commit dd5efb7175c48ede58ca900bc389ebe6821d2f34 Author: korenkonder Date: Tue Dec 5 19:03:23 2023 +0300 First commit diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..3517e98 --- /dev/null +++ b/.gitignore @@ -0,0 +1,8 @@ +.vs +bin +lib +obj +src/KKdLib +*.aps +*.cs +!extern/lib diff --git a/DivaGL.sln b/DivaGL.sln new file mode 100644 index 0000000..3425cc9 --- /dev/null +++ b/DivaGL.sln @@ -0,0 +1,40 @@ +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio Version 16 +VisualStudioVersion = 16.0.30320.27 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "DivaGL", "src\DivaGL\DivaGL.vcxproj", "{4D949362-9095-4113-9423-7E0492618F16}" +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "KKdLib", "src\KKdLib\KKdLib.vcxproj", "{4C9636B9-E5B6-41E5-9AFC-5B33CC9633DE}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|x64 = Debug|x64 + DebugDLL|x64 = DebugDLL|x64 + Release|x64 = Release|x64 + ReleaseDLL|x64 = ReleaseDLL|x64 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {4D949362-9095-4113-9423-7E0492618F16}.Debug|x64.ActiveCfg = Debug|x64 + {4D949362-9095-4113-9423-7E0492618F16}.Debug|x64.Build.0 = Debug|x64 + {4D949362-9095-4113-9423-7E0492618F16}.DebugDLL|x64.ActiveCfg = DebugDLL|x64 + {4D949362-9095-4113-9423-7E0492618F16}.DebugDLL|x64.Build.0 = DebugDLL|x64 + {4D949362-9095-4113-9423-7E0492618F16}.Release|x64.ActiveCfg = Release|x64 + {4D949362-9095-4113-9423-7E0492618F16}.Release|x64.Build.0 = Release|x64 + {4D949362-9095-4113-9423-7E0492618F16}.ReleaseDLL|x64.ActiveCfg = ReleaseDLL|x64 + {4D949362-9095-4113-9423-7E0492618F16}.ReleaseDLL|x64.Build.0 = ReleaseDLL|x64 + {4C9636B9-E5B6-41E5-9AFC-5B33CC9633DE}.Debug|x64.ActiveCfg = DebugOpt|x64 + {4C9636B9-E5B6-41E5-9AFC-5B33CC9633DE}.Debug|x64.Build.0 = DebugOpt|x64 + {4C9636B9-E5B6-41E5-9AFC-5B33CC9633DE}.DebugDLL|x64.ActiveCfg = DebugOpt|x64 + {4C9636B9-E5B6-41E5-9AFC-5B33CC9633DE}.DebugDLL|x64.Build.0 = DebugOpt|x64 + {4C9636B9-E5B6-41E5-9AFC-5B33CC9633DE}.Release|x64.ActiveCfg = Release|x64 + {4C9636B9-E5B6-41E5-9AFC-5B33CC9633DE}.Release|x64.Build.0 = Release|x64 + {4C9636B9-E5B6-41E5-9AFC-5B33CC9633DE}.ReleaseDLL|x64.ActiveCfg = Release|x64 + {4C9636B9-E5B6-41E5-9AFC-5B33CC9633DE}.ReleaseDLL|x64.Build.0 = Release|x64 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection + GlobalSection(ExtensibilityGlobals) = postSolution + SolutionGuid = {90795F07-C3EF-4F00-A79A-0647DBB7117E} + EndGlobalSection +EndGlobal diff --git a/extern/lib/detours.lib b/extern/lib/detours.lib new file mode 100644 index 0000000..27fbf1f Binary files /dev/null and b/extern/lib/detours.lib differ diff --git a/extern/lib/detours.pdb b/extern/lib/detours.pdb new file mode 100644 index 0000000..095f79f Binary files /dev/null and b/extern/lib/detours.pdb differ diff --git a/extern/lib/libdeflatestatic.lib b/extern/lib/libdeflatestatic.lib new file mode 100644 index 0000000..2c457d1 Binary files /dev/null and b/extern/lib/libdeflatestatic.lib differ diff --git a/extern/lib/libdeflatestatic.pdb b/extern/lib/libdeflatestatic.pdb new file mode 100644 index 0000000..19fdb49 Binary files /dev/null and b/extern/lib/libdeflatestatic.pdb differ diff --git a/extern/lib/syelog.lib b/extern/lib/syelog.lib new file mode 100644 index 0000000..e8d1d68 Binary files /dev/null and b/extern/lib/syelog.lib differ diff --git a/extern/src/Helpers.h b/extern/src/Helpers.h new file mode 100644 index 0000000..94d1192 --- /dev/null +++ b/extern/src/Helpers.h @@ -0,0 +1,169 @@ +#pragma once + +#include "detours.h" + +#define _CONCAT2(x, y) x##y +#define CONCAT2(x, y) _CONCAT(x, y) +#define INSERT_PADDING(length) \ + uint8_t CONCAT2(pad, __LINE__)[length] + +#define ASSERT_OFFSETOF(type, field, offset) \ + static_assert(offsetof(type, field) == offset, "offsetof assertion failed") + +#define ASSERT_SIZEOF(type, size) \ + static_assert(sizeof(type) == size, "sizeof assertion failed") + +#ifdef BASE_ADDRESS +const HMODULE MODULE_HANDLE = GetModuleHandle(nullptr); + +#define ASLR(address) \ + ((size_t)MODULE_HANDLE + (size_t)address - (size_t)BASE_ADDRESS) +#endif + +#define FUNCTION_PTR(returnType, callingConvention, function, location, ...) \ + returnType (callingConvention *function)(__VA_ARGS__) = (returnType(callingConvention*)(__VA_ARGS__))(location) + +#define FUNCTION_PTR_H(returnType, callingConvention, function, ...) \ + extern returnType (callingConvention *function) (__VA_ARGS__) + +#define PROC_ADDRESS(libraryName, procName) \ + GetProcAddress(LoadLibrary(TEXT(libraryName)), procName) + +#define HOOK(returnType, callingConvention, functionName, location, ...) \ + typedef returnType callingConvention _##functionName(__VA_ARGS__); \ + _##functionName* original##functionName = (_##functionName*)(location); \ + returnType callingConvention implOf##functionName(__VA_ARGS__) + +#define INSTALL_HOOK(functionName) \ + { \ + DetourTransactionBegin(); \ + DetourUpdateThread(GetCurrentThread()); \ + DetourAttach((void**)&original##functionName, implOf##functionName); \ + DetourTransactionCommit(); \ + } + +#define VTABLE_HOOK(returnType, callingConvention, className, functionName, ...) \ + typedef returnType callingConvention className##functionName(className* This, __VA_ARGS__); \ + className##functionName* original##className##functionName; \ + returnType callingConvention implOf##className##functionName(className* This, __VA_ARGS__) + +#define INSTALL_VTABLE_HOOK(className, object, functionName, functionIndex) \ + { \ + void** addr = &(*(void***)object)[functionIndex]; \ + if (*addr != implOf##className##functionName) \ + { \ + original##className##functionName = (className##functionName*)*addr; \ + DWORD oldProtect; \ + VirtualProtect(addr, sizeof(void*), PAGE_EXECUTE_READWRITE, &oldProtect); \ + *addr = implOf##className##functionName; \ + VirtualProtect(addr, sizeof(void*), oldProtect, &oldProtect); \ + } \ + } + +#define READ_MEMORY(location, type) \ + *(type *)location + +#define WRITE_MEMORY(location, type, ...) \ + { \ + const type data[] = { __VA_ARGS__ }; \ + DWORD oldProtect; \ + VirtualProtect((void*)(location), sizeof(data), PAGE_EXECUTE_READWRITE, &oldProtect); \ + memcpy((void*)(location), data, sizeof(data)); \ + VirtualProtect((void*)(location), sizeof(data), oldProtect, &oldProtect); \ + } + +#define WRITE_MEMORY_STRING(location, data, length) \ + { \ + DWORD oldProtect; \ + VirtualProtect ((void *)(location), length, PAGE_EXECUTE_READWRITE, &oldProtect); \ + memcpy ((void *)(location), data, length); \ + VirtualProtect ((void *)(location), length, oldProtect, &oldProtect); \ + } + +#define WRITE_JUMP(location, function) \ + { \ + WRITE_MEMORY(location, uint8_t, 0xE9); \ + WRITE_MEMORY(location + 1, uint32_t, (uint32_t)(function - location - 5)); \ + } + +#define WRITE_CALL(location, function) \ + { \ + WRITE_MEMORY(location, uint8_t, 0xE8); \ + WRITE_MEMORY(location + 1, uint32_t, (uint32_t)(function - location - 5)); \ + } + +#define WRITE_NOP(location, count) \ + { \ + DWORD oldProtect; \ + VirtualProtect((void*)(location), (size_t)(count), PAGE_EXECUTE_READWRITE, &oldProtect); \ + for (size_t i = 0; i < (size_t)(count); i++) \ + *((uint8_t*)(location) + i) = 0x90; \ + VirtualProtect((void*)(location), (size_t)(count), oldProtect, &oldProtect); \ + } + +#define WRITE_NOP_1(location) \ + { \ + WRITE_MEMORY(location, uint8_t, 0x90); \ + } + +#define WRITE_NOP_2(location) \ + { \ + WRITE_MEMORY(location, uint8_t, 0x66, 0x90); \ + } + +#define WRITE_NOP_3(location) \ + { \ + WRITE_MEMORY(location, uint8_t, 0x0F, 0x1F, 0x00); \ + } + +#define WRITE_NOP_4(location) \ + { \ + WRITE_MEMORY(location, uint8_t, 0x0F, 0x1F, 0x40, 0x00); \ + } + +#define WRITE_NOP_5(location) \ + { \ + WRITE_MEMORY(location, uint8_t, 0x0F, 0x1F, 0x44, 0x00, 0x00); \ + } + +#define WRITE_NOP_6(location) \ + { \ + WRITE_MEMORY(location, uint8_t, 0x66, 0x0F, 0x1F, 0x44, 0x00, 0x00); \ + } + +#define WRITE_NOP_7(location) \ + { \ + WRITE_MEMORY(location, uint8_t, 0x0F, 0x1F, 0x80, 0x00, 0x00, 0x00, 0x00); \ + } + +#define WRITE_NOP_8(location) \ + { \ + WRITE_MEMORY(location, uint8_t, 0x0F, 0x1F, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00); \ + } + +#define WRITE_NOP_9(location) \ + { \ + WRITE_MEMORY(location, uint8_t, 0x66, 0x0F, 0x1F, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00); \ + } + +#define WRITE_NOP_10(location) \ + { \ + WRITE_MEMORY(location, uint8_t, 0x66, 0x66, 0x0F, 0x1F, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00); \ + } + +#define WRITE_NOP_11(location) \ + { \ + WRITE_MEMORY(location, uint8_t, 0x66, 0x66, 0x66, 0x0F, 0x1F, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00); \ + } + +#define WRITE_NULL(location, count) \ + { \ + DWORD oldProtect; \ + VirtualProtect((void*)(location), (size_t)(count), PAGE_EXECUTE_READWRITE, &oldProtect); \ + for (size_t i = 0; i < (size_t)(count); i++) \ + *((uint8_t*)(location) + i) = 0x00; \ + VirtualProtect((void*)(location), (size_t)(count), oldProtect, &oldProtect); \ + } + +#define COUNTOFARR(arr) \ + sizeof(arr) / sizeof(arr[0]) diff --git a/extern/src/SigScan.h b/extern/src/SigScan.h new file mode 100644 index 0000000..f5ed89d --- /dev/null +++ b/extern/src/SigScan.h @@ -0,0 +1,111 @@ +#pragma once + +#include + +FORCEINLINE const MODULEINFO& getModuleInfo() { + static MODULEINFO moduleInfo; + + if (moduleInfo.SizeOfImage) + return moduleInfo; + + ZeroMemory(&moduleInfo, sizeof(MODULEINFO)); + GetModuleInformation(GetCurrentProcess(), GetModuleHandle(nullptr), &moduleInfo, sizeof(MODULEINFO)); + + return moduleInfo; +} + +// Signature scan in specified memory region +FORCEINLINE void* sigScan(const char* signature, const char* mask, size_t sigSize, void* memory, const size_t memorySize) { + if (sigSize == 0) + sigSize = strlen(mask); + + for (size_t i = 0; i < memorySize; i++) { + char* currMemory = (char*)memory + i; + + size_t j; + for (j = 0; j < sigSize; j++) { + if (mask[j] != '?' && signature[j] != currMemory[j]) + break; + } + + if (j == sigSize) + return currMemory; + } + + return nullptr; +} + +// Signature scan in current process +FORCEINLINE void* sigScan(const char* signature, const char* mask, void* hint) { + const MODULEINFO& info = getModuleInfo(); + const size_t sigSize = strlen(mask); + + // Ensure hint address is within the process memory region so there are no crashes. + if ((hint >= info.lpBaseOfDll) && ((char*)hint + sigSize <= (char*)info.lpBaseOfDll + info.SizeOfImage)) { + void* result = sigScan(signature, mask, sigSize, hint, sigSize); + + if (result) + return result; + } + + return sigScan(signature, mask, sigSize, info.lpBaseOfDll, info.SizeOfImage); +} + +// Signature scan string in specified memory region +FORCEINLINE void* sigScanString(const char* signature, void* memory, const size_t memorySize) { + const size_t sigSize = strlen(signature); + + for (size_t i = 0; i < memorySize; i++) { + char* currMemory = (char*)memory + i; + + if (!memcmp(signature, currMemory, sigSize)) + return currMemory; + } + + return nullptr; +} + +// Signature scan string in current process +FORCEINLINE void* sigScanString(const char* signature) { + const MODULEINFO& info = getModuleInfo(); + return sigScanString(signature, info.lpBaseOfDll, info.SizeOfImage); +} + +// Automatically scanned signature +#define SIG_SCAN(x, y, ...) \ + FORCEINLINE void* x(); \ + inline bool x##Valid = true; \ + inline void* x##Addr = x(); \ + FORCEINLINE void* x() { \ + constexpr const char* x##Data[] = { __VA_ARGS__ }; \ + constexpr size_t x##Size = _countof(x##Data); \ + if (!x##Addr) { \ + if constexpr (x##Size == 2) { \ + x##Addr = sigScan(x##Data[0], x##Data[1], (void*)(y)); \ + if (x##Addr) \ + return x##Addr; \ + } \ + else \ + for (int i = 0; i < x##Size; i += 2) { \ + x##Addr = sigScan(x##Data[i], x##Data[i + 1], (void*)(y)); \ + if (x##Addr) \ + return x##Addr; \ + } \ + x##Valid = false; \ + } \ + return x##Addr; \ + } + +#define SIG_SCAN_STRING(x, y) \ + FORCEINLINE void* x(); \ + inline bool x##Valid = true; \ + inline void* x##Addr = x(); \ + FORCEINLINE void* x() { \ + if (!x##Addr) { \ + x##Addr = sigScanString(y); \ + if (x##Addr) \ + return x##Addr; \ + x##Valid = false; \ + } \ + return x##Addr; \ + } diff --git a/extern/src/detours.h b/extern/src/detours.h new file mode 100644 index 0000000..f3738af --- /dev/null +++ b/extern/src/detours.h @@ -0,0 +1,1233 @@ +///////////////////////////////////////////////////////////////////////////// +// +// Core Detours Functionality (detours.h of detours.lib) +// +// Microsoft Research Detours Package, Version 4.0.1 +// +// Copyright (c) Microsoft Corporation. All rights reserved. +// + +#pragma once +#ifndef _DETOURS_H_ +#define _DETOURS_H_ + +#define DETOURS_VERSION 0x4c0c1 // 0xMAJORcMINORcPATCH + +////////////////////////////////////////////////////////////////////////////// +// + +#ifdef DETOURS_INTERNAL + +#define _CRT_STDIO_ARBITRARY_WIDE_SPECIFIERS 1 +#define _ARM_WINAPI_PARTITION_DESKTOP_SDK_AVAILABLE 1 + +#pragma warning(disable:4068) // unknown pragma (suppress) + +#if _MSC_VER >= 1900 +#pragma warning(push) +#pragma warning(disable:4091) // empty typedef +#endif + +// Suppress declspec(dllimport) for the sake of Detours +// users that provide kernel32 functionality themselves. +// This is ok in the mainstream case, it will just cost +// an extra instruction calling some functions, which +// LTCG optimizes away. +// +#define _KERNEL32_ 1 +#define _USER32_ 1 + +#include +#if (_MSC_VER < 1310) +#else +#pragma warning(push) +#if _MSC_VER > 1400 +#pragma warning(disable:6102 6103) // /analyze warnings +#endif +#include +#include +#pragma warning(pop) +#endif +#include + +// Allow Detours to cleanly compile with the MingW toolchain. +// +#ifdef __GNUC__ +#define __try +#define __except(x) if (0) +#include +#include +#endif + +// From winerror.h, as this error isn't found in some SDKs: +// +// MessageId: ERROR_DYNAMIC_CODE_BLOCKED +// +// MessageText: +// +// The operation was blocked as the process prohibits dynamic code generation. +// +#define ERROR_DYNAMIC_CODE_BLOCKED 1655L + +#endif // DETOURS_INTERNAL + +////////////////////////////////////////////////////////////////////////////// +// + +#undef DETOURS_X64 +#undef DETOURS_X86 +#undef DETOURS_IA64 +#undef DETOURS_ARM +#undef DETOURS_ARM64 +#undef DETOURS_BITS +#undef DETOURS_32BIT +#undef DETOURS_64BIT + +#if defined(_X86_) +#define DETOURS_X86 +#define DETOURS_OPTION_BITS 64 + +#elif defined(_AMD64_) +#define DETOURS_X64 +#define DETOURS_OPTION_BITS 32 + +#elif defined(_IA64_) +#define DETOURS_IA64 +#define DETOURS_OPTION_BITS 32 + +#elif defined(_ARM_) +#define DETOURS_ARM + +#elif defined(_ARM64_) +#define DETOURS_ARM64 + +#else +#error Unknown architecture (x86, amd64, ia64, arm, arm64) +#endif + +#ifdef _WIN64 +#undef DETOURS_32BIT +#define DETOURS_64BIT 1 +#define DETOURS_BITS 64 +// If all 64bit kernels can run one and only one 32bit architecture. +//#define DETOURS_OPTION_BITS 32 +#else +#define DETOURS_32BIT 1 +#undef DETOURS_64BIT +#define DETOURS_BITS 32 +// If all 64bit kernels can run one and only one 32bit architecture. +//#define DETOURS_OPTION_BITS 32 +#endif + +/////////////////////////////////////////////////////////////// Helper Macros. +// +#define DETOURS_STRINGIFY_(x) #x +#define DETOURS_STRINGIFY(x) DETOURS_STRINGIFY_(x) + +#define VER_DETOURS_BITS DETOURS_STRINGIFY(DETOURS_BITS) + +////////////////////////////////////////////////////////////////////////////// +// + +#if (_MSC_VER < 1299) && !defined(__MINGW32__) +typedef LONG LONG_PTR; +typedef ULONG ULONG_PTR; +#endif + +///////////////////////////////////////////////// SAL 2.0 Annotations w/o SAL. +// +// These definitions are include so that Detours will build even if the +// compiler doesn't have full SAL 2.0 support. +// +#ifndef DETOURS_DONT_REMOVE_SAL_20 + +#ifdef DETOURS_TEST_REMOVE_SAL_20 +#undef _Analysis_assume_ +#undef _Benign_race_begin_ +#undef _Benign_race_end_ +#undef _Field_range_ +#undef _Field_size_ +#undef _In_ +#undef _In_bytecount_ +#undef _In_count_ +#undef __in_ecount +#undef _In_opt_ +#undef _In_opt_bytecount_ +#undef _In_opt_count_ +#undef _In_opt_z_ +#undef _In_range_ +#undef _In_reads_ +#undef _In_reads_bytes_ +#undef _In_reads_opt_ +#undef _In_reads_opt_bytes_ +#undef _In_reads_or_z_ +#undef _In_z_ +#undef _Inout_ +#undef _Inout_opt_ +#undef _Inout_z_count_ +#undef _Out_ +#undef _Out_opt_ +#undef _Out_writes_ +#undef _Outptr_result_maybenull_ +#undef _Readable_bytes_ +#undef _Success_ +#undef _Writable_bytes_ +#undef _Pre_notnull_ +#endif + +#if defined(_Deref_out_opt_z_) && !defined(_Outptr_result_maybenull_) +#define _Outptr_result_maybenull_ _Deref_out_opt_z_ +#endif + +#if defined(_In_count_) && !defined(_In_reads_) +#define _In_reads_(x) _In_count_(x) +#endif + +#if defined(_In_opt_count_) && !defined(_In_reads_opt_) +#define _In_reads_opt_(x) _In_opt_count_(x) +#endif + +#if defined(_In_opt_bytecount_) && !defined(_In_reads_opt_bytes_) +#define _In_reads_opt_bytes_(x) _In_opt_bytecount_(x) +#endif + +#if defined(_In_bytecount_) && !defined(_In_reads_bytes_) +#define _In_reads_bytes_(x) _In_bytecount_(x) +#endif + +#ifndef _In_ +#define _In_ +#endif + +#ifndef _In_bytecount_ +#define _In_bytecount_(x) +#endif + +#ifndef _In_count_ +#define _In_count_(x) +#endif + +#ifndef __in_ecount +#define __in_ecount(x) +#endif + +#ifndef _In_opt_ +#define _In_opt_ +#endif + +#ifndef _In_opt_bytecount_ +#define _In_opt_bytecount_(x) +#endif + +#ifndef _In_opt_count_ +#define _In_opt_count_(x) +#endif + +#ifndef _In_opt_z_ +#define _In_opt_z_ +#endif + +#ifndef _In_range_ +#define _In_range_(x,y) +#endif + +#ifndef _In_reads_ +#define _In_reads_(x) +#endif + +#ifndef _In_reads_bytes_ +#define _In_reads_bytes_(x) +#endif + +#ifndef _In_reads_opt_ +#define _In_reads_opt_(x) +#endif + +#ifndef _In_reads_opt_bytes_ +#define _In_reads_opt_bytes_(x) +#endif + +#ifndef _In_reads_or_z_ +#define _In_reads_or_z_ +#endif + +#ifndef _In_z_ +#define _In_z_ +#endif + +#ifndef _Inout_ +#define _Inout_ +#endif + +#ifndef _Inout_opt_ +#define _Inout_opt_ +#endif + +#ifndef _Inout_z_count_ +#define _Inout_z_count_(x) +#endif + +#ifndef _Out_ +#define _Out_ +#endif + +#ifndef _Out_opt_ +#define _Out_opt_ +#endif + +#ifndef _Out_writes_ +#define _Out_writes_(x) +#endif + +#ifndef _Outptr_result_maybenull_ +#define _Outptr_result_maybenull_ +#endif + +#ifndef _Writable_bytes_ +#define _Writable_bytes_(x) +#endif + +#ifndef _Readable_bytes_ +#define _Readable_bytes_(x) +#endif + +#ifndef _Success_ +#define _Success_(x) +#endif + +#ifndef _Pre_notnull_ +#define _Pre_notnull_ +#endif + +#ifdef DETOURS_INTERNAL + +#pragma warning(disable:4615) // unknown warning type (suppress with older compilers) + +#ifndef _Benign_race_begin_ +#define _Benign_race_begin_ +#endif + +#ifndef _Benign_race_end_ +#define _Benign_race_end_ +#endif + +#ifndef _Field_size_ +#define _Field_size_(x) +#endif + +#ifndef _Field_range_ +#define _Field_range_(x,y) +#endif + +#ifndef _Analysis_assume_ +#define _Analysis_assume_(x) +#endif + +#endif // DETOURS_INTERNAL +#endif // DETOURS_DONT_REMOVE_SAL_20 + +////////////////////////////////////////////////////////////////////////////// +// +#ifndef GUID_DEFINED +#define GUID_DEFINED +typedef struct _GUID +{ + DWORD Data1; + WORD Data2; + WORD Data3; + BYTE Data4[ 8 ]; +} GUID; + +#ifdef INITGUID +#define DEFINE_GUID(name, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8) \ + const GUID name \ + = { l, w1, w2, { b1, b2, b3, b4, b5, b6, b7, b8 } } +#else +#define DEFINE_GUID(name, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8) \ + const GUID name +#endif // INITGUID +#endif // !GUID_DEFINED + +#if defined(__cplusplus) +#ifndef _REFGUID_DEFINED +#define _REFGUID_DEFINED +#define REFGUID const GUID & +#endif // !_REFGUID_DEFINED +#else // !__cplusplus +#ifndef _REFGUID_DEFINED +#define _REFGUID_DEFINED +#define REFGUID const GUID * const +#endif // !_REFGUID_DEFINED +#endif // !__cplusplus + +#ifndef ARRAYSIZE +#define ARRAYSIZE(x) (sizeof(x)/sizeof(x[0])) +#endif + +// +////////////////////////////////////////////////////////////////////////////// + +#ifdef __cplusplus +extern "C" { +#endif // __cplusplus + +/////////////////////////////////////////////////// Instruction Target Macros. +// +#define DETOUR_INSTRUCTION_TARGET_NONE ((PVOID)0) +#define DETOUR_INSTRUCTION_TARGET_DYNAMIC ((PVOID)(LONG_PTR)-1) +#define DETOUR_SECTION_HEADER_SIGNATURE 0x00727444 // "Dtr\0" + +extern const GUID DETOUR_EXE_RESTORE_GUID; +extern const GUID DETOUR_EXE_HELPER_GUID; + +#define DETOUR_TRAMPOLINE_SIGNATURE 0x21727444 // Dtr! +typedef struct _DETOUR_TRAMPOLINE DETOUR_TRAMPOLINE, *PDETOUR_TRAMPOLINE; + +#ifndef DETOUR_MAX_SUPPORTED_IMAGE_SECTION_HEADERS +#define DETOUR_MAX_SUPPORTED_IMAGE_SECTION_HEADERS 32 +#endif // !DETOUR_MAX_SUPPORTED_IMAGE_SECTION_HEADERS + +/////////////////////////////////////////////////////////// Binary Structures. +// +#pragma pack(push, 8) +typedef struct _DETOUR_SECTION_HEADER +{ + DWORD cbHeaderSize; + DWORD nSignature; + DWORD nDataOffset; + DWORD cbDataSize; + + DWORD nOriginalImportVirtualAddress; + DWORD nOriginalImportSize; + DWORD nOriginalBoundImportVirtualAddress; + DWORD nOriginalBoundImportSize; + + DWORD nOriginalIatVirtualAddress; + DWORD nOriginalIatSize; + DWORD nOriginalSizeOfImage; + DWORD cbPrePE; + + DWORD nOriginalClrFlags; + DWORD reserved1; + DWORD reserved2; + DWORD reserved3; + + // Followed by cbPrePE bytes of data. +} DETOUR_SECTION_HEADER, *PDETOUR_SECTION_HEADER; + +typedef struct _DETOUR_SECTION_RECORD +{ + DWORD cbBytes; + DWORD nReserved; + GUID guid; +} DETOUR_SECTION_RECORD, *PDETOUR_SECTION_RECORD; + +typedef struct _DETOUR_CLR_HEADER +{ + // Header versioning + ULONG cb; + USHORT MajorRuntimeVersion; + USHORT MinorRuntimeVersion; + + // Symbol table and startup information + IMAGE_DATA_DIRECTORY MetaData; + ULONG Flags; + + // Followed by the rest of the IMAGE_COR20_HEADER +} DETOUR_CLR_HEADER, *PDETOUR_CLR_HEADER; + +typedef struct _DETOUR_EXE_RESTORE +{ + DWORD cb; + DWORD cbidh; + DWORD cbinh; + DWORD cbclr; + + PBYTE pidh; + PBYTE pinh; + PBYTE pclr; + + IMAGE_DOS_HEADER idh; + union { + IMAGE_NT_HEADERS inh; // all environments have this +#ifdef IMAGE_NT_OPTIONAL_HDR32_MAGIC // some environments do not have this + IMAGE_NT_HEADERS32 inh32; +#endif +#ifdef IMAGE_NT_OPTIONAL_HDR64_MAGIC // some environments do not have this + IMAGE_NT_HEADERS64 inh64; +#endif +#ifdef IMAGE_NT_OPTIONAL_HDR64_MAGIC // some environments do not have this + BYTE raw[sizeof(IMAGE_NT_HEADERS64) + + sizeof(IMAGE_SECTION_HEADER) * DETOUR_MAX_SUPPORTED_IMAGE_SECTION_HEADERS]; +#else + BYTE raw[0x108 + sizeof(IMAGE_SECTION_HEADER) * DETOUR_MAX_SUPPORTED_IMAGE_SECTION_HEADERS]; +#endif + }; + DETOUR_CLR_HEADER clr; + +} DETOUR_EXE_RESTORE, *PDETOUR_EXE_RESTORE; + +#ifdef IMAGE_NT_OPTIONAL_HDR64_MAGIC +C_ASSERT(sizeof(IMAGE_NT_HEADERS64) == 0x108); +#endif + +// The size can change, but assert for clarity due to the muddying #ifdefs. +#ifdef _WIN64 +C_ASSERT(sizeof(DETOUR_EXE_RESTORE) == 0x688); +#else +C_ASSERT(sizeof(DETOUR_EXE_RESTORE) == 0x678); +#endif + +typedef struct _DETOUR_EXE_HELPER +{ + DWORD cb; + DWORD pid; + DWORD nDlls; + CHAR rDlls[4]; +} DETOUR_EXE_HELPER, *PDETOUR_EXE_HELPER; + +#pragma pack(pop) + +#define DETOUR_SECTION_HEADER_DECLARE(cbSectionSize) \ +{ \ + sizeof(DETOUR_SECTION_HEADER),\ + DETOUR_SECTION_HEADER_SIGNATURE,\ + sizeof(DETOUR_SECTION_HEADER),\ + (cbSectionSize),\ + \ + 0,\ + 0,\ + 0,\ + 0,\ + \ + 0,\ + 0,\ + 0,\ + 0,\ +} + +///////////////////////////////////////////////////////////// Binary Typedefs. +// +typedef BOOL (CALLBACK *PF_DETOUR_BINARY_BYWAY_CALLBACK)( + _In_opt_ PVOID pContext, + _In_opt_ LPCSTR pszFile, + _Outptr_result_maybenull_ LPCSTR *ppszOutFile); + +typedef BOOL (CALLBACK *PF_DETOUR_BINARY_FILE_CALLBACK)( + _In_opt_ PVOID pContext, + _In_ LPCSTR pszOrigFile, + _In_ LPCSTR pszFile, + _Outptr_result_maybenull_ LPCSTR *ppszOutFile); + +typedef BOOL (CALLBACK *PF_DETOUR_BINARY_SYMBOL_CALLBACK)( + _In_opt_ PVOID pContext, + _In_ ULONG nOrigOrdinal, + _In_ ULONG nOrdinal, + _Out_ ULONG *pnOutOrdinal, + _In_opt_ LPCSTR pszOrigSymbol, + _In_opt_ LPCSTR pszSymbol, + _Outptr_result_maybenull_ LPCSTR *ppszOutSymbol); + +typedef BOOL (CALLBACK *PF_DETOUR_BINARY_COMMIT_CALLBACK)( + _In_opt_ PVOID pContext); + +typedef BOOL (CALLBACK *PF_DETOUR_ENUMERATE_EXPORT_CALLBACK)(_In_opt_ PVOID pContext, + _In_ ULONG nOrdinal, + _In_opt_ LPCSTR pszName, + _In_opt_ PVOID pCode); + +typedef BOOL (CALLBACK *PF_DETOUR_IMPORT_FILE_CALLBACK)(_In_opt_ PVOID pContext, + _In_opt_ HMODULE hModule, + _In_opt_ LPCSTR pszFile); + +typedef BOOL (CALLBACK *PF_DETOUR_IMPORT_FUNC_CALLBACK)(_In_opt_ PVOID pContext, + _In_ DWORD nOrdinal, + _In_opt_ LPCSTR pszFunc, + _In_opt_ PVOID pvFunc); + +// Same as PF_DETOUR_IMPORT_FUNC_CALLBACK but extra indirection on last parameter. +typedef BOOL (CALLBACK *PF_DETOUR_IMPORT_FUNC_CALLBACK_EX)(_In_opt_ PVOID pContext, + _In_ DWORD nOrdinal, + _In_opt_ LPCSTR pszFunc, + _In_opt_ PVOID* ppvFunc); + +typedef VOID * PDETOUR_BINARY; +typedef VOID * PDETOUR_LOADED_BINARY; + +//////////////////////////////////////////////////////////// Transaction APIs. +// +LONG WINAPI DetourTransactionBegin(VOID); +LONG WINAPI DetourTransactionAbort(VOID); +LONG WINAPI DetourTransactionCommit(VOID); +LONG WINAPI DetourTransactionCommitEx(_Out_opt_ PVOID **pppFailedPointer); + +LONG WINAPI DetourUpdateThread(_In_ HANDLE hThread); + +LONG WINAPI DetourAttach(_Inout_ PVOID *ppPointer, + _In_ PVOID pDetour); + +LONG WINAPI DetourAttachEx(_Inout_ PVOID *ppPointer, + _In_ PVOID pDetour, + _Out_opt_ PDETOUR_TRAMPOLINE *ppRealTrampoline, + _Out_opt_ PVOID *ppRealTarget, + _Out_opt_ PVOID *ppRealDetour); + +LONG WINAPI DetourDetach(_Inout_ PVOID *ppPointer, + _In_ PVOID pDetour); + +BOOL WINAPI DetourSetIgnoreTooSmall(_In_ BOOL fIgnore); +BOOL WINAPI DetourSetRetainRegions(_In_ BOOL fRetain); +PVOID WINAPI DetourSetSystemRegionLowerBound(_In_ PVOID pSystemRegionLowerBound); +PVOID WINAPI DetourSetSystemRegionUpperBound(_In_ PVOID pSystemRegionUpperBound); + +////////////////////////////////////////////////////////////// Code Functions. +// +PVOID WINAPI DetourFindFunction(_In_ LPCSTR pszModule, + _In_ LPCSTR pszFunction); +PVOID WINAPI DetourCodeFromPointer(_In_ PVOID pPointer, + _Out_opt_ PVOID *ppGlobals); +PVOID WINAPI DetourCopyInstruction(_In_opt_ PVOID pDst, + _Inout_opt_ PVOID *ppDstPool, + _In_ PVOID pSrc, + _Out_opt_ PVOID *ppTarget, + _Out_opt_ LONG *plExtra); +BOOL WINAPI DetourSetCodeModule(_In_ HMODULE hModule, + _In_ BOOL fLimitReferencesToModule); +PVOID WINAPI DetourAllocateRegionWithinJumpBounds(_In_ LPCVOID pbTarget, + _Out_ PDWORD pcbAllocatedSize); +BOOL WINAPI DetourIsFunctionImported(_In_ PBYTE pbCode, + _In_ PBYTE pbAddress); + +///////////////////////////////////////////////////// Loaded Binary Functions. +// +HMODULE WINAPI DetourGetContainingModule(_In_ PVOID pvAddr); +HMODULE WINAPI DetourEnumerateModules(_In_opt_ HMODULE hModuleLast); +PVOID WINAPI DetourGetEntryPoint(_In_opt_ HMODULE hModule); +ULONG WINAPI DetourGetModuleSize(_In_opt_ HMODULE hModule); +BOOL WINAPI DetourEnumerateExports(_In_ HMODULE hModule, + _In_opt_ PVOID pContext, + _In_ PF_DETOUR_ENUMERATE_EXPORT_CALLBACK pfExport); +BOOL WINAPI DetourEnumerateImports(_In_opt_ HMODULE hModule, + _In_opt_ PVOID pContext, + _In_opt_ PF_DETOUR_IMPORT_FILE_CALLBACK pfImportFile, + _In_opt_ PF_DETOUR_IMPORT_FUNC_CALLBACK pfImportFunc); + +BOOL WINAPI DetourEnumerateImportsEx(_In_opt_ HMODULE hModule, + _In_opt_ PVOID pContext, + _In_opt_ PF_DETOUR_IMPORT_FILE_CALLBACK pfImportFile, + _In_opt_ PF_DETOUR_IMPORT_FUNC_CALLBACK_EX pfImportFuncEx); + +_Writable_bytes_(*pcbData) +_Readable_bytes_(*pcbData) +_Success_(return != NULL) +PVOID WINAPI DetourFindPayload(_In_opt_ HMODULE hModule, + _In_ REFGUID rguid, + _Out_opt_ DWORD *pcbData); + +_Writable_bytes_(*pcbData) +_Readable_bytes_(*pcbData) +_Success_(return != NULL) +PVOID WINAPI DetourFindPayloadEx(_In_ REFGUID rguid, + _Out_opt_ DWORD *pcbData); + +DWORD WINAPI DetourGetSizeOfPayloads(_In_opt_ HMODULE hModule); + +BOOL WINAPI DetourFreePayload(_In_ PVOID pvData); +///////////////////////////////////////////////// Persistent Binary Functions. +// + +PDETOUR_BINARY WINAPI DetourBinaryOpen(_In_ HANDLE hFile); + +_Writable_bytes_(*pcbData) +_Readable_bytes_(*pcbData) +_Success_(return != NULL) +PVOID WINAPI DetourBinaryEnumeratePayloads(_In_ PDETOUR_BINARY pBinary, + _Out_opt_ GUID *pGuid, + _Out_ DWORD *pcbData, + _Inout_ DWORD *pnIterator); + +_Writable_bytes_(*pcbData) +_Readable_bytes_(*pcbData) +_Success_(return != NULL) +PVOID WINAPI DetourBinaryFindPayload(_In_ PDETOUR_BINARY pBinary, + _In_ REFGUID rguid, + _Out_ DWORD *pcbData); + +PVOID WINAPI DetourBinarySetPayload(_In_ PDETOUR_BINARY pBinary, + _In_ REFGUID rguid, + _In_reads_opt_(cbData) PVOID pData, + _In_ DWORD cbData); +BOOL WINAPI DetourBinaryDeletePayload(_In_ PDETOUR_BINARY pBinary, _In_ REFGUID rguid); +BOOL WINAPI DetourBinaryPurgePayloads(_In_ PDETOUR_BINARY pBinary); +BOOL WINAPI DetourBinaryResetImports(_In_ PDETOUR_BINARY pBinary); +BOOL WINAPI DetourBinaryEditImports(_In_ PDETOUR_BINARY pBinary, + _In_opt_ PVOID pContext, + _In_opt_ PF_DETOUR_BINARY_BYWAY_CALLBACK pfByway, + _In_opt_ PF_DETOUR_BINARY_FILE_CALLBACK pfFile, + _In_opt_ PF_DETOUR_BINARY_SYMBOL_CALLBACK pfSymbol, + _In_opt_ PF_DETOUR_BINARY_COMMIT_CALLBACK pfCommit); +BOOL WINAPI DetourBinaryWrite(_In_ PDETOUR_BINARY pBinary, _In_ HANDLE hFile); +BOOL WINAPI DetourBinaryClose(_In_ PDETOUR_BINARY pBinary); + +/////////////////////////////////////////////////// Create Process & Load Dll. +// +_Success_(return != NULL) +PVOID WINAPI DetourFindRemotePayload(_In_ HANDLE hProcess, + _In_ REFGUID rguid, + _Out_opt_ DWORD *pcbData); + +typedef BOOL (WINAPI *PDETOUR_CREATE_PROCESS_ROUTINEA)( + _In_opt_ LPCSTR lpApplicationName, + _Inout_opt_ LPSTR lpCommandLine, + _In_opt_ LPSECURITY_ATTRIBUTES lpProcessAttributes, + _In_opt_ LPSECURITY_ATTRIBUTES lpThreadAttributes, + _In_ BOOL bInheritHandles, + _In_ DWORD dwCreationFlags, + _In_opt_ LPVOID lpEnvironment, + _In_opt_ LPCSTR lpCurrentDirectory, + _In_ LPSTARTUPINFOA lpStartupInfo, + _Out_ LPPROCESS_INFORMATION lpProcessInformation); + +typedef BOOL (WINAPI *PDETOUR_CREATE_PROCESS_ROUTINEW)( + _In_opt_ LPCWSTR lpApplicationName, + _Inout_opt_ LPWSTR lpCommandLine, + _In_opt_ LPSECURITY_ATTRIBUTES lpProcessAttributes, + _In_opt_ LPSECURITY_ATTRIBUTES lpThreadAttributes, + _In_ BOOL bInheritHandles, + _In_ DWORD dwCreationFlags, + _In_opt_ LPVOID lpEnvironment, + _In_opt_ LPCWSTR lpCurrentDirectory, + _In_ LPSTARTUPINFOW lpStartupInfo, + _Out_ LPPROCESS_INFORMATION lpProcessInformation); + +BOOL WINAPI DetourCreateProcessWithDllA(_In_opt_ LPCSTR lpApplicationName, + _Inout_opt_ LPSTR lpCommandLine, + _In_opt_ LPSECURITY_ATTRIBUTES lpProcessAttributes, + _In_opt_ LPSECURITY_ATTRIBUTES lpThreadAttributes, + _In_ BOOL bInheritHandles, + _In_ DWORD dwCreationFlags, + _In_opt_ LPVOID lpEnvironment, + _In_opt_ LPCSTR lpCurrentDirectory, + _In_ LPSTARTUPINFOA lpStartupInfo, + _Out_ LPPROCESS_INFORMATION lpProcessInformation, + _In_ LPCSTR lpDllName, + _In_opt_ PDETOUR_CREATE_PROCESS_ROUTINEA pfCreateProcessA); + +BOOL WINAPI DetourCreateProcessWithDllW(_In_opt_ LPCWSTR lpApplicationName, + _Inout_opt_ LPWSTR lpCommandLine, + _In_opt_ LPSECURITY_ATTRIBUTES lpProcessAttributes, + _In_opt_ LPSECURITY_ATTRIBUTES lpThreadAttributes, + _In_ BOOL bInheritHandles, + _In_ DWORD dwCreationFlags, + _In_opt_ LPVOID lpEnvironment, + _In_opt_ LPCWSTR lpCurrentDirectory, + _In_ LPSTARTUPINFOW lpStartupInfo, + _Out_ LPPROCESS_INFORMATION lpProcessInformation, + _In_ LPCSTR lpDllName, + _In_opt_ PDETOUR_CREATE_PROCESS_ROUTINEW pfCreateProcessW); + +#ifdef UNICODE +#define DetourCreateProcessWithDll DetourCreateProcessWithDllW +#define PDETOUR_CREATE_PROCESS_ROUTINE PDETOUR_CREATE_PROCESS_ROUTINEW +#else +#define DetourCreateProcessWithDll DetourCreateProcessWithDllA +#define PDETOUR_CREATE_PROCESS_ROUTINE PDETOUR_CREATE_PROCESS_ROUTINEA +#endif // !UNICODE + +BOOL WINAPI DetourCreateProcessWithDllExA(_In_opt_ LPCSTR lpApplicationName, + _Inout_opt_ LPSTR lpCommandLine, + _In_opt_ LPSECURITY_ATTRIBUTES lpProcessAttributes, + _In_opt_ LPSECURITY_ATTRIBUTES lpThreadAttributes, + _In_ BOOL bInheritHandles, + _In_ DWORD dwCreationFlags, + _In_opt_ LPVOID lpEnvironment, + _In_opt_ LPCSTR lpCurrentDirectory, + _In_ LPSTARTUPINFOA lpStartupInfo, + _Out_ LPPROCESS_INFORMATION lpProcessInformation, + _In_ LPCSTR lpDllName, + _In_opt_ PDETOUR_CREATE_PROCESS_ROUTINEA pfCreateProcessA); + +BOOL WINAPI DetourCreateProcessWithDllExW(_In_opt_ LPCWSTR lpApplicationName, + _Inout_opt_ LPWSTR lpCommandLine, + _In_opt_ LPSECURITY_ATTRIBUTES lpProcessAttributes, + _In_opt_ LPSECURITY_ATTRIBUTES lpThreadAttributes, + _In_ BOOL bInheritHandles, + _In_ DWORD dwCreationFlags, + _In_opt_ LPVOID lpEnvironment, + _In_opt_ LPCWSTR lpCurrentDirectory, + _In_ LPSTARTUPINFOW lpStartupInfo, + _Out_ LPPROCESS_INFORMATION lpProcessInformation, + _In_ LPCSTR lpDllName, + _In_opt_ PDETOUR_CREATE_PROCESS_ROUTINEW pfCreateProcessW); + +#ifdef UNICODE +#define DetourCreateProcessWithDllEx DetourCreateProcessWithDllExW +#else +#define DetourCreateProcessWithDllEx DetourCreateProcessWithDllExA +#endif // !UNICODE + +BOOL WINAPI DetourCreateProcessWithDllsA(_In_opt_ LPCSTR lpApplicationName, + _Inout_opt_ LPSTR lpCommandLine, + _In_opt_ LPSECURITY_ATTRIBUTES lpProcessAttributes, + _In_opt_ LPSECURITY_ATTRIBUTES lpThreadAttributes, + _In_ BOOL bInheritHandles, + _In_ DWORD dwCreationFlags, + _In_opt_ LPVOID lpEnvironment, + _In_opt_ LPCSTR lpCurrentDirectory, + _In_ LPSTARTUPINFOA lpStartupInfo, + _Out_ LPPROCESS_INFORMATION lpProcessInformation, + _In_ DWORD nDlls, + _In_reads_(nDlls) LPCSTR *rlpDlls, + _In_opt_ PDETOUR_CREATE_PROCESS_ROUTINEA pfCreateProcessA); + +BOOL WINAPI DetourCreateProcessWithDllsW(_In_opt_ LPCWSTR lpApplicationName, + _Inout_opt_ LPWSTR lpCommandLine, + _In_opt_ LPSECURITY_ATTRIBUTES lpProcessAttributes, + _In_opt_ LPSECURITY_ATTRIBUTES lpThreadAttributes, + _In_ BOOL bInheritHandles, + _In_ DWORD dwCreationFlags, + _In_opt_ LPVOID lpEnvironment, + _In_opt_ LPCWSTR lpCurrentDirectory, + _In_ LPSTARTUPINFOW lpStartupInfo, + _Out_ LPPROCESS_INFORMATION lpProcessInformation, + _In_ DWORD nDlls, + _In_reads_(nDlls) LPCSTR *rlpDlls, + _In_opt_ PDETOUR_CREATE_PROCESS_ROUTINEW pfCreateProcessW); + +#ifdef UNICODE +#define DetourCreateProcessWithDlls DetourCreateProcessWithDllsW +#else +#define DetourCreateProcessWithDlls DetourCreateProcessWithDllsA +#endif // !UNICODE + +BOOL WINAPI DetourProcessViaHelperA(_In_ DWORD dwTargetPid, + _In_ LPCSTR lpDllName, + _In_ PDETOUR_CREATE_PROCESS_ROUTINEA pfCreateProcessA); + +BOOL WINAPI DetourProcessViaHelperW(_In_ DWORD dwTargetPid, + _In_ LPCSTR lpDllName, + _In_ PDETOUR_CREATE_PROCESS_ROUTINEW pfCreateProcessW); + +#ifdef UNICODE +#define DetourProcessViaHelper DetourProcessViaHelperW +#else +#define DetourProcessViaHelper DetourProcessViaHelperA +#endif // !UNICODE + +BOOL WINAPI DetourProcessViaHelperDllsA(_In_ DWORD dwTargetPid, + _In_ DWORD nDlls, + _In_reads_(nDlls) LPCSTR *rlpDlls, + _In_ PDETOUR_CREATE_PROCESS_ROUTINEA pfCreateProcessA); + +BOOL WINAPI DetourProcessViaHelperDllsW(_In_ DWORD dwTargetPid, + _In_ DWORD nDlls, + _In_reads_(nDlls) LPCSTR *rlpDlls, + _In_ PDETOUR_CREATE_PROCESS_ROUTINEW pfCreateProcessW); + +#ifdef UNICODE +#define DetourProcessViaHelperDlls DetourProcessViaHelperDllsW +#else +#define DetourProcessViaHelperDlls DetourProcessViaHelperDllsA +#endif // !UNICODE + +BOOL WINAPI DetourUpdateProcessWithDll(_In_ HANDLE hProcess, + _In_reads_(nDlls) LPCSTR *rlpDlls, + _In_ DWORD nDlls); + +BOOL WINAPI DetourUpdateProcessWithDllEx(_In_ HANDLE hProcess, + _In_ HMODULE hImage, + _In_ BOOL bIs32Bit, + _In_reads_(nDlls) LPCSTR *rlpDlls, + _In_ DWORD nDlls); + +BOOL WINAPI DetourCopyPayloadToProcess(_In_ HANDLE hProcess, + _In_ REFGUID rguid, + _In_reads_bytes_(cbData) LPCVOID pvData, + _In_ DWORD cbData); +_Success_(return != NULL) +PVOID WINAPI DetourCopyPayloadToProcessEx(_In_ HANDLE hProcess, + _In_ REFGUID rguid, + _In_reads_bytes_(cbData) LPCVOID pvData, + _In_ DWORD cbData); + +BOOL WINAPI DetourRestoreAfterWith(VOID); +BOOL WINAPI DetourRestoreAfterWithEx(_In_reads_bytes_(cbData) PVOID pvData, + _In_ DWORD cbData); +BOOL WINAPI DetourIsHelperProcess(VOID); +VOID CALLBACK DetourFinishHelperProcess(_In_ HWND, + _In_ HINSTANCE, + _In_ LPSTR, + _In_ INT); + +// +////////////////////////////////////////////////////////////////////////////// +#ifdef __cplusplus +} +#endif // __cplusplus + +/////////////////////////////////////////////////// Type-safe overloads for C++ +// +#if __cplusplus >= 201103L || _MSVC_LANG >= 201103L +#include + +template +struct DetoursIsFunctionPointer : std::false_type {}; + +template +struct DetoursIsFunctionPointer : std::is_function::type> {}; + +template< + typename T, + typename std::enable_if::value, int>::type = 0> +LONG DetourAttach(_Inout_ T *ppPointer, + _In_ T pDetour) noexcept +{ + return DetourAttach( + reinterpret_cast(ppPointer), + reinterpret_cast(pDetour)); +} + +template< + typename T, + typename std::enable_if::value, int>::type = 0> +LONG DetourAttachEx(_Inout_ T *ppPointer, + _In_ T pDetour, + _Out_opt_ PDETOUR_TRAMPOLINE *ppRealTrampoline, + _Out_opt_ T *ppRealTarget, + _Out_opt_ T *ppRealDetour) noexcept +{ + return DetourAttachEx( + reinterpret_cast(ppPointer), + reinterpret_cast(pDetour), + ppRealTrampoline, + reinterpret_cast(ppRealTarget), + reinterpret_cast(ppRealDetour)); +} + +template< + typename T, + typename std::enable_if::value, int>::type = 0> +LONG DetourDetach(_Inout_ T *ppPointer, + _In_ T pDetour) noexcept +{ + return DetourDetach( + reinterpret_cast(ppPointer), + reinterpret_cast(pDetour)); +} + +#endif // __cplusplus >= 201103L || _MSVC_LANG >= 201103L +// +////////////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////// Detours Internal Definitions. +// +#ifdef __cplusplus +#ifdef DETOURS_INTERNAL + +#define NOTHROW +// #define NOTHROW (nothrow) + +////////////////////////////////////////////////////////////////////////////// +// +#if (_MSC_VER < 1299) && !defined(__GNUC__) +#include +typedef IMAGEHLP_MODULE IMAGEHLP_MODULE64; +typedef PIMAGEHLP_MODULE PIMAGEHLP_MODULE64; +typedef IMAGEHLP_SYMBOL SYMBOL_INFO; +typedef PIMAGEHLP_SYMBOL PSYMBOL_INFO; + +static inline +LONG InterlockedCompareExchange(_Inout_ LONG *ptr, _In_ LONG nval, _In_ LONG oval) +{ + return (LONG)::InterlockedCompareExchange((PVOID*)ptr, (PVOID)nval, (PVOID)oval); +} +#else +#pragma warning(push) +#pragma warning(disable:4091) // empty typedef +#include +#pragma warning(pop) +#endif + +#ifdef IMAGEAPI // defined by DBGHELP.H +typedef LPAPI_VERSION (NTAPI *PF_ImagehlpApiVersionEx)(_In_ LPAPI_VERSION AppVersion); + +typedef BOOL (NTAPI *PF_SymInitialize)(_In_ HANDLE hProcess, + _In_opt_ LPCSTR UserSearchPath, + _In_ BOOL fInvadeProcess); +typedef DWORD (NTAPI *PF_SymSetOptions)(_In_ DWORD SymOptions); +typedef DWORD (NTAPI *PF_SymGetOptions)(VOID); +typedef DWORD64 (NTAPI *PF_SymLoadModule64)(_In_ HANDLE hProcess, + _In_opt_ HANDLE hFile, + _In_opt_ LPSTR ImageName, + _In_opt_ LPSTR ModuleName, + _In_ DWORD64 BaseOfDll, + _In_ DWORD SizeOfDll); +typedef BOOL (NTAPI *PF_SymGetModuleInfo64)(_In_ HANDLE hProcess, + _In_ DWORD64 qwAddr, + _Out_ PIMAGEHLP_MODULE64 ModuleInfo); +typedef BOOL (NTAPI *PF_SymFromName)(_In_ HANDLE hProcess, + _In_ LPSTR Name, + _Out_ PSYMBOL_INFO Symbol); + +typedef struct _DETOUR_SYM_INFO +{ + HANDLE hProcess; + HMODULE hDbgHelp; + PF_ImagehlpApiVersionEx pfImagehlpApiVersionEx; + PF_SymInitialize pfSymInitialize; + PF_SymSetOptions pfSymSetOptions; + PF_SymGetOptions pfSymGetOptions; + PF_SymLoadModule64 pfSymLoadModule64; + PF_SymGetModuleInfo64 pfSymGetModuleInfo64; + PF_SymFromName pfSymFromName; +} DETOUR_SYM_INFO, *PDETOUR_SYM_INFO; + +PDETOUR_SYM_INFO DetourLoadImageHlp(VOID); + +#endif // IMAGEAPI + +#if defined(_INC_STDIO) && !defined(_CRT_STDIO_ARBITRARY_WIDE_SPECIFIERS) +#error detours.h must be included before stdio.h (or at least define _CRT_STDIO_ARBITRARY_WIDE_SPECIFIERS earlier) +#endif +#define _CRT_STDIO_ARBITRARY_WIDE_SPECIFIERS 1 + +#ifdef _DEBUG + +int Detour_AssertExprWithFunctionName(int reportType, const char* filename, int linenumber, const char* FunctionName, const char* msg); + +#define DETOUR_ASSERT_EXPR_WITH_FUNCTION(expr, msg) \ + (void) ((expr) || \ + (1 != Detour_AssertExprWithFunctionName(_CRT_ASSERT, __FILE__, __LINE__,__FUNCTION__, msg)) || \ + (_CrtDbgBreak(), 0)) + +#define DETOUR_ASSERT(expr) DETOUR_ASSERT_EXPR_WITH_FUNCTION((expr), #expr) + +#else// _DEBUG +#define DETOUR_ASSERT(expr) +#endif// _DEBUG + +#ifndef DETOUR_TRACE +#if DETOUR_DEBUG +#define DETOUR_TRACE(x) printf x +#define DETOUR_BREAK() __debugbreak() +#include +#include +#else +#define DETOUR_TRACE(x) +#define DETOUR_BREAK() +#endif +#endif + +#if 1 || defined(DETOURS_IA64) + +// +// IA64 instructions are 41 bits, 3 per bundle, plus 5 bit bundle template => 128 bits per bundle. +// + +#define DETOUR_IA64_INSTRUCTIONS_PER_BUNDLE (3) + +#define DETOUR_IA64_TEMPLATE_OFFSET (0) +#define DETOUR_IA64_TEMPLATE_SIZE (5) + +#define DETOUR_IA64_INSTRUCTION_SIZE (41) +#define DETOUR_IA64_INSTRUCTION0_OFFSET (DETOUR_IA64_TEMPLATE_SIZE) +#define DETOUR_IA64_INSTRUCTION1_OFFSET (DETOUR_IA64_TEMPLATE_SIZE + DETOUR_IA64_INSTRUCTION_SIZE) +#define DETOUR_IA64_INSTRUCTION2_OFFSET (DETOUR_IA64_TEMPLATE_SIZE + DETOUR_IA64_INSTRUCTION_SIZE + DETOUR_IA64_INSTRUCTION_SIZE) + +C_ASSERT(DETOUR_IA64_TEMPLATE_SIZE + DETOUR_IA64_INSTRUCTIONS_PER_BUNDLE * DETOUR_IA64_INSTRUCTION_SIZE == 128); + +__declspec(align(16)) struct DETOUR_IA64_BUNDLE +{ + public: + union + { + BYTE data[16]; + UINT64 wide[2]; + }; + + enum { + A_UNIT = 1u, + I_UNIT = 2u, + M_UNIT = 3u, + B_UNIT = 4u, + F_UNIT = 5u, + L_UNIT = 6u, + X_UNIT = 7u, + }; + struct DETOUR_IA64_METADATA + { + ULONG nTemplate : 8; // Instruction template. + ULONG nUnit0 : 4; // Unit for slot 0 + ULONG nUnit1 : 4; // Unit for slot 1 + ULONG nUnit2 : 4; // Unit for slot 2 + }; + + protected: + static const DETOUR_IA64_METADATA s_rceCopyTable[33]; + + UINT RelocateBundle(_Inout_ DETOUR_IA64_BUNDLE* pDst, _Inout_opt_ DETOUR_IA64_BUNDLE* pBundleExtra) const; + + bool RelocateInstruction(_Inout_ DETOUR_IA64_BUNDLE* pDst, + _In_ BYTE slot, + _Inout_opt_ DETOUR_IA64_BUNDLE* pBundleExtra) const; + + // 120 112 104 96 88 80 72 64 56 48 40 32 24 16 8 0 + // f. e. d. c. b. a. 9. 8. 7. 6. 5. 4. 3. 2. 1. 0. + + // 00 + // f.e. d.c. b.a. 9.8. 7.6. 5.4. 3.2. 1.0. + // 0000 0000 0000 0000 0000 0000 0000 001f : Template [4..0] + // 0000 0000 0000 0000 0000 03ff ffff ffe0 : Zero [ 41.. 5] + // 0000 0000 0000 0000 0000 3c00 0000 0000 : Zero [ 45.. 42] + // 0000 0000 0007 ffff ffff c000 0000 0000 : One [ 82.. 46] + // 0000 0000 0078 0000 0000 0000 0000 0000 : One [ 86.. 83] + // 0fff ffff ff80 0000 0000 0000 0000 0000 : Two [123.. 87] + // f000 0000 0000 0000 0000 0000 0000 0000 : Two [127..124] + BYTE GetTemplate() const; + // Get 4 bit opcodes. + BYTE GetInst0() const; + BYTE GetInst1() const; + BYTE GetInst2() const; + BYTE GetUnit(BYTE slot) const; + BYTE GetUnit0() const; + BYTE GetUnit1() const; + BYTE GetUnit2() const; + // Get 37 bit data. + UINT64 GetData0() const; + UINT64 GetData1() const; + UINT64 GetData2() const; + + // Get/set the full 41 bit instructions. + UINT64 GetInstruction(BYTE slot) const; + UINT64 GetInstruction0() const; + UINT64 GetInstruction1() const; + UINT64 GetInstruction2() const; + void SetInstruction(BYTE slot, UINT64 instruction); + void SetInstruction0(UINT64 instruction); + void SetInstruction1(UINT64 instruction); + void SetInstruction2(UINT64 instruction); + + // Get/set bitfields. + static UINT64 GetBits(UINT64 Value, UINT64 Offset, UINT64 Count); + static UINT64 SetBits(UINT64 Value, UINT64 Offset, UINT64 Count, UINT64 Field); + + // Get specific read-only fields. + static UINT64 GetOpcode(UINT64 instruction); // 4bit opcode + static UINT64 GetX(UINT64 instruction); // 1bit opcode extension + static UINT64 GetX3(UINT64 instruction); // 3bit opcode extension + static UINT64 GetX6(UINT64 instruction); // 6bit opcode extension + + // Get/set specific fields. + static UINT64 GetImm7a(UINT64 instruction); + static UINT64 SetImm7a(UINT64 instruction, UINT64 imm7a); + static UINT64 GetImm13c(UINT64 instruction); + static UINT64 SetImm13c(UINT64 instruction, UINT64 imm13c); + static UINT64 GetSignBit(UINT64 instruction); + static UINT64 SetSignBit(UINT64 instruction, UINT64 signBit); + static UINT64 GetImm20a(UINT64 instruction); + static UINT64 SetImm20a(UINT64 instruction, UINT64 imm20a); + static UINT64 GetImm20b(UINT64 instruction); + static UINT64 SetImm20b(UINT64 instruction, UINT64 imm20b); + + static UINT64 SignExtend(UINT64 Value, UINT64 Offset); + + BOOL IsMovlGp() const; + + VOID SetInst(BYTE Slot, BYTE nInst); + VOID SetInst0(BYTE nInst); + VOID SetInst1(BYTE nInst); + VOID SetInst2(BYTE nInst); + VOID SetData(BYTE Slot, UINT64 nData); + VOID SetData0(UINT64 nData); + VOID SetData1(UINT64 nData); + VOID SetData2(UINT64 nData); + BOOL SetNop(BYTE Slot); + BOOL SetNop0(); + BOOL SetNop1(); + BOOL SetNop2(); + + public: + BOOL IsBrl() const; + VOID SetBrl(); + VOID SetBrl(UINT64 target); + UINT64 GetBrlTarget() const; + VOID SetBrlTarget(UINT64 target); + VOID SetBrlImm(UINT64 imm); + UINT64 GetBrlImm() const; + + UINT64 GetMovlGp() const; + VOID SetMovlGp(UINT64 gp); + + VOID SetStop(); + + UINT Copy(_Out_ DETOUR_IA64_BUNDLE *pDst, _Inout_opt_ DETOUR_IA64_BUNDLE* pBundleExtra = NULL) const; +}; +#endif // DETOURS_IA64 + +#ifdef DETOURS_ARM + +#define DETOURS_PFUNC_TO_PBYTE(p) ((PBYTE)(((ULONG_PTR)(p)) & ~(ULONG_PTR)1)) +#define DETOURS_PBYTE_TO_PFUNC(p) ((PBYTE)(((ULONG_PTR)(p)) | (ULONG_PTR)1)) + +#endif // DETOURS_ARM + +////////////////////////////////////////////////////////////////////////////// + +#ifdef __cplusplus +extern "C" { +#endif // __cplusplus + +#define DETOUR_OFFLINE_LIBRARY(x) \ +PVOID WINAPI DetourCopyInstruction##x(_In_opt_ PVOID pDst, \ + _Inout_opt_ PVOID *ppDstPool, \ + _In_ PVOID pSrc, \ + _Out_opt_ PVOID *ppTarget, \ + _Out_opt_ LONG *plExtra); \ + \ +BOOL WINAPI DetourSetCodeModule##x(_In_ HMODULE hModule, \ + _In_ BOOL fLimitReferencesToModule); \ + +DETOUR_OFFLINE_LIBRARY(X86) +DETOUR_OFFLINE_LIBRARY(X64) +DETOUR_OFFLINE_LIBRARY(ARM) +DETOUR_OFFLINE_LIBRARY(ARM64) +DETOUR_OFFLINE_LIBRARY(IA64) + +#undef DETOUR_OFFLINE_LIBRARY + +////////////////////////////////////////////////////////////////////////////// +// +// Helpers for manipulating page protection. +// + +_Success_(return != FALSE) +BOOL WINAPI DetourVirtualProtectSameExecuteEx(_In_ HANDLE hProcess, + _In_ PVOID pAddress, + _In_ SIZE_T nSize, + _In_ DWORD dwNewProtect, + _Out_ PDWORD pdwOldProtect); + +_Success_(return != FALSE) +BOOL WINAPI DetourVirtualProtectSameExecute(_In_ PVOID pAddress, + _In_ SIZE_T nSize, + _In_ DWORD dwNewProtect, + _Out_ PDWORD pdwOldProtect); + +// Detours must depend only on kernel32.lib, so we cannot use IsEqualGUID +BOOL WINAPI DetourAreSameGuid(_In_ REFGUID left, _In_ REFGUID right); +#ifdef __cplusplus +} +#endif // __cplusplus + +////////////////////////////////////////////////////////////////////////////// + +#define MM_ALLOCATION_GRANULARITY 0x10000 + +////////////////////////////////////////////////////////////////////////////// + +#endif // DETOURS_INTERNAL +#endif // __cplusplus + +#endif // _DETOURS_H_ +// +//////////////////////////////////////////////////////////////// End of File. diff --git a/extern/src/libdeflate.h b/extern/src/libdeflate.h new file mode 100644 index 0000000..0a274f0 --- /dev/null +++ b/extern/src/libdeflate.h @@ -0,0 +1,411 @@ +/* + * libdeflate.h - public header for libdeflate + */ + +#ifndef LIBDEFLATE_H +#define LIBDEFLATE_H + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +#define LIBDEFLATE_VERSION_MAJOR 1 +#define LIBDEFLATE_VERSION_MINOR 19 +#define LIBDEFLATE_VERSION_STRING "1.19" + +/* + * Users of libdeflate.dll on Windows can define LIBDEFLATE_DLL to cause + * __declspec(dllimport) to be used. This should be done when it's easy to do. + * Otherwise it's fine to skip it, since it is a very minor performance + * optimization that is irrelevant for most use cases of libdeflate. + */ +#ifndef LIBDEFLATEAPI +# if defined(LIBDEFLATE_DLL) && (defined(_WIN32) || defined(__CYGWIN__)) +# define LIBDEFLATEAPI __declspec(dllimport) +# else +# define LIBDEFLATEAPI +# endif +#endif + +/* ========================================================================== */ +/* Compression */ +/* ========================================================================== */ + +struct libdeflate_compressor; +struct libdeflate_options; + +/* + * libdeflate_alloc_compressor() allocates a new compressor that supports + * DEFLATE, zlib, and gzip compression. 'compression_level' is the compression + * level on a zlib-like scale but with a higher maximum value (1 = fastest, 6 = + * medium/default, 9 = slow, 12 = slowest). Level 0 is also supported and means + * "no compression", specifically "create a valid stream, but only emit + * uncompressed blocks" (this will expand the data slightly). + * + * The return value is a pointer to the new compressor, or NULL if out of memory + * or if the compression level is invalid (i.e. outside the range [0, 12]). + * + * Note: for compression, the sliding window size is defined at compilation time + * to 32768, the largest size permissible in the DEFLATE format. It cannot be + * changed at runtime. + * + * A single compressor is not safe to use by multiple threads concurrently. + * However, different threads may use different compressors concurrently. + */ +LIBDEFLATEAPI struct libdeflate_compressor * +libdeflate_alloc_compressor(int compression_level); + +/* + * Like libdeflate_alloc_compressor(), but adds the 'options' argument. + */ +LIBDEFLATEAPI struct libdeflate_compressor * +libdeflate_alloc_compressor_ex(int compression_level, + const struct libdeflate_options *options); + +/* + * libdeflate_deflate_compress() performs raw DEFLATE compression on a buffer of + * data. It attempts to compress 'in_nbytes' bytes of data located at 'in' and + * write the result to 'out', which has space for 'out_nbytes_avail' bytes. The + * return value is the compressed size in bytes, or 0 if the data could not be + * compressed to 'out_nbytes_avail' bytes or fewer. + * + * If compression is successful, then the output data is guaranteed to be a + * valid DEFLATE stream that decompresses to the input data. No other + * guarantees are made about the output data. Notably, different versions of + * libdeflate can produce different compressed data for the same uncompressed + * data, even at the same compression level. Do ***NOT*** do things like + * writing tests that compare compressed data to a golden output, as this can + * break when libdeflate is updated. (This property isn't specific to + * libdeflate; the same is true for zlib and other compression libraries too.) + */ +LIBDEFLATEAPI size_t +libdeflate_deflate_compress(struct libdeflate_compressor *compressor, + const void *in, size_t in_nbytes, + void *out, size_t out_nbytes_avail); + +/* + * libdeflate_deflate_compress_bound() returns a worst-case upper bound on the + * number of bytes of compressed data that may be produced by compressing any + * buffer of length less than or equal to 'in_nbytes' using + * libdeflate_deflate_compress() with the specified compressor. This bound will + * necessarily be a number greater than or equal to 'in_nbytes'. It may be an + * overestimate of the true upper bound. The return value is guaranteed to be + * the same for all invocations with the same compressor and same 'in_nbytes'. + * + * As a special case, 'compressor' may be NULL. This causes the bound to be + * taken across *any* libdeflate_compressor that could ever be allocated with + * this build of the library, with any options. + * + * Note that this function is not necessary in many applications. With + * block-based compression, it is usually preferable to separately store the + * uncompressed size of each block and to store any blocks that did not compress + * to less than their original size uncompressed. In that scenario, there is no + * need to know the worst-case compressed size, since the maximum number of + * bytes of compressed data that may be used would always be one less than the + * input length. You can just pass a buffer of that size to + * libdeflate_deflate_compress() and store the data uncompressed if + * libdeflate_deflate_compress() returns 0, indicating that the compressed data + * did not fit into the provided output buffer. + */ +LIBDEFLATEAPI size_t +libdeflate_deflate_compress_bound(struct libdeflate_compressor *compressor, + size_t in_nbytes); + +/* + * Like libdeflate_deflate_compress(), but uses the zlib wrapper format instead + * of raw DEFLATE. + */ +LIBDEFLATEAPI size_t +libdeflate_zlib_compress(struct libdeflate_compressor *compressor, + const void *in, size_t in_nbytes, + void *out, size_t out_nbytes_avail); + +/* + * Like libdeflate_deflate_compress_bound(), but assumes the data will be + * compressed with libdeflate_zlib_compress() rather than with + * libdeflate_deflate_compress(). + */ +LIBDEFLATEAPI size_t +libdeflate_zlib_compress_bound(struct libdeflate_compressor *compressor, + size_t in_nbytes); + +/* + * Like libdeflate_deflate_compress(), but uses the gzip wrapper format instead + * of raw DEFLATE. + */ +LIBDEFLATEAPI size_t +libdeflate_gzip_compress(struct libdeflate_compressor *compressor, + const void *in, size_t in_nbytes, + void *out, size_t out_nbytes_avail); + +/* + * Like libdeflate_deflate_compress_bound(), but assumes the data will be + * compressed with libdeflate_gzip_compress() rather than with + * libdeflate_deflate_compress(). + */ +LIBDEFLATEAPI size_t +libdeflate_gzip_compress_bound(struct libdeflate_compressor *compressor, + size_t in_nbytes); + +/* + * libdeflate_free_compressor() frees a compressor that was allocated with + * libdeflate_alloc_compressor(). If a NULL pointer is passed in, no action is + * taken. + */ +LIBDEFLATEAPI void +libdeflate_free_compressor(struct libdeflate_compressor *compressor); + +/* ========================================================================== */ +/* Decompression */ +/* ========================================================================== */ + +struct libdeflate_decompressor; +struct libdeflate_options; + +/* + * libdeflate_alloc_decompressor() allocates a new decompressor that can be used + * for DEFLATE, zlib, and gzip decompression. The return value is a pointer to + * the new decompressor, or NULL if out of memory. + * + * This function takes no parameters, and the returned decompressor is valid for + * decompressing data that was compressed at any compression level and with any + * sliding window size. + * + * A single decompressor is not safe to use by multiple threads concurrently. + * However, different threads may use different decompressors concurrently. + */ +LIBDEFLATEAPI struct libdeflate_decompressor * +libdeflate_alloc_decompressor(void); + +/* + * Like libdeflate_alloc_decompressor(), but adds the 'options' argument. + */ +LIBDEFLATEAPI struct libdeflate_decompressor * +libdeflate_alloc_decompressor_ex(const struct libdeflate_options *options); + +/* + * Result of a call to libdeflate_deflate_decompress(), + * libdeflate_zlib_decompress(), or libdeflate_gzip_decompress(). + */ +enum libdeflate_result { + /* Decompression was successful. */ + LIBDEFLATE_SUCCESS = 0, + + /* Decompression failed because the compressed data was invalid, + * corrupt, or otherwise unsupported. */ + LIBDEFLATE_BAD_DATA = 1, + + /* A NULL 'actual_out_nbytes_ret' was provided, but the data would have + * decompressed to fewer than 'out_nbytes_avail' bytes. */ + LIBDEFLATE_SHORT_OUTPUT = 2, + + /* The data would have decompressed to more than 'out_nbytes_avail' + * bytes. */ + LIBDEFLATE_INSUFFICIENT_SPACE = 3, +}; + +/* + * libdeflate_deflate_decompress() decompresses a DEFLATE stream from the buffer + * 'in' with compressed size up to 'in_nbytes' bytes. The uncompressed data is + * written to 'out', a buffer with size 'out_nbytes_avail' bytes. If + * decompression succeeds, then 0 (LIBDEFLATE_SUCCESS) is returned. Otherwise, + * a nonzero result code such as LIBDEFLATE_BAD_DATA is returned, and the + * contents of the output buffer are undefined. + * + * Decompression stops at the end of the DEFLATE stream (as indicated by the + * BFINAL flag), even if it is actually shorter than 'in_nbytes' bytes. + * + * libdeflate_deflate_decompress() can be used in cases where the actual + * uncompressed size is known (recommended) or unknown (not recommended): + * + * - If the actual uncompressed size is known, then pass the actual + * uncompressed size as 'out_nbytes_avail' and pass NULL for + * 'actual_out_nbytes_ret'. This makes libdeflate_deflate_decompress() fail + * with LIBDEFLATE_SHORT_OUTPUT if the data decompressed to fewer than the + * specified number of bytes. + * + * - If the actual uncompressed size is unknown, then provide a non-NULL + * 'actual_out_nbytes_ret' and provide a buffer with some size + * 'out_nbytes_avail' that you think is large enough to hold all the + * uncompressed data. In this case, if the data decompresses to less than + * or equal to 'out_nbytes_avail' bytes, then + * libdeflate_deflate_decompress() will write the actual uncompressed size + * to *actual_out_nbytes_ret and return 0 (LIBDEFLATE_SUCCESS). Otherwise, + * it will return LIBDEFLATE_INSUFFICIENT_SPACE if the provided buffer was + * not large enough but no other problems were encountered, or another + * nonzero result code if decompression failed for another reason. + */ +LIBDEFLATEAPI enum libdeflate_result +libdeflate_deflate_decompress(struct libdeflate_decompressor *decompressor, + const void *in, size_t in_nbytes, + void *out, size_t out_nbytes_avail, + size_t *actual_out_nbytes_ret); + +/* + * Like libdeflate_deflate_decompress(), but adds the 'actual_in_nbytes_ret' + * argument. If decompression succeeds and 'actual_in_nbytes_ret' is not NULL, + * then the actual compressed size of the DEFLATE stream (aligned to the next + * byte boundary) is written to *actual_in_nbytes_ret. + */ +LIBDEFLATEAPI enum libdeflate_result +libdeflate_deflate_decompress_ex(struct libdeflate_decompressor *decompressor, + const void *in, size_t in_nbytes, + void *out, size_t out_nbytes_avail, + size_t *actual_in_nbytes_ret, + size_t *actual_out_nbytes_ret); + +/* + * Like libdeflate_deflate_decompress(), but assumes the zlib wrapper format + * instead of raw DEFLATE. + * + * Decompression will stop at the end of the zlib stream, even if it is shorter + * than 'in_nbytes'. If you need to know exactly where the zlib stream ended, + * use libdeflate_zlib_decompress_ex(). + */ +LIBDEFLATEAPI enum libdeflate_result +libdeflate_zlib_decompress(struct libdeflate_decompressor *decompressor, + const void *in, size_t in_nbytes, + void *out, size_t out_nbytes_avail, + size_t *actual_out_nbytes_ret); + +/* + * Like libdeflate_zlib_decompress(), but adds the 'actual_in_nbytes_ret' + * argument. If 'actual_in_nbytes_ret' is not NULL and the decompression + * succeeds (indicating that the first zlib-compressed stream in the input + * buffer was decompressed), then the actual number of input bytes consumed is + * written to *actual_in_nbytes_ret. + */ +LIBDEFLATEAPI enum libdeflate_result +libdeflate_zlib_decompress_ex(struct libdeflate_decompressor *decompressor, + const void *in, size_t in_nbytes, + void *out, size_t out_nbytes_avail, + size_t *actual_in_nbytes_ret, + size_t *actual_out_nbytes_ret); + +/* + * Like libdeflate_deflate_decompress(), but assumes the gzip wrapper format + * instead of raw DEFLATE. + * + * If multiple gzip-compressed members are concatenated, then only the first + * will be decompressed. Use libdeflate_gzip_decompress_ex() if you need + * multi-member support. + */ +LIBDEFLATEAPI enum libdeflate_result +libdeflate_gzip_decompress(struct libdeflate_decompressor *decompressor, + const void *in, size_t in_nbytes, + void *out, size_t out_nbytes_avail, + size_t *actual_out_nbytes_ret); + +/* + * Like libdeflate_gzip_decompress(), but adds the 'actual_in_nbytes_ret' + * argument. If 'actual_in_nbytes_ret' is not NULL and the decompression + * succeeds (indicating that the first gzip-compressed member in the input + * buffer was decompressed), then the actual number of input bytes consumed is + * written to *actual_in_nbytes_ret. + */ +LIBDEFLATEAPI enum libdeflate_result +libdeflate_gzip_decompress_ex(struct libdeflate_decompressor *decompressor, + const void *in, size_t in_nbytes, + void *out, size_t out_nbytes_avail, + size_t *actual_in_nbytes_ret, + size_t *actual_out_nbytes_ret); + +/* + * libdeflate_free_decompressor() frees a decompressor that was allocated with + * libdeflate_alloc_decompressor(). If a NULL pointer is passed in, no action + * is taken. + */ +LIBDEFLATEAPI void +libdeflate_free_decompressor(struct libdeflate_decompressor *decompressor); + +/* ========================================================================== */ +/* Checksums */ +/* ========================================================================== */ + +/* + * libdeflate_adler32() updates a running Adler-32 checksum with 'len' bytes of + * data and returns the updated checksum. When starting a new checksum, the + * required initial value for 'adler' is 1. This value is also returned when + * 'buffer' is specified as NULL. + */ +LIBDEFLATEAPI uint32_t +libdeflate_adler32(uint32_t adler, const void *buffer, size_t len); + + +/* + * libdeflate_crc32() updates a running CRC-32 checksum with 'len' bytes of data + * and returns the updated checksum. When starting a new checksum, the required + * initial value for 'crc' is 0. This value is also returned when 'buffer' is + * specified as NULL. + */ +LIBDEFLATEAPI uint32_t +libdeflate_crc32(uint32_t crc, const void *buffer, size_t len); + +/* ========================================================================== */ +/* Custom memory allocator */ +/* ========================================================================== */ + +/* + * Install a custom memory allocator which libdeflate will use for all memory + * allocations by default. 'malloc_func' is a function that must behave like + * malloc(), and 'free_func' is a function that must behave like free(). + * + * The per-(de)compressor custom memory allocator that can be specified in + * 'struct libdeflate_options' takes priority over this. + * + * This doesn't affect the free() function that will be used to free + * (de)compressors that were already in existence when this is called. + */ +LIBDEFLATEAPI void +libdeflate_set_memory_allocator(void *(*malloc_func)(size_t), + void (*free_func)(void *)); + +/* + * Advanced options. This is the options structure that + * libdeflate_alloc_compressor_ex() and libdeflate_alloc_decompressor_ex() + * require. Most users won't need this and should just use the non-"_ex" + * functions instead. If you do need this, it should be initialized like this: + * + * struct libdeflate_options options; + * + * memset(&options, 0, sizeof(options)); + * options.sizeof_options = sizeof(options); + * // Then set the fields that you need to override the defaults for. + */ +struct libdeflate_options { + + /* + * This field must be set to the struct size. This field exists for + * extensibility, so that fields can be appended to this struct in + * future versions of libdeflate while still supporting old binaries. + */ + size_t sizeof_options; + + /* + * An optional custom memory allocator to use for this (de)compressor. + * 'malloc_func' must be a function that behaves like malloc(), and + * 'free_func' must be a function that behaves like free(). + * + * This is useful in cases where a process might have multiple users of + * libdeflate who want to use different memory allocators. For example, + * a library might want to use libdeflate with a custom memory allocator + * without interfering with user code that might use libdeflate too. + * + * This takes priority over the "global" memory allocator (which by + * default is malloc() and free(), but can be changed by + * libdeflate_set_memory_allocator()). Moreover, libdeflate will never + * call the "global" memory allocator if a per-(de)compressor custom + * allocator is always given. + */ + void *(*malloc_func)(size_t); + void (*free_func)(void *); +}; + +#ifdef __cplusplus +} +#endif + +#endif /* LIBDEFLATE_H */ diff --git a/src/DivaGL/DivaGL.rc b/src/DivaGL/DivaGL.rc new file mode 100644 index 0000000..caea5e7 --- /dev/null +++ b/src/DivaGL/DivaGL.rc @@ -0,0 +1,46 @@ +#define IDR_VERSION2 101 + +#ifdef APSTUDIO_INVOKED +#ifndef APSTUDIO_READONLY_SYMBOLS +#define _APS_NEXT_RESOURCE_VALUE 102 +#define _APS_NEXT_COMMAND_VALUE 40001 +#define _APS_NEXT_CONTROL_VALUE 1000 +#define _APS_NEXT_SYMED_VALUE 101 +#endif +#endif + +#define APSTUDIO_READONLY_SYMBOLS +#include "winres.h" +#undef APSTUDIO_READONLY_SYMBOLS + +VS_VERSION_INFO VERSIONINFO + FILEVERSION 0,2,0 + PRODUCTVERSION 0,2,0,0 + FILEFLAGSMASK 0x3fL +#ifdef _DEBUG + FILEFLAGS 0x1L +#else + FILEFLAGS 0x0L +#endif + FILEOS 0x40004L + FILETYPE 0x0L + FILESUBTYPE 0x0L +BEGIN + BLOCK "StringFileInfo" + BEGIN + BLOCK "000904b0" + BEGIN + VALUE "FileDescription", "DivaGL plugin for PDAFT 7.10" + VALUE "FileVersion", "0.2.0.0" + VALUE "InternalName", "DivaGL" + VALUE "LegalCopyright", "korenkonder (C) 2020-2023" + VALUE "OriginalFilename", "DivaGL.dll" + VALUE "ProductName", "DivaGL" + VALUE "ProductVersion", "0.2.0.0" + END + END + BLOCK "VarFileInfo" + BEGIN + VALUE "Translation", 0x9, 1200 + END +END diff --git a/src/DivaGL/DivaGL.vcxproj b/src/DivaGL/DivaGL.vcxproj new file mode 100644 index 0000000..3d2dce5 --- /dev/null +++ b/src/DivaGL/DivaGL.vcxproj @@ -0,0 +1,339 @@ + + + + + DebugDLL + x64 + + + Debug + x64 + + + ReleaseDLL + x64 + + + Release + x64 + + + + 16.0 + {4D949362-9095-4113-9423-7E0492618F16} + Win32Proj + 10.0 + + + + DynamicLibrary + false + v142 + Unicode + + + DynamicLibrary + false + v142 + Unicode + + + DynamicLibrary + false + v142 + Unicode + + + DynamicLibrary + false + v142 + Unicode + + + + + + + + + + + + + + + + + false + DivaGL + $(SolutionDir)bin\ + $(SolutionDir)obj\debug\DivaGL\ + .dva + + + false + dinput8 + $(SolutionDir)bin\ + $(SolutionDir)obj\debug\DivaGL\ + .dll + + + false + DivaGL + $(SolutionDir)bin\ + $(SolutionDir)obj\release\DivaGL\ + .dva + + + false + dinput8 + $(SolutionDir)bin\ + $(SolutionDir)obj\release\DivaGL\ + .dll + + + + NotUsing + Level3 + Disabled + WIN32;DEBUG;%(PreprocessorDefinitions) + $(SolutionDir)extern\src + true + ProgramDatabase + false + OnlyExplicitInline + FastCall + true + CompileAsCpp + $(IntDir)/%(RelativeDir) + MultiThreaded + 26812 + false + + + MachineX64 + DebugFull + Windows + $(SolutionDir)extern\lib;$(SolutionDir)lib\debugopt\ + opengl32.lib;detours.lib;syelog.lib;libdeflatestatic.lib;KKdLib.lib;%(AdditionalDependencies) + /ignore:4098 /ignore:4099 /ignore:4286 %(AdditionalOptions) + false + + + copy /Y "$(SolutionDir)bin\$(TargetName).dva" "N:\DUMP\plugins\$(TargetName).dva" +copy /Y "$(SolutionDir)bin\$(TargetName).pdb" "N:\DUMP\plugins\$(TargetName).pdb" +del "$(SolutionDir)bin\$(TargetName).exp" +del "$(SolutionDir)bin\$(TargetName).lib" + + + + + NotUsing + Level3 + Disabled + WIN32;DINPUT8_DLL;DEBUG;%(PreprocessorDefinitions) + $(SolutionDir)extern\src + true + ProgramDatabase + false + OnlyExplicitInline + FastCall + true + CompileAsCpp + $(IntDir)/%(RelativeDir) + MultiThreaded + 26812 + false + + + MachineX64 + DebugFull + Windows + $(SolutionDir)extern\lib;$(SolutionDir)lib\debugopt\ + opengl32.lib;detours.lib;syelog.lib;libdeflatestatic.lib;KKdLib.lib;%(AdditionalDependencies) + /ignore:4098 /ignore:4099 /ignore:4286 %(AdditionalOptions) + false + + + copy /Y "$(SolutionDir)bin\$(TargetName).dll" "N:\DUMP\$(TargetName).dll" +copy /Y "$(SolutionDir)bin\$(TargetName).pdb" "N:\DUMP\$(TargetName).pdb" +del "$(SolutionDir)bin\$(TargetName).exp" +del "$(SolutionDir)bin\$(TargetName).lib" + + + + + NotUsing + Level3 + MaxSpeed + WIN32;%(PreprocessorDefinitions) + $(SolutionDir)extern\src + true + false + ProgramDatabase + OnlyExplicitInline + true + FastCall + CompileAsCpp + + + $(IntDir)/%(RelativeDir) + Size + + + false + MultiThreaded + 26812 + + + MachineX64 + true + Windows + $(SolutionDir)extern\lib;$(SolutionDir)lib\release\ + opengl32.lib;detours.lib;syelog.lib;libdeflatestatic.lib;KKdLib.lib;%(AdditionalDependencies) + true + /ignore:4098 /ignore:4099 /ignore:4286 %(AdditionalOptions) + true + false + + + copy /Y "$(SolutionDir)bin\$(TargetName).dva" "N:\DUMP\plugins\$(TargetName).dva" +copy /Y "$(SolutionDir)bin\$(TargetName).pdb" "N:\DUMP\plugins\$(TargetName).pdb" +del "$(SolutionDir)bin\$(TargetName).exp" +del "$(SolutionDir)bin\$(TargetName).lib" + + + + + NotUsing + Level3 + MaxSpeed + WIN32;DINPUT8_DLL;%(PreprocessorDefinitions) + $(SolutionDir)extern\src + true + false + ProgramDatabase + OnlyExplicitInline + true + FastCall + CompileAsCpp + + + $(IntDir)/%(RelativeDir) + Size + + + false + MultiThreaded + 26812 + + + MachineX64 + true + Windows + $(SolutionDir)extern\lib;$(SolutionDir)lib\release\ + opengl32.lib;detours.lib;syelog.lib;libdeflatestatic.lib;KKdLib.lib;%(AdditionalDependencies) + true + /ignore:4098 /ignore:4099 /ignore:4286 %(AdditionalOptions) + true + false + + + copy /Y "$(SolutionDir)bin\$(TargetName).dll" "N:\DUMP\$(TargetName).dll" +copy /Y "$(SolutionDir)bin\$(TargetName).pdb" "N:\DUMP\$(TargetName).pdb" +del "$(SolutionDir)bin\$(TargetName).exp" +del "$(SolutionDir)bin\$(TargetName).lib" + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + {4c9636b9-e5b6-41e5-9afc-5b33cc9633de} + + + + \ No newline at end of file diff --git a/src/DivaGL/DivaGL.vcxproj.user b/src/DivaGL/DivaGL.vcxproj.user new file mode 100644 index 0000000..c23e4d1 --- /dev/null +++ b/src/DivaGL/DivaGL.vcxproj.user @@ -0,0 +1,30 @@ + + + + N:\DUMP\diva.exe + N:\DUMP + WindowsLocalDebugger + --launch -w + + + N:\DUMP\diva.exe + N:\DUMP + WindowsLocalDebugger + --launch -w + + + N:\DUMP\diva.exe + --launch -w + N:\DUMP + WindowsLocalDebugger + + + N:\DUMP\diva.exe + --launch -w + N:\DUMP + WindowsLocalDebugger + + + true + + \ No newline at end of file diff --git a/src/DivaGL/Glitter/glitter.cpp b/src/DivaGL/Glitter/glitter.cpp new file mode 100644 index 0000000..8914149 --- /dev/null +++ b/src/DivaGL/Glitter/glitter.cpp @@ -0,0 +1,146 @@ +/* + by korenkonder + GitHub/GitLab: korenkonder +*/ + +#include "glitter.hpp" +#include "../inject.hpp" +#include "../gl_state.hpp" +#include "../wrap.hpp" + +namespace Glitter { + void axis_angle_from_vectors(vec3* axis, float_t* angle, const vec3* vec1, const vec3* vec2) { + *axis = vec3::cross(*vec1, *vec2); + *angle = vec3::length(*axis); + if (*angle >= 0.000001f) + *angle = asinf(min_def(*angle, 1.0f)); + else { + *angle = 0.0f; + axis->x = vec1->z; + axis->y = 0.0f; + axis->z = vec1->x; + if (vec3::length(*axis) < 0.000001f) { + axis->x = -vec1->y; + axis->y = vec1->x; + axis->z = 0.0f; + } + } + + if (vec3::dot(*vec1, *vec2) < 0.0f) + *angle = (float_t)M_PI - *angle; + } + + void CreateBuffer(int32_t max_count, bool is_quad, GLuint& vao, GLuint& vbo, GLuint& ebo) { + glGenVertexArrays(1, &vao); + gl_state_bind_vertex_array(vao, true); + + glGenBuffers(1, &vbo); + gl_state_bind_array_buffer(vbo, true); + + glBufferData(GL_ARRAY_BUFFER, (GLsizeiptr)(sizeof(Buffer) * max_count), 0, GL_DYNAMIC_DRAW); + + if (is_quad) { + size_t count = (size_t)max_count / 4 * 5; + int32_t* ebo_data = (int32_t*)_operator_new(sizeof(int32_t) * (count - 1)); + for (size_t i = 0, j = 0, k = count / 5 - 1; i < count; i += 5, j += 4, k--) { + ebo_data[i + 0] = (uint32_t)(j + 0); + ebo_data[i + 1] = (uint32_t)(j + 1); + ebo_data[i + 2] = (uint32_t)(j + 3); + ebo_data[i + 3] = (uint32_t)(j + 2); + if (k) + ebo_data[i + 4] = 0xFFFFFFFF; + } + + glGenBuffers(1, &ebo); + gl_state_bind_element_array_buffer(ebo); + glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(int32_t) * (count - 1), ebo_data, GL_STATIC_DRAW); + _operator_delete(ebo_data); + } + else + ebo = 0; + + static const GLsizei buffer_size = sizeof(Buffer); + + glEnableVertexAttribArray(0); + glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, buffer_size, + (void*)offsetof(Buffer, position)); + glEnableVertexAttribArray(1); + glVertexAttribPointer(1, 4, GL_FLOAT, GL_FALSE, buffer_size, + (void*)offsetof(Buffer, uv)); + glEnableVertexAttribArray(2); + glVertexAttribPointer(2, 4, GL_FLOAT, GL_FALSE, buffer_size, + (void*)offsetof(Buffer, color)); + + gl_state_bind_array_buffer(0); + gl_state_bind_vertex_array(0); + if (is_quad) + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); + } + + void DeleteBuffer(GLuint& vao, GLuint& vbo, GLuint& ebo) { + if (ebo) { + glDeleteBuffers(1, &ebo); + ebo = 0; + } + + if (vbo) { + glDeleteBuffers(1, &vbo); + vbo = 0; + } + + if (vao) { + glDeleteVertexArrays(1, &vao); + vao = 0; + } + } + + // Particle + const char* _000000014039BC78_patch_data + = "\x48\x89\xE9\x48\xB8\x00\x00\x00\x00\x00\x00\x00\x80\xFF\xD0\xEB\x3D"; + const char* _00000001403AEA7E_patch_data + = "\x48\x89\xD9\x48\xB8\x00\x00\x00\x00\x00\x00\x00\x80\xFF\xD0\xEB\x0B"; + + // RenderGroup + const char* _00000001403A5CA7_patch_data + = "\x48\x8B\xCE\x48\xB8\x00\x00\x00\x00\x00\x00\x00\x80\xFF\xD0\xE9\x95\x00\x00\x00"; + const char* _00000001403A8552_patch_data + = "\x48\x89\xD9\x48\xB8\x00\x00\x00\x00\x00\x00\x00\x80\xFF\xD0\xEB\x07"; + + void Patch() { + uint8_t buf[0x100]; + + // Particle + inject_uint32_t((void*)0x000000014039A396, + 0x1B0 + sizeof(GLuint) * 2 + sizeof(DrawListData*)); + + memcpy(buf, _000000014039BC78_patch_data, 0x11); + *(uint64_t*)&buf[0x05] = (uint64_t)Particle::CreateBuffer; + inject_data((void*)0x000000014039BC78, buf, 0x11); + + memcpy(buf, _00000001403AEA7E_patch_data, 0x11); + *(uint64_t*)&buf[0x05] = (uint64_t)Particle::DeleteBuffer; + inject_data((void*)0x00000001403AEA7E, buf, 0x11); + + // RenderGroup + inject_uint32_t((void*)0x00000001403A9740, sizeof(RenderGroup)); + + memcpy(buf, _00000001403A5CA7_patch_data, 0x14); + *(uint64_t*)&buf[0x05] = (uint64_t)RenderGroup::CreateBuffer; + inject_data((void*)0x00000001403A5CA7, buf, 0x14); + + memcpy(buf, _00000001403A8552_patch_data, 0x11); + *(uint64_t*)&buf[0x05] = (uint64_t)RenderGroup::DeleteBuffer; + inject_data((void*)0x00000001403A8552, buf, 0x11); + + // RenderScene + buf[0x00] = 0x48; + buf[0x01] = 0xB8; + *(uint64_t*)&buf[0x02] = (uint64_t)RenderScene::Disp; + buf[0x0A] = 0xFF; + buf[0x0B] = 0xE0; + inject_data((void*)0x00000001403AA140, buf, 0x0C); + + // GltParticleManager + inject_uint64_t((void*)(0x00000001409EB880 + 0x20), (uint64_t)GltParticleManager::Disp); + } +} diff --git a/src/DivaGL/Glitter/glitter.hpp b/src/DivaGL/Glitter/glitter.hpp new file mode 100644 index 0000000..f1616be --- /dev/null +++ b/src/DivaGL/Glitter/glitter.hpp @@ -0,0 +1,322 @@ +/* + by korenkonder + GitHub/GitLab: korenkonder +*/ + +#pragma once + +#include "../../KKdLib/mat.hpp" +#include "../../KKdLib/vec.hpp" +#include "../gl.hpp" +#include "../types.hpp" +#include "../texture.hpp" + +namespace Glitter { + enum Direction { + DIRECTION_BILLBOARD = 0, + DIRECTION_EMITTER_DIRECTION = 1, + DIRECTION_PREV_POSITION = 2, + DIRECTION_EMIT_POSITION = 3, + DIRECTION_Y_AXIS = 4, + DIRECTION_X_AXIS = 5, + DIRECTION_Z_AXIS = 6, + DIRECTION_BILLBOARD_Y_AXIS = 7, + DIRECTION_PREV_POSITION_DUP = 8, + DIRECTION_EMITTER_ROTATION = 9, + DIRECTION_EFFECT_ROTATION = 10, + DIRECTION_PARTICLE_ROTATION = 11, + }; + + enum DispType { + DISP_OPAQUE = 0, + DISP_NORMAL = 1, + DISP_ALPHA = 2, + }; + + enum FogType { + FOG_NONE = 0, + FOG_DEPTH = 1, + FOG_HEIGHT = 2, + }; + + enum ParticleBlend { + PARTICLE_BLEND_ZERO = 0, + PARTICLE_BLEND_TYPICAL = 1, + PARTICLE_BLEND_ADD = 2, + PARTICLE_BLEND_SUBTRACT = 3, + PARTICLE_BLEND_MULTIPLY = 4, + PARTICLE_BLEND_PUNCH_THROUGH = 5, + }; + + enum ParticleFlag { + PARTICLE_NONE = 0x00000, + PARTICLE_LOOP = 0x00001, + PARTICLE_EMITTER_LOCAL = 0x00004, + PARTICLE_SCALE_Y_BY_X = 0x00010, + PARTICLE_REBOUND_PLANE = 0x00020, + PARTICLE_ROTATE_BY_EMITTER = 0x00040, + PARTICLE_SCALE = 0x00080, + PARTICLE_TEXTURE_MASK = 0x00100, + PARTICLE_DEPTH_TEST = 0x00200, + PARTICLE_ROTATE_LOCUS = 0x00800, + PARTICLE_LOCAL = 0x10000, + PARTICLE_EMISSION = 0x20000, + }; + + enum ParticleManagerFlag { + PARTICLE_MANAGER_PAUSE = 0x01, + PARTICLE_MANAGER_NOT_DISP = 0x02, + PARTICLE_MANAGER_RESET_SCENE_COUNTER = 0x04, + PARTICLE_MANAGER_READ_FILES = 0x08, + }; + + enum ParticleType { + PARTICLE_QUAD = 0, + PARTICLE_LINE = 1, + PARTICLE_LOCUS = 2, + }; + + enum Pivot { + PIVOT_TOP_LEFT = 0, + PIVOT_TOP_CENTER = 1, + PIVOT_TOP_RIGHT = 2, + PIVOT_MIDDLE_LEFT = 3, + PIVOT_MIDDLE_CENTER = 4, + PIVOT_MIDDLE_RIGHT = 5, + PIVOT_BOTTOM_LEFT = 6, + PIVOT_BOTTOM_CENTER = 7, + PIVOT_BOTTOM_RIGHT = 8, + }; + + enum SceneFlag { + SCENE_NONE = 0x00, + SCENE_FLAG_1 = 0x01, + SCENE_NOT_DISP = 0x02, + SCENE_FLAG_3 = 0x04, + }; + + struct Animation; + struct Buffer; + struct Camera; + struct Curve; + struct Effect; + struct Emitter; + struct EmitterInst; + struct ItemBase; + struct Node; + struct Particle; + struct ParticleInst; + struct Random; + struct RenderElement; + struct RenderGroup; + struct RenderScene; + + struct BatchShaderData; + struct Scene; + struct GltParticleManager; + +#define GPM Glitter::GltParticleManager* glt_particle_manager +#define GPM_VAL (glt_particle_manager) + + struct Buffer { + vec3 position; + vec2 uv[2]; + vec4 color; + }; + + struct LocusHistory { + struct Data { + vec3 translation; + vec4 color; + float_t scale; + }; + + struct Sub { + prj::vector vec; + int32_t count; + }; + + void* __vftable; + Sub sub; + }; + + struct Particle { + static void CreateBuffer(size_t data); + static void DeleteBuffer(size_t data); + }; + + struct RenderElement { + bool alive; + uint8_t uv_counter; + int32_t random; + float_t frame; + float_t life_time; + float_t rebound_time; + float_t frame_step_uv; + float_t speed; + float_t deceleration; + vec2 uv; + vec4 color; + vec3 base_translation; + vec3 translation; + vec3 translation_prev; + vec3 direction; + vec3 acceleration; + vec2 scale_particle; + vec3 scale; + vec3 rotation; + vec3 rotation_add; + float_t rot_z_cos; + float_t rot_z_sin; + float_t scale_all; + vec2 uv_scroll; + mat4 mat; + LocusHistory* locus_history; + }; + + struct EffectGroup { + void* __vftable; + std::vector effects; // Glitter::Effect + int32_t load_count; + texture** textures; + void* scene; // Glitter::Scene + float_t emission; + bool not_loaded; + bool scene_init; + bool buffer_init; + }; + + typedef prj::vector> DrawListData; + + struct RenderGroup { + void* __vftable; + ParticleFlag flags; + ParticleType type; + Direction draw_type; + ParticleBlend blend_mode; + ParticleBlend mask_blend_mode; + int32_t dword1C; + Pivot pivot; + int32_t split_u; + int32_t split_v; + vec2 split_uv; + float_t z_offset; + int32_t count; + int32_t ctrl; + int32_t texture; + int32_t mask_texture; + prj::string name; + float_t frame; + mat4 mat; + mat4 mat_rot; + bool has_mask; + int32_t dwordF0; + int32_t dwordF4; + RenderElement* elements; + Buffer* buffer; + int32_t max_count; + int32_t dword10C; + void* particle_inst; // Glitter::ParticleInst + DispType disp_type; + FogType fog_type; + GLuint vbo; + float_t emission; + bool use_own_buffer; + GLuint vao; + GLuint ebo; + size_t disp; + mat4 mat_draw; + DrawListData* draw_list; + + static mat4 RotateToEmitPosition(RenderGroup* rend_group, + RenderElement* rend_elem, vec3* vec); + static mat4 RotateToPrevPosition(RenderGroup* rend_group, + RenderElement* rend_elem, vec3* vec); + + static void CreateBuffer(RenderGroup* rend_group); + static void DeleteBuffer(RenderGroup* rend_group); + }; + + struct RenderScene { + prj::vector render_groups; + int32_t disp_quad; + int32_t disp_locus; + int32_t disp_line; + int32_t ctrl_quad; + int32_t ctrl_locus; + int32_t ctrl_line; + + static void CalcDisp(RenderScene* rend_sc); + static void CalcDisp(RenderScene* rend_sc, RenderGroup* rend_group); + static void CalcDispLine(RenderGroup* rend_group); + static void CalcDispLocus(RenderGroup* rend_group); + static void CalcDispQuad(RenderGroup* rend_group); + static void CalcDispQuadDirectionRotation( + RenderGroup* rend_group, mat4* model_mat, mat4* dir_mat); + static void CalcDispQuadNormal( + RenderGroup* rend_group, mat4* model_mat, mat4* dir_mat); + static void Disp(RenderScene* rend_sc, RenderGroup* rend_group); + + static void CalcDispLocusSetPivot(Pivot pivot, + float_t w, float_t& v00, float_t& v01); + static void CalcDispQuadSetPivot(Pivot pivot, + float_t w, float_t h, float_t& v00, float_t& v01, float_t& v10, float_t& v11); + }; + + struct SceneEffect { + void* ptr; // Glitter::EffectInst + bool draw; + }; + + struct Scene { + void* __vftable; + prj::vector effects; + uint32_t load_counter; + uint64_t hash; + SceneFlag flags; + float_t emission; + EffectGroup* effect_group; + RenderScene render_scene; + + static void CalcDisp(Scene* sc); + }; + + struct GltParticleManager { + void* __vftable; + uint8_t app_task_data[0x60]; + prj::map effect_groups; + void* field_78; + uint64_t field_80; + prj::vector scenes; + prj::vector file_readers; + void* sys_frame_rate; + ParticleManagerFlag flags; + int32_t scene_load_counter; + int32_t available_buffers_init; + int32_t available_buffers; + float_t field_D0; + float_t field_D4; + float_t emission; + float_t delta_frame; + prj::map resources; + uint32_t texture_counter; + int32_t field_F4; + int32_t field_F8; + int32_t random; + int32_t counter; + int32_t field_104; + + static void Disp(GPM); + }; + + extern GPM; + + extern void axis_angle_from_vectors(vec3* axis, float_t* angle, const vec3* vec0, const vec3* vec1); + + extern void CreateBuffer(int32_t max_count, bool is_quad, GLuint& vao, GLuint& vbo, GLuint& ebo); + extern void DeleteBuffer(GLuint& vao, GLuint& vbo, GLuint& ebo); + + extern void Patch(); + + extern void (FASTCALL* GltParticleManager__DispScenes)(GPM, DispType disp_type); +} diff --git a/src/DivaGL/Glitter/particle.cpp b/src/DivaGL/Glitter/particle.cpp new file mode 100644 index 0000000..7f93421 --- /dev/null +++ b/src/DivaGL/Glitter/particle.cpp @@ -0,0 +1,33 @@ +/* + by korenkonder + GitHub/GitLab: korenkonder +*/ + +#include "glitter.hpp" + +namespace Glitter { + void Particle::CreateBuffer(size_t data) { + ParticleType type = (ParticleType) * (int32_t*)(data + 0x40 + 0x00 + 0x08); + GLuint& vbo = ((GLuint*)(data + 0x40 + 0x160))[0]; + int32_t max_count = *(int32_t*)(data + 0x40 + 0x164); + GLuint& vao = ((GLuint*)(data + 0x40 + 0x170))[0]; + GLuint& ebo = ((GLuint*)(data + 0x40 + 0x170))[1]; + Glitter::CreateBuffer(max_count, type == PARTICLE_QUAD, vao, vbo, ebo); + + DrawListData*& draw_list = *(DrawListData**)(data + 0x40 + 0x170 + sizeof(GLuint) * 2); + draw_list = new DrawListData; + } + + void Particle::DeleteBuffer(size_t data) { + DrawListData*& draw_list = *(DrawListData**)(data + 0x40 + 0x170 + sizeof(GLuint) * 2); + if (draw_list) { + delete draw_list; + draw_list = 0; + } + + GLuint& vbo = ((GLuint*)(data + 0x40 + 0x160))[0]; + GLuint& vao = ((GLuint*)(data + 0x40 + 0x170))[0]; + GLuint& ebo = ((GLuint*)(data + 0x40 + 0x170))[1]; + Glitter::DeleteBuffer(vao, vbo, ebo); + } +} diff --git a/src/DivaGL/Glitter/particle_manager.cpp b/src/DivaGL/Glitter/particle_manager.cpp new file mode 100644 index 0000000..994d730 --- /dev/null +++ b/src/DivaGL/Glitter/particle_manager.cpp @@ -0,0 +1,23 @@ +/* + by korenkonder + GitHub/GitLab: korenkonder +*/ + +#include "glitter.hpp" +#include "../gl_state.hpp" + +namespace Glitter { + GPM = (GltParticleManager*)0x000000141199BB0; + + void GltParticleManager::Disp(GPM) { + if (glt_particle_manager->flags & PARTICLE_MANAGER_NOT_DISP) + return; + + for (Scene*& i : glt_particle_manager->scenes) + if (i) + Scene::CalcDisp(i); + } + + void (FASTCALL* GltParticleManager__DispScenes)(GPM, DispType disp_type) + = (void (FASTCALL*)(GPM, DispType disp_type))0x00000001403A1020; +} diff --git a/src/DivaGL/Glitter/render_group.cpp b/src/DivaGL/Glitter/render_group.cpp new file mode 100644 index 0000000..77ae9d0 --- /dev/null +++ b/src/DivaGL/Glitter/render_group.cpp @@ -0,0 +1,103 @@ +/* + by korenkonder + GitHub/GitLab: korenkonder +*/ + +#include "glitter.hpp" +#include "../gl_state.hpp" + +namespace Glitter { + mat4 RenderGroup::RotateToEmitPosition(RenderGroup* rend_group, + RenderElement* rend_elem, vec3* vec) { + vec3 vec2; + if (rend_group->flags & PARTICLE_EMITTER_LOCAL) + vec2 = rend_elem->translation; + else { + mat4_get_translation(&rend_group->mat, &vec2); + vec2 -= rend_elem->translation; + } + vec2 = vec3::normalize(vec2); + + mat4 mat; + if (fabsf(vec2.y) >= 0.000001f) { + mat = mat4_identity; + vec3 vec1 = *vec; + + vec3 axis; + float_t angle; + axis_angle_from_vectors(&axis, &angle, &vec1, &vec2); + mat4_mul_rotation(&mat, &axis, angle, &mat); + } + else + mat4_rotate_z((float_t)M_PI, &mat); + return mat; + } + + mat4 RenderGroup::RotateToPrevPosition(RenderGroup* rend_group, + RenderElement* rend_elem, vec3* vec) { + vec3 vec2 = rend_elem->translation - rend_elem->translation_prev; + + if (vec3::length_squared(vec2) < 0.000001f) + vec2 = rend_elem->translation; + vec2 = vec3::normalize(vec2); + + mat4 mat; + mat4_rotate_z((float_t)M_PI, &mat); + if (fabsf(vec2.y) >= 0.000001f) { + vec3 vec1 = *vec; + + vec3 axis; + float_t angle; + axis_angle_from_vectors(&axis, &angle, &vec1, &vec2); + mat4_mul_rotation(&mat, &axis, angle, &mat); + } + return mat; + } + + void RenderGroup::CreateBuffer(RenderGroup* rend_group) { + if (rend_group->use_own_buffer) { + if (rend_group->max_count > 0) { + rend_group->buffer = (Buffer*)_operator_new(sizeof(Buffer) * rend_group->max_count); + if (!rend_group->buffer) + rend_group->max_count = 0; + + ParticleType type = rend_group->type; + GLuint& vbo = rend_group->vbo; + int32_t max_count = rend_group->max_count; + GLuint& vao = rend_group->vao; + GLuint& ebo = rend_group->ebo; + Glitter::CreateBuffer(max_count, type == PARTICLE_QUAD, vao, vbo, ebo); + rend_group->draw_list = new DrawListData; + } + } + else { + size_t particle = *(size_t*)((size_t)rend_group->particle_inst + 0x98 + 0x178); + rend_group->vao = ((GLuint*)(particle + 0x40 + 0x170))[0]; + rend_group->ebo = ((GLuint*)(particle + 0x40 + 0x170))[1]; + rend_group->draw_list = *(DrawListData**)(particle + + 0x40 + 0x170 + sizeof(GLuint) * 2); + } + } + + void RenderGroup::DeleteBuffer(RenderGroup* rend_group) { + if (rend_group->use_own_buffer) { + DrawListData* draw_list = rend_group->draw_list; + if (draw_list) { + draw_list->clear(); + draw_list->shrink_to_fit(); + _operator_delete(draw_list); + rend_group->draw_list = 0; + } + + GLuint& vbo = rend_group->vbo; + GLuint& vao = rend_group->vao; + GLuint& ebo = rend_group->ebo; + Glitter::DeleteBuffer(vao, vbo, ebo); + } + else { + rend_group->vbo = 0; + rend_group->ebo = 0; + rend_group->draw_list = 0; + } + } +} diff --git a/src/DivaGL/Glitter/render_scene.cpp b/src/DivaGL/Glitter/render_scene.cpp new file mode 100644 index 0000000..30f0423 --- /dev/null +++ b/src/DivaGL/Glitter/render_scene.cpp @@ -0,0 +1,1042 @@ +/* + by korenkonder + GitHub/GitLab: korenkonder +*/ + +#include "glitter.hpp" +#include "../gl_state.hpp" +#include "../render_context.hpp" +#include "../shader_glsl_ft.hpp" +#include "../wrap.hpp" + +namespace Glitter { + void RenderScene::CalcDisp(RenderScene* rend_sc) { + rend_sc->disp_quad = 0; + rend_sc->disp_line = 0; + rend_sc->disp_locus = 0; + + bool (FASTCALL * RenderGroup_CannotDisp)(RenderGroup * rend_group) + = (bool(FASTCALL*)(RenderGroup * rend_group))0x00000001403A7120; + + for (RenderGroup*& i : rend_sc->render_groups) { + if (!i) + continue; + + RenderGroup* rend_group = i; + if (RenderGroup_CannotDisp(rend_group)) + continue; + + CalcDisp(rend_sc, rend_group); + } + } + + void RenderScene::CalcDisp(RenderScene* rend_sc, RenderGroup* rend_group) { + rend_group->disp = 0; + switch (rend_group->type) { + case PARTICLE_QUAD: + if (!rend_group->vao) + return; + + CalcDispQuad(rend_group); + rend_sc->disp_quad += (uint32_t)rend_group->disp; + break; + case PARTICLE_LINE: + if (!rend_group->vao) + return; + + CalcDispLine(rend_group); + rend_sc->disp_line += (uint32_t)rend_group->disp; + break; + case PARTICLE_LOCUS: + if (!rend_group->vao) + return; + + CalcDispLocus(rend_group); + rend_sc->disp_locus += (uint32_t)rend_group->disp; + break; + } + } + + void RenderScene::CalcDispLine(RenderGroup* rend_group) { + if (!rend_group->elements || !rend_group->vbo || rend_group->ctrl < 1) + return; + + size_t count = 0; + RenderElement* elem = rend_group->elements; + for (size_t i = rend_group->ctrl; i > 0; i--, elem++) { + if (!elem->alive) + continue; + + if (elem->locus_history) { + size_t length = elem->locus_history->sub.vec.size(); + if (length > 1) + count += length; + } + } + + if (!count || count > rend_group->max_count) + return; + + bool has_scale = false; + vec3 scale = 0.0f; + if (rend_group->flags & PARTICLE_EMITTER_LOCAL) { + mat4 mat; + mat4_transpose(&rend_group->mat, &mat); + mat4_get_scale(&mat, &scale); + scale -= 1.0f; + if (!(has_scale |= fabsf(scale.x) > 0.000001f ? true : false)) + scale.x = 0.0f; + if (!(has_scale |= fabsf(scale.y) > 0.000001f ? true : false)) + scale.y = 0.0f; + if (!(has_scale |= fabsf(scale.z) > 0.000001f ? true : false)) + scale.z = 0.0f; + mat4_normalize_rotation(&mat, &mat); + mat4_transpose(&mat, &rend_group->mat_draw); + } + else + rend_group->mat_draw = mat4_identity; + + Buffer* buf; + if (GL_VERSION_4_5) + buf = (Buffer*)glMapNamedBuffer(rend_group->vbo, GL_WRITE_ONLY); + else { + gl_state_bind_array_buffer(rend_group->vbo); + buf = (Buffer*)glMapBuffer(GL_ARRAY_BUFFER, GL_WRITE_ONLY); + } + + if (!buf) { + if (!GL_VERSION_4_5) + gl_state_bind_array_buffer(0); + return; + } + + elem = rend_group->elements; + size_t disp = 0; + rend_group->draw_list->clear(); + for (size_t i = rend_group->ctrl, index = 0; i > 0; elem++) { + if (!elem->alive) + continue; + + i--; + LocusHistory* hist = elem->locus_history; + if (elem->color.w < 0.01f || !hist || hist->sub.vec.size() < 2) + continue; + + size_t j = 0; + if (has_scale) + for (LocusHistory::Data& hist_data : hist->sub.vec) { + vec3& pos = hist_data.translation; + buf->position = pos + (pos - elem->base_translation) * scale; + buf->uv[0] = 0.0f; + buf->uv[1] = 0.0f; + buf->color = hist_data.color; + j++; + buf++; + } + else + for (LocusHistory::Data& hist_data : hist->sub.vec) { + buf->position = hist_data.translation; + buf->uv[0] = 0.0f; + buf->uv[1] = 0.0f; + buf->color = hist_data.color; + j++; + buf++; + } + + if (j > 0) { + disp += j; + rend_group->draw_list->push_back({ (GLint)index, (GLsizei)j }); + index += j; + } + } + rend_group->disp = disp; + + if (GL_VERSION_4_5) + glUnmapNamedBuffer(rend_group->vbo); + else { + glUnmapBuffer(GL_ARRAY_BUFFER); + gl_state_bind_array_buffer(0); + } + } + + void RenderScene::CalcDispLocus(RenderGroup* rend_group) { + if (!rend_group->elements || !rend_group->vbo || rend_group->ctrl < 1) + return; + + size_t count = 0; + RenderElement* elem = rend_group->elements; + for (size_t i = rend_group->ctrl; i > 0; i--, elem++) { + if (!elem->alive) + continue; + + if (elem->locus_history) { + LocusHistory* hist = elem->locus_history; + size_t length = elem->locus_history->sub.vec.size(); + if (length > 1) + count += 2 * length; + } + } + + if (!count || count > rend_group->max_count) + return; + + mat4 cam_view; + mat4 cam_inv_view; + mat4_transpose(&camera_data->view_matrix, &cam_view); + mat4_transpose(&camera_data->inv_view_matrix, &cam_inv_view); + + vec3 x_vec = { 1.0f, 0.0f, 0.0f }; + if (rend_group->flags & PARTICLE_LOCAL) { + mat4 mat; + mat4_transpose(&rend_group->mat, &mat); + mat4_mul(&cam_inv_view, &mat, &mat); + mat4_mul(&cam_view, &mat, &mat); + mat4_mul(&mat, &cam_inv_view, &mat); + mat4_transpose(&mat, &rend_group->mat_draw); + } + else + rend_group->mat_draw = mat4_identity; + + bool has_scale = false; + vec3 scale = 0.0f; + mat3 model_mat; + if (rend_group->flags & PARTICLE_EMITTER_LOCAL) { + mat4 mat; + mat4_transpose(&rend_group->mat, &mat); + mat4_get_scale(&mat, &scale); + if (rend_group->flags & PARTICLE_SCALE) + x_vec.x = scale.x; + scale -= 1.0f; + if (!(has_scale |= fabsf(scale.x) > 0.000001f ? true : false)) + scale.x = 0.0f; + if (!(has_scale |= fabsf(scale.y) > 0.000001f ? true : false)) + scale.y = 0.0f; + if (!(has_scale |= fabsf(scale.z) > 0.000001f ? true : false)) + scale.z = 0.0f; + + mat4 mat_rot; + mat4_transpose(&rend_group->mat_rot, &mat_rot); + mat4_transform_vector(&mat_rot, &scale, &scale); + + mat4_to_mat3(&mat, &model_mat); + mat3_normalize_rotation(&model_mat, &model_mat); + } + else + model_mat = mat3_identity; + + mat3 cam_inv_view_mat3; + mat4_to_mat3(&cam_inv_view, &cam_inv_view_mat3); + mat3_invert(&cam_inv_view_mat3, &cam_inv_view_mat3); + mat3_transform_vector(&cam_inv_view_mat3, &x_vec, &x_vec); + + Buffer* buf; + if (GL_VERSION_4_5) + buf = (Buffer*)glMapNamedBuffer(rend_group->vbo, GL_WRITE_ONLY); + else { + gl_state_bind_array_buffer(rend_group->vbo); + buf = (Buffer*)glMapBuffer(GL_ARRAY_BUFFER, GL_WRITE_ONLY); + } + + if (!buf) { + if (!GL_VERSION_4_5) + gl_state_bind_array_buffer(0); + return; + } + + elem = rend_group->elements; + vec2 split_uv = rend_group->split_uv; + Pivot pivot = rend_group->pivot; + size_t disp = 0; + rend_group->draw_list->clear(); + for (size_t i = rend_group->ctrl, index = 0; i > 0; elem++) { + if (!elem->alive) + continue; + + i--; + LocusHistory* hist = elem->locus_history; + if (elem->color.w < 0.01f || !hist || hist->sub.vec.size() < 2) + continue; + + float_t uv_u = elem->uv.x + elem->uv_scroll.x; + float_t uv_u_2nd = elem->uv.x + elem->uv_scroll.x + split_uv.x; + float_t uv_v_2nd = elem->uv.y + elem->uv_scroll.y + split_uv.y; + float_t uv_v_scale = split_uv.y / (float_t)(hist->sub.vec.size() - 1); + + uv_v_2nd = 1.0f - uv_v_2nd; + + size_t len = elem->locus_history->sub.vec.size(); + size_t j = 0; + if (has_scale) + for (LocusHistory::Data& hist_data : hist->sub.vec) { + vec3 pos = hist_data.translation; + vec3 pos_diff = (pos - elem->base_translation) * scale; + mat3_transform_vector(&model_mat, &pos_diff, &pos_diff); + pos += pos_diff; + + float_t v00; + float_t v01; + CalcDispLocusSetPivot(pivot, + hist_data.scale * elem->scale.x * elem->scale_all, + v00, v01); + + buf[0].position = pos + x_vec * v00; + buf[0].uv[0].x = uv_u; + buf[0].uv[0].y = uv_v_2nd + (float_t)j * uv_v_scale; + buf[0].uv[1] = buf[0].uv[0]; + buf[0].color = hist_data.color; + + buf[1].position = pos + x_vec * v01; + buf[1].uv[0].x = uv_u_2nd; + buf[1].uv[0].y = uv_v_2nd + (float_t)j * uv_v_scale; + buf[1].uv[1] = buf[1].uv[0]; + buf[1].color = hist_data.color; + j++; + buf += 2; + } + else + for (LocusHistory::Data& hist_data : hist->sub.vec) { + vec3 pos = hist_data.translation; + + float_t v00; + float_t v01; + CalcDispLocusSetPivot(pivot, + hist_data.scale * elem->scale.x * elem->scale_all, + v00, v01); + + buf[0].position = pos + x_vec * v00; + buf[0].uv[0].x = uv_u; + buf[0].uv[0].y = uv_v_2nd + (float_t)j * uv_v_scale; + buf[0].uv[1] = buf[0].uv[0]; + buf[0].color = hist_data.color; + + buf[1].position = pos + x_vec * v01; + buf[1].uv[0].x = uv_u_2nd; + buf[1].uv[0].y = uv_v_2nd + (float_t)j * uv_v_scale; + buf[1].uv[1] = buf[1].uv[0]; + buf[1].color = hist_data.color; + j++; + buf += 2; + } + + if (j > 0) { + disp += j; + rend_group->draw_list->push_back({ (GLint)index, (GLsizei)(j * 2) }); + index += j * 2; + } + } + rend_group->disp = disp; + + if (GL_VERSION_4_5) + glUnmapNamedBuffer(rend_group->vbo); + else { + glUnmapBuffer(GL_ARRAY_BUFFER); + gl_state_bind_array_buffer(0); + } + } + + void RenderScene::CalcDispQuad(RenderGroup* rend_group) { + if (!rend_group->elements || !rend_group->vbo || rend_group->ctrl < 1) + return; + + mat4 cam_view; + mat4 cam_inv_view; + mat4_transpose(&camera_data->view_matrix, &cam_view); + mat4_transpose(&camera_data->inv_view_matrix, &cam_inv_view); + + mat4 model_mat; + mat4 view_mat; + mat4 inv_view_mat; + if (rend_group->flags & PARTICLE_EMITTER_LOCAL) { + mat4_transpose(&rend_group->mat, &model_mat); + mat4_normalize_rotation(&model_mat, &view_mat); + mat4_mul(&view_mat, &cam_view, &view_mat); + mat4_invert(&view_mat, &inv_view_mat); + } + else { + model_mat = mat4_identity; + view_mat = cam_view; + inv_view_mat = cam_inv_view; + } + + if (rend_group->flags & PARTICLE_LOCAL) { + mat4 mat; + mat4_transpose(&rend_group->mat, &mat); + mat4_mul(&inv_view_mat, &mat, &inv_view_mat); + mat4_mul(&view_mat, &inv_view_mat, &view_mat); + mat4_invert(&view_mat, &inv_view_mat); + } + + mat4_mul(&view_mat, &cam_inv_view, &rend_group->mat_draw); + mat4_transpose(&rend_group->mat_draw, &rend_group->mat_draw); + + mat4 dir_mat; + switch (rend_group->draw_type) { + case DIRECTION_BILLBOARD: + mat4_clear_trans(&model_mat, &dir_mat); + mat4_mul(&dir_mat, &inv_view_mat, &dir_mat); + mat4_clear_trans(&dir_mat, &dir_mat); + break; + case DIRECTION_EMITTER_DIRECTION: + mat4_transpose(&rend_group->mat_rot, &dir_mat); + mat4_clear_trans(&dir_mat, &dir_mat); + break; + case DIRECTION_PREV_POSITION: + case DIRECTION_EMIT_POSITION: + case DIRECTION_PREV_POSITION_DUP: + if (rend_group->flags & PARTICLE_EMITTER_LOCAL) { + mat4_transpose(&rend_group->mat_rot, &dir_mat); + mat4_clear_trans(&dir_mat, &dir_mat); + } + else + dir_mat = mat4_identity; + break; + case DIRECTION_Y_AXIS: + mat4_rotate_y((float_t)-M_PI_2, &dir_mat); + break; + case DIRECTION_X_AXIS: + mat4_rotate_x((float_t)-M_PI_2, &dir_mat); + break; + case DIRECTION_Z_AXIS: + mat4_rotate_z((float_t)-M_PI_2, &dir_mat); + break; + case DIRECTION_BILLBOARD_Y_AXIS: + mat4_rotate_y(camera_data->rotation.y, &dir_mat); + break; + default: + dir_mat = mat4_identity; + break; + } + + switch (rend_group->draw_type) { + case DIRECTION_PREV_POSITION: + case DIRECTION_EMIT_POSITION: + case DIRECTION_PREV_POSITION_DUP: + CalcDispQuadDirectionRotation(rend_group, &model_mat, &dir_mat); + break; + default: + CalcDispQuadNormal(rend_group, &model_mat, &dir_mat); + break; + } + } + + void RenderScene::CalcDispQuadDirectionRotation( + RenderGroup* rend_group, mat4* model_mat, mat4* dir_mat) { + mat4 inv_model_mat; + mat4_invert(model_mat, &inv_model_mat); + mat4_clear_trans(&inv_model_mat, &inv_model_mat); + + vec3 x_vec_base = { 1.0f, 0.0f, 0.0f }; + vec3 y_vec_base = { 0.0f, 1.0f, 0.0f }; + + mat4_transform_vector(&inv_model_mat, &x_vec_base, &x_vec_base); + mat4_transform_vector(&inv_model_mat, &y_vec_base, &y_vec_base); + + vec3 up_vec; + mat4(*rotate_func)(RenderGroup*, RenderElement*, vec3*); + if (rend_group->draw_type == DIRECTION_EMIT_POSITION) { + up_vec = { 0.0f, 0.0f, 1.0f }; + rotate_func = RenderGroup::RotateToEmitPosition; + } + else { + up_vec = { 0.0f, 1.0f, 0.0f }; + rotate_func = RenderGroup::RotateToPrevPosition; + } + + vec3 scale; + mat4_get_scale(model_mat, &scale); + + Buffer* buf; + if (GL_VERSION_4_5) + buf = (Buffer*)glMapNamedBuffer(rend_group->vbo, GL_WRITE_ONLY); + else { + gl_state_bind_array_buffer(rend_group->vbo); + buf = (Buffer*)glMapBuffer(GL_ARRAY_BUFFER, GL_WRITE_ONLY); + } + + if (!buf) { + if (!GL_VERSION_4_5) + gl_state_bind_array_buffer(0); + return; + } + + bool use_scale = rend_group->flags & PARTICLE_SCALE ? true : false; + RenderElement* elem = rend_group->elements; + vec2 split_uv = rend_group->split_uv; + Pivot pivot = rend_group->pivot; + size_t disp = 0; + for (size_t i = rend_group->ctrl, j_max = 1024; i > 0; i -= j_max) { + j_max = min_def(i, j_max); + for (size_t j = j_max; j > 0; elem++) { + if (!elem->alive) + continue; + j--; + + if (elem->color.w < 0.01f) + continue; + + vec2 scale_particle = *(vec2*)&elem->scale * elem->scale_particle * elem->scale_all; + if (fabsf(scale_particle.x) < 0.000001f || fabsf(scale_particle.y) < 0.000001f) + continue; + + vec3 pos = elem->translation; + + float_t v00; + float_t v01; + float_t v10; + float_t v11; + CalcDispQuadSetPivot(pivot, + scale_particle.x, scale_particle.y, + v00, v01, v10, v11); + + vec2 pos_add[4]; + vec2 uv_add[4]; + pos_add[0].x = v00; + pos_add[0].y = v11; + uv_add[0].x = 0.0f; + uv_add[0].y = 0.0f; + pos_add[1].x = v00; + pos_add[1].y = v10; + uv_add[1].x = 0.0f; + uv_add[1].y = split_uv.y; + pos_add[2].x = v01; + pos_add[2].y = v10; + uv_add[2].x = split_uv.x; + uv_add[2].y = split_uv.y; + pos_add[3].x = v01; + pos_add[3].y = v11; + uv_add[3].x = split_uv.x; + uv_add[3].y = 0.0f; + + vec2 uv = elem->uv + elem->uv_scroll; + + mat4 mat = rotate_func(rend_group, elem, &up_vec); + mat4_clear_trans(&mat, &mat); + mat4_mul(dir_mat, &mat, &mat); + mat4_clear_trans(&mat, &mat); + + vec3 x_vec; + mat4_transform_vector(&mat, &x_vec_base, &x_vec); + vec3 y_vec; + mat4_transform_vector(&mat, &y_vec_base, &y_vec); + + if (use_scale) { + x_vec *= scale; + y_vec *= scale; + } + + float_t rot_z_cos = elem->rot_z_cos; + float_t rot_z_sin = elem->rot_z_sin; + for (int32_t k = 0; k < 4; k++, buf++) { + vec3 x_vec_rot = x_vec * (pos_add[k].x * rot_z_cos - pos_add[k].y * rot_z_sin); + vec3 y_vec_rot = y_vec * (pos_add[k].x * rot_z_sin + pos_add[k].y * rot_z_cos); + buf->position = pos + (x_vec_rot + y_vec_rot); + buf->uv[0] = uv + uv_add[k]; + buf->uv[1] = buf->uv[0]; + buf->color = elem->color; + } + disp++; + } + } + rend_group->disp = disp; + + if (GL_VERSION_4_5) + glUnmapNamedBuffer(rend_group->vbo); + else { + glUnmapBuffer(GL_ARRAY_BUFFER); + gl_state_bind_array_buffer(0); + } + } + + void RenderScene::CalcDispQuadNormal( + RenderGroup* rend_group, mat4* model_mat, mat4* dir_mat) { + mat4 inv_model_mat; + mat4_invert(model_mat, &inv_model_mat); + mat4_clear_trans(&inv_model_mat, &inv_model_mat); + + vec3 x_vec = { 1.0f, 0.0f, 0.0f }; + vec3 y_vec = { 0.0f, 1.0f, 0.0f }; + bool use_z_offset = false; + vec3 dist_to_cam = 0.0f; + mat4 z_offset_inv_mat = mat4_identity; + if (fabsf(rend_group->z_offset) > 0.000001f) { + use_z_offset = true; + mat4_get_translation(model_mat, &dist_to_cam); + dist_to_cam = camera_data->view_point - dist_to_cam; + if (rend_group->flags & PARTICLE_EMITTER_LOCAL) { + mat4_normalize_rotation(model_mat, &z_offset_inv_mat); + mat4_invert(&z_offset_inv_mat, &z_offset_inv_mat); + } + } + + bool has_scale = false; + bool emitter_local = false; + vec3 scale = 0.0f; + if (rend_group->flags & PARTICLE_EMITTER_LOCAL) { + mat4_get_scale(model_mat, &scale); + if (rend_group->flags & PARTICLE_SCALE) { + x_vec.x = scale.x; + y_vec.y = scale.y; + } + scale -= 1.0f; + if (!(has_scale |= fabsf(scale.x) > 0.000001f ? true : false)) + scale.x = 0.0f; + if (!(has_scale |= fabsf(scale.y) > 0.000001f ? true : false)) + scale.y = 0.0f; + if (!(has_scale |= fabsf(scale.z) > 0.000001f ? true : false)) + scale.z = 0.0f; + + mat4 mat_rot; + mat4_transpose(&rend_group->mat_rot, &mat_rot); + mat4_transform_vector(&mat_rot, &scale, &scale); + emitter_local = true; + } + + vec3 ext_anim_scale; + float_t some_scale = 0.0f; + bool (FASTCALL * RenderGroup_GetExtAnimScale)(RenderGroup * rend_group, + vec3 * ext_anim_scale, float_t * some_scale) = (bool(FASTCALL*)(RenderGroup * rend_group, + vec3 * ext_anim_scale, float_t * some_scale))0x00000001403A6800; + if (RenderGroup_GetExtAnimScale(rend_group, &ext_anim_scale, &some_scale)) { + if (some_scale <= 0.0f) + some_scale = 1.0f; + + ext_anim_scale += some_scale; + x_vec.x *= ext_anim_scale.x; + y_vec.y *= ext_anim_scale.y; + } + + if (rend_group->draw_type != DIRECTION_BILLBOARD) { + mat4_transform_vector(dir_mat, &x_vec, &x_vec); + mat4_transform_vector(dir_mat, &y_vec, &y_vec); + } + else + mat4_mul(&inv_model_mat, dir_mat, &inv_model_mat); + + mat4_transform_vector(&inv_model_mat, &x_vec, &x_vec); + mat4_transform_vector(&inv_model_mat, &y_vec, &y_vec); + + Buffer* buf; + if (GL_VERSION_4_5) + buf = (Buffer*)glMapNamedBuffer(rend_group->vbo, GL_WRITE_ONLY); + else { + gl_state_bind_array_buffer(rend_group->vbo); + buf = (Buffer*)glMapBuffer(GL_ARRAY_BUFFER, GL_WRITE_ONLY); + } + + if (!buf) { + if (!GL_VERSION_4_5) + gl_state_bind_array_buffer(0); + return; + } + + RenderElement* elem = rend_group->elements; + vec2 split_uv = rend_group->split_uv; + Pivot pivot = rend_group->pivot; + float_t z_offset = rend_group->z_offset; + size_t disp = 0; + if (rend_group->draw_type == DIRECTION_PARTICLE_ROTATION) + for (size_t i = rend_group->ctrl, j_max = 1024; i > 0; i -= j_max) { + j_max = min_def(i, j_max); + for (size_t j = j_max; j > 0; elem++) { + if (!elem->alive) + continue; + j--; + + if (elem->color.w < 0.01f) + continue; + + vec2 scale_particle = *(vec2*)&elem->scale * elem->scale_particle * elem->scale_all; + if (fabsf(scale_particle.x) < 0.000001f || fabsf(scale_particle.y) < 0.000001f) + continue; + + vec3 pos = elem->translation; + if (has_scale) { + vec3 pos_diff = (pos - elem->base_translation) * scale; + mat4_transform_vector(&inv_model_mat, &pos_diff, &pos_diff); + pos += pos_diff; + } + + float_t v00; + float_t v01; + float_t v11; + float_t v10; + CalcDispQuadSetPivot(pivot, + scale_particle.x, scale_particle.y, + v00, v01, v10, v11); + + vec2 pos_add[4]; + vec2 uv_add[4]; + pos_add[0].x = v00; + pos_add[0].y = v11; + uv_add[0].x = 0.0f; + uv_add[0].y = 0.0f; + pos_add[1].x = v00; + pos_add[1].y = v10; + uv_add[1].x = 0.0f; + uv_add[1].y = split_uv.y; + pos_add[2].x = v01; + pos_add[2].y = v10; + uv_add[2].x = split_uv.x; + uv_add[2].y = split_uv.y; + pos_add[3].x = v01; + pos_add[3].y = v11; + uv_add[3].x = split_uv.x; + uv_add[3].y = 0.0f; + + vec2 uv = elem->uv + elem->uv_scroll; + + if (use_z_offset) { + vec3 z_offset_dir = vec3::normalize(dist_to_cam - pos); + if (emitter_local) + mat4_transform_vector(&z_offset_inv_mat, &z_offset_dir, &z_offset_dir); + pos += z_offset_dir * z_offset; + } + + mat3 ptc_rot; + mat3_rotate_zyx(elem->rotation.x, elem->rotation.y, elem->rotation.z, &ptc_rot); + for (int32_t k = 0; k < 4; k++, buf++) { + vec3 xy_vec_rot; + xy_vec_rot.x = x_vec.x * pos_add[k].x; + xy_vec_rot.y = y_vec.y * pos_add[k].y; + xy_vec_rot.z = 0.0f; + mat3_transform_vector(&ptc_rot, &xy_vec_rot, &xy_vec_rot); + buf->position = pos + xy_vec_rot; + buf->uv[0] = uv + uv_add[k]; + buf->uv[1] = buf->uv[0]; + buf->color = elem->color; + } + disp++; + } + } + else + for (size_t i = rend_group->ctrl, j_max = 1024; i > 0; i -= j_max) { + j_max = min_def(i, j_max); + for (size_t j = j_max; j > 0; elem++) { + if (!elem->alive) + continue; + j--; + + if (elem->color.w < 0.01f) + continue; + + vec2 scale_particle = *(vec2*)&elem->scale * elem->scale_particle * elem->scale_all; + if (fabsf(scale_particle.x) < 0.000001f || fabsf(scale_particle.y) < 0.000001f) + continue; + + vec3 pos = elem->translation; + if (has_scale) { + vec3 pos_diff = (pos - elem->base_translation) * scale; + mat4_transform_vector(&inv_model_mat, &pos_diff, &pos_diff); + pos += pos_diff; + } + + float_t v00; + float_t v01; + float_t v11; + float_t v10; + CalcDispQuadSetPivot(pivot, + scale_particle.x, scale_particle.y, + v00, v01, v10, v11); + + vec2 pos_add[4]; + vec2 uv_add[4]; + pos_add[0].x = v00; + pos_add[0].y = v11; + uv_add[0].x = 0.0f; + uv_add[0].y = 0.0f; + pos_add[1].x = v00; + pos_add[1].y = v10; + uv_add[1].x = 0.0f; + uv_add[1].y = split_uv.y; + pos_add[2].x = v01; + pos_add[2].y = v10; + uv_add[2].x = split_uv.x; + uv_add[2].y = split_uv.y; + pos_add[3].x = v01; + pos_add[3].y = v11; + uv_add[3].x = split_uv.x; + uv_add[3].y = 0.0f; + + vec2 uv = elem->uv + elem->uv_scroll; + + if (use_z_offset) { + vec3 z_offset_dir = vec3::normalize(dist_to_cam - pos); + if (emitter_local) + mat4_transform_vector(&z_offset_inv_mat, &z_offset_dir, &z_offset_dir); + pos += z_offset_dir * z_offset; + } + + float_t rot_z_cos = elem->rot_z_cos; + float_t rot_z_sin = elem->rot_z_sin; + for (int32_t k = 0; k < 4; k++, buf++) { + vec3 x_vec_rot = x_vec * (rot_z_cos * pos_add[k].x - rot_z_sin * pos_add[k].y); + vec3 y_vec_rot = y_vec * (rot_z_sin * pos_add[k].x + rot_z_cos * pos_add[k].y); + buf->position = pos + (x_vec_rot + y_vec_rot); + buf->uv[0] = uv + uv_add[k]; + buf->uv[1] = buf->uv[0]; + buf->color = elem->color; + } + disp++; + } + } + rend_group->disp = disp; + + if (GL_VERSION_4_5) + glUnmapNamedBuffer(rend_group->vbo); + else { + glUnmapBuffer(GL_ARRAY_BUFFER); + gl_state_bind_array_buffer(0); + } + } + + void RenderScene::Disp(RenderScene* rend_sc, RenderGroup* rend_group) { + switch (rend_group->type) { + case PARTICLE_QUAD: + case PARTICLE_LINE: + case PARTICLE_LOCUS: + break; + default: + return; + } + + if (!rend_group->vao || rend_group->disp < 1) + return; + + mat4 cam_view; + mat4 cam_projection; + mat4_transpose(&camera_data->view_matrix, &cam_view); + mat4_transpose(&camera_data->projection_matrix, &cam_projection); + + mat4 mat; + mat4_transpose(&rend_group->mat_draw, &mat); + mat4_mul(&mat, &cam_view, &mat); + mat4_mul(&mat, &cam_projection, &mat); + + float_t emission = 1.0f; + if (rend_group->flags & PARTICLE_EMISSION || rend_group->blend_mode == PARTICLE_BLEND_TYPICAL) + emission = rend_group->emission; + + glitter_batch_shader_data shader_data = {}; + mat4_transpose(&mat, &mat); + shader_data.g_mvp[0] = mat.row0; + shader_data.g_mvp[1] = mat.row1; + shader_data.g_mvp[2] = mat.row2; + shader_data.g_mvp[3] = mat.row3; + shader_data.g_glitter_blend_color = 1.0f; + shader_data.g_state_material_diffuse = 0.0f; + shader_data.g_state_material_emission = { emission, emission, emission, 1.0f }; + rctx->glitter_batch_ubo.WriteMemory(shader_data); + + GLenum blend_src = GL_SRC_ALPHA; + GLenum blend_dst = GL_ONE_MINUS_SRC_ALPHA; + switch (rend_group->blend_mode) { + case PARTICLE_BLEND_ADD: + blend_src = GL_SRC_ALPHA; + blend_dst = GL_ONE; + break; + case PARTICLE_BLEND_MULTIPLY: + blend_src = GL_ZERO; + blend_dst = GL_SRC_COLOR; + break; + } + + gl_state_enable_blend(true); + gl_state_set_blend_func(blend_src, blend_dst, true); + gl_state_set_blend_equation(GL_FUNC_ADD, true); + + GLuint texture = rctx->empty_texture_2d; + GLuint mask_texture = rctx->empty_texture_2d; + if (rend_group->type != PARTICLE_LINE && rend_group->texture) { + texture = rend_group->texture; + if (rend_group->mask_texture) { + mask_texture = rend_group->mask_texture; + + uniform->arr[U_TEXTURE_COUNT] = 2; + switch (rend_group->mask_blend_mode) { + default: + uniform->arr[U_TEXTURE_BLEND] = 0; + break; + case PARTICLE_BLEND_MULTIPLY: + uniform->arr[U_TEXTURE_BLEND] = 1; + break; + case PARTICLE_BLEND_ADD: + uniform->arr[U_TEXTURE_BLEND] = 2; + break; + } + } + else { + uniform->arr[U_TEXTURE_COUNT] = 1; + uniform->arr[U_TEXTURE_BLEND] = 0; + } + } + else { + uniform->arr[U_TEXTURE_COUNT] = 0; + uniform->arr[U_TEXTURE_BLEND] = 0; + } + + gl_state_active_bind_texture_2d(0, texture, true); + gl_state_active_bind_texture_2d(1, mask_texture, true); + + switch (rend_group->type) { + case PARTICLE_QUAD: + switch (rend_group->fog_type) { + default: + uniform->arr[U_FOG_HEIGHT] = 0; + break; + case Glitter::FOG_DEPTH: + uniform->arr[U_FOG_HEIGHT] = 1; + break; + case Glitter::FOG_HEIGHT: + uniform->arr[U_FOG_HEIGHT] = 2; + break; + } + + if (rend_group->blend_mode == PARTICLE_BLEND_PUNCH_THROUGH) { + uniform->arr[U_ALPHA_BLEND] = 1; + gl_state_enable_depth_test(true); + gl_state_set_depth_mask(GL_TRUE, true); + } + else { + uniform->arr[U_ALPHA_BLEND] = rend_group->disp_type ? 2 : 0; + gl_state_enable_depth_test(true); + gl_state_set_depth_mask(GL_FALSE, true); + } + + if (rend_group->draw_type == DIRECTION_BILLBOARD) { + gl_state_enable_cull_face(true); + gl_state_set_cull_face_mode(GL_BACK, true); + } + else + gl_state_disable_cull_face(true); + break; + case PARTICLE_LINE: + uniform->arr[U_FOG_HEIGHT] = 0; + uniform->arr[U_ALPHA_BLEND] = 2; + + gl_state_enable_depth_test(true); + gl_state_set_depth_mask(GL_FALSE, true); + gl_state_enable_cull_face(true); + gl_state_set_cull_face_mode(GL_BACK, true); + break; + case PARTICLE_LOCUS: + uniform->arr[U_FOG_HEIGHT] = 0; + uniform->arr[U_ALPHA_BLEND] = 2; + + gl_state_enable_depth_test(true); + gl_state_set_depth_mask(GL_FALSE, true); + gl_state_disable_cull_face(true); + break; + } + + shaders_ft.set(SHADER_FT_GLITTER_PT); + rctx->glitter_batch_ubo.Bind(2); + switch (rend_group->type) { + case PARTICLE_QUAD: + gl_state_bind_vertex_array(rend_group->vao, true); + shaders_ft.enable_primitive_restart(); + shaders_ft.draw_elements(GL_TRIANGLE_STRIP, (GLsizei)(5 * rend_group->disp - 1), GL_UNSIGNED_INT, 0); + shaders_ft.disable_primitive_restart(); + gl_state_bind_vertex_array(0); + break; + case PARTICLE_LINE: + case PARTICLE_LOCUS: + gl_state_bind_vertex_array(rend_group->vao, true); + DrawListData& draw_list = *rend_group->draw_list; + if (rend_group->type == PARTICLE_LINE) + for (prj::pair& i : draw_list) + shaders_ft.draw_arrays(GL_LINE_STRIP, i.first, i.second); + else + for (prj::pair& i : draw_list) + shaders_ft.draw_arrays(GL_TRIANGLE_STRIP, i.first, i.second); + gl_state_bind_vertex_array(0); + break; + } + shaders_ft.set(-1); + } + + void RenderScene::CalcDispLocusSetPivot(Pivot pivot, + float_t w, float_t& v00, float_t& v01) { + switch (pivot) { + case PIVOT_TOP_LEFT: + case PIVOT_MIDDLE_LEFT: + case PIVOT_BOTTOM_LEFT: + v00 = 0.0f; + v01 = w; + break; + case PIVOT_TOP_CENTER: + case PIVOT_MIDDLE_CENTER: + case PIVOT_BOTTOM_CENTER: + default: + v00 = w * -0.5f; + v01 = w * 0.5f; + break; + case PIVOT_TOP_RIGHT: + case PIVOT_MIDDLE_RIGHT: + case PIVOT_BOTTOM_RIGHT: + v00 = -w; + v01 = 0.0f; + break; + } + } + + void RenderScene::CalcDispQuadSetPivot(Pivot pivot, + float_t w, float_t h, float_t& v00, float_t& v01, float_t& v10, float_t& v11) { + switch (pivot) { + case PIVOT_TOP_LEFT: + v00 = 0.0f; + v01 = w; + v10 = -h; + v11 = 0.0f; + break; + case PIVOT_TOP_CENTER: + v00 = w * -0.5f; + v01 = w * 0.5f; + v10 = -h; + v11 = 0.0f; + break; + case PIVOT_TOP_RIGHT: + v00 = -w; + v01 = 0.0f; + v10 = -h; + v11 = 0.0f; + break; + case PIVOT_MIDDLE_LEFT: + v00 = 0.0f; + v01 = w; + v10 = h * -0.5f; + v11 = h * 0.5f; + break; + case PIVOT_MIDDLE_CENTER: + default: + v00 = w * -0.5f; + v01 = w * 0.5f; + v10 = h * -0.5f; + v11 = h * 0.5f; + break; + case PIVOT_MIDDLE_RIGHT: + v00 = -w; + v01 = 0.0f; + v10 = h * -0.5f; + v11 = h * 0.5f; + break; + case PIVOT_BOTTOM_LEFT: + v00 = 0.0f; + v01 = w; + v10 = 0.0f; + v11 = h; + break; + case PIVOT_BOTTOM_CENTER: + v00 = w * -0.5f; + v01 = w * 0.5f; + v10 = 0.0f; + v11 = h; + break; + case PIVOT_BOTTOM_RIGHT: + v00 = -w; + v01 = 0.0f; + v10 = 0.0f; + v11 = h; + break; + } + } +} diff --git a/src/DivaGL/Glitter/scene.cpp b/src/DivaGL/Glitter/scene.cpp new file mode 100644 index 0000000..f926d8b --- /dev/null +++ b/src/DivaGL/Glitter/scene.cpp @@ -0,0 +1,14 @@ +/* + by korenkonder + GitHub/GitLab: korenkonder +*/ + +#include "glitter.hpp" +#include "../gl_state.hpp" + +namespace Glitter { + void Scene::CalcDisp(Scene* sc) { + if (!(sc->flags & SCENE_NOT_DISP)) + RenderScene::CalcDisp(&sc->render_scene); + } +} diff --git a/src/DivaGL/auth_3d.cpp b/src/DivaGL/auth_3d.cpp new file mode 100644 index 0000000..7b5667c --- /dev/null +++ b/src/DivaGL/auth_3d.cpp @@ -0,0 +1,750 @@ +/* + by korenkonder + GitHub/GitLab: korenkonder +*/ + +#include "auth_3d.hpp" +#include "../KKdLib/database/item_table.hpp" +#include "light_param/fog.hpp" +#include "mdl/disp_manager.hpp" +#include "rob/rob.hpp" +#include "object.hpp" +#include "render_context.hpp" +#include "sprite.hpp" +#include "texture.hpp" +#include "types.hpp" +#include + +enum auth_3d_camera_auxiliary_flags { + AUTH_3D_CAMERA_AUXILIARY_EXPOSURE = 0x01, + AUTH_3D_CAMERA_AUXILIARY_GAMMA = 0x02, + AUTH_3D_CAMERA_AUXILIARY_SATURATE = 0x04, + AUTH_3D_CAMERA_AUXILIARY_AUTO_EXPOSURE = 0x08, +}; + +enum auth_3d_ep_type { + AUTH_3D_EP_NONE = 0x00, + AUTH_3D_EP_LINEAR = 0x01, + AUTH_3D_EP_CYCLE = 0x02, + AUTH_3D_EP_CYCLE_OFFSET = 0x03, +}; + +enum auth_3d_fog_flags { + AUTH_3D_FOG_DENSITY = 0x01, + AUTH_3D_FOG_START = 0x02, + AUTH_3D_FOG_END = 0x04, + AUTH_3D_FOG_COLOR = 0x08, +}; + +enum auth_3d_key_type { + AUTH_3D_KEY_NONE = 0x00, + AUTH_3D_KEY_STATIC = 0x01, + AUTH_3D_KEY_LINEAR = 0x02, + AUTH_3D_KEY_HERMITE = 0x03, + AUTH_3D_KEY_HOLD = 0x04, +}; + +enum auth_3d_light_flags { + AUTH_3D_LIGHT_AMBIENT = 0x01, + AUTH_3D_LIGHT_DIFFUSE = 0x02, + AUTH_3D_LIGHT_SPECULAR = 0x04, + AUTH_3D_LIGHT_TONE_CURVE = 0x08, +}; + +enum auth_3d_object_texture_transform_flags { + AUTH_3D_OBJECT_TEX_TRANSFORM_COVERAGE_U = 0x001, + AUTH_3D_OBJECT_TEX_TRANSFORM_COVERAGE_V = 0x002, + AUTH_3D_OBJECT_TEX_TRANSFORM_REPEAT_U = 0x004, + AUTH_3D_OBJECT_TEX_TRANSFORM_REPEAT_V = 0x008, + AUTH_3D_OBJECT_TEX_TRANSFORM_TRANSLATE_FRAME_U = 0x010, + AUTH_3D_OBJECT_TEX_TRANSFORM_TRANSLATE_FRAME_V = 0x020, + AUTH_3D_OBJECT_TEX_TRANSFORM_OFFSET_U = 0x040, + AUTH_3D_OBJECT_TEX_TRANSFORM_OFFSET_V = 0x080, + AUTH_3D_OBJECT_TEX_TRANSFORM_ROTATE_FRAME = 0x100, + AUTH_3D_OBJECT_TEX_TRANSFORM_ROTATE = 0x200, +}; + +enum auth_3d_post_process_flags { + AUTH_3D_POST_PROCESS_LENS_FLARE = 0x01, + AUTH_3D_POST_PROCESS_LENS_SHAFT = 0x02, + AUTH_3D_POST_PROCESS_LENS_GHOST = 0x04, + AUTH_3D_POST_PROCESS_RADIUS = 0x08, + AUTH_3D_POST_PROCESS_INTENSITY = 0x10, + AUTH_3D_POST_PROCESS_SCENE_FADE = 0x20, +}; + +struct kft3 { + float_t frame; + float_t value; + float_t tangent1; + float_t tangent2; +}; + +static_assert(sizeof(kft3) == 0x10, "\"kft3\" struct should have a size of 0x10"); + +struct auth_3d_key { + auth_3d_key_type type; + float_t value; + float_t max_frame; + auth_3d_ep_type ep_type_pre; + auth_3d_ep_type ep_type_post; + float_t frame_delta; + float_t value_delta; + prj::vector keys_vec; + size_t length; + kft3* keys; +}; + +static_assert(sizeof(auth_3d_key) == 0x48, "\"auth_3d_key\" struct should have a size of 0x48"); + +struct auth_3d_vec3 { + auth_3d_key x; + auth_3d_key y; + auth_3d_key z; +}; + +static_assert(sizeof(auth_3d_vec3) == 0xD8, "\"auth_3d_vec3\" struct should have a size of 0xD8"); + +struct auth_3d_rgba { + auth_3d_key r; + auth_3d_key g; + auth_3d_key b; + auth_3d_key a; + bool has_r; + bool has_g; + bool has_b; + bool has_a; + int32_t field_124; + vec4 value; + bool has_got[4]; +}; + +static_assert(sizeof(auth_3d_rgba) == 0x140, "\"auth_3d_rgba\" struct should have a size of 0x140"); + +struct auth_3d_model_transform { + mat4 mat; + auth_3d_vec3 scale; + auth_3d_vec3 rotation; + auth_3d_vec3 translation; + auth_3d_key visibility; + vec3 scale_value; + vec3 rotation_value; + vec3 translation_value; + bool visible; +}; + +static_assert(sizeof(auth_3d_model_transform) == 0x338, "\"auth_3d_model_transform\" struct should have a size of 0x338"); + +struct auth_3d_curve { + auth_3d_key curve; + prj::string name; + float_t value; +}; + +static_assert(sizeof(auth_3d_curve) == 0x70, "\"auth_3d_curve\" struct should have a size of 0x70"); + +struct auth_3d_object_curve { + auth_3d_curve* curve; + prj::string name; + float_t frame_offset; + float_t value; +}; + +static_assert(sizeof(auth_3d_object_curve) == 0x30, "\"auth_3d_object_curve\" struct should have a size of 0x30"); + +struct auth_3d_object_texture_pattern { + prj::string name; + int32_t texture_id; + auth_3d_object_curve pattern; +}; + +static_assert(sizeof(auth_3d_object_texture_pattern) == 0x58, "\"auth_3d_object_texture_pattern\" struct should have a size of 0x58"); + +struct auth_3d_object_texture_transform { + auth_3d_object_texture_transform_flags flags; + prj::string name; + int32_t texture_id; + auth_3d_key coverageU; + auth_3d_key coverageV; + auth_3d_key repeatU; + auth_3d_key repeatV; + auth_3d_key translateFrameU; + auth_3d_key translateFrameV; + auth_3d_key offsetU; + auth_3d_key offsetV; + auth_3d_key rotateFrame; + auth_3d_key rotate; + mat4 mat; + vec3 scale_value; + vec3 repeat_value; + vec3 rotate_value; + vec3 translateFrame_value; +}; + +static_assert(sizeof(auth_3d_object_texture_transform) == 0x370, "\"auth_3d_object_texture_transform\" struct should have a size of 0x370"); + +struct auth_3d_object_hrc; + +struct auth_3d_object { + auth_3d_model_transform model_transform; + int64_t field_338; + prj::string name; + prj::string uid_name; + prj::string parent_name; + prj::string parent_node; + auth_3d_object_curve pattern; + auth_3d_object_curve morph; + prj::vector texture_pattern; + prj::vectortexture_transform; + prj::vector children_object; + prj::vector children_object_hrc; + object_info object_info; + bool reflect; + bool refract; +}; + +static_assert(sizeof(auth_3d_object) == 0x488, "\"auth_3d_object\" struct should have a size of 0x488"); + +struct auth_3d_object_model_transform { + mat4 mat; + mat4 mat_inner; + auth_3d_vec3 translation; + auth_3d_vec3 rotation; + auth_3d_vec3 scale; + auth_3d_key visibility; + vec3 translation_value; + vec3 rotation_value; + vec3 scale_value; + bool visible; + mat4 mat_rot; + int64_t field_3B8; + int32_t field_3C0; + mat4 field_3C4; + vec3 field_404; + float_t frame; + bool has_rotation; + bool has_translation; + bool has_scale; + bool has_visibility; +}; + +static_assert(sizeof(auth_3d_object_model_transform) == 0x418, "\"auth_3d_object_model_transform\" struct should have a size of 0x418"); + +struct auth_3d_object_node { + prj::string name; + int32_t bone_id; + int32_t parent; + auth_3d_object_model_transform model_transform; + mat4* mat; + mat4 joint_orient; +}; + +static_assert(sizeof(auth_3d_object_node) == 0x488, "\"auth_3d_object_node\" struct should have a size of 0x488"); + +struct auth_3d_object_hrc { + prj::vector node; + prj::vector node_bone_mats; + mat4* bone_mats; + prj::string name; + prj::string uid_name; + object_info object_info; + bool reflect; + bool refract; + bool shadow; + prj::string parent_name; + prj::string parent_node; + prj::vector children_object; + prj::vector children_object_parent_node; + prj::vector children_object_hrc; + prj::vector children_object_hrc_parent_node; +}; + +static_assert(sizeof(auth_3d_object_hrc) == 0x120, "\"auth_3d_object_hrc\" struct should have a size of 0x120"); + +struct auth_3d_object_instance { + prj::string name; + prj::string uid_name; + object_info object_info; + bool shadow; + auth_3d_object_model_transform model_transform; + prj::vector object_bone_indices; + prj::vector mats; +}; + +static_assert(sizeof(auth_3d_object_instance) == 0x490, "\"auth_3d_object_instance\" struct should have a size of 0x490"); + +struct auth_3d_m_object_hrc { + prj::string name; + auth_3d_object_model_transform model_transform; + prj::vector node; + prj::vector instance; +}; + +static_assert(sizeof(auth_3d_m_object_hrc) == 0x468, "\"auth_3d_m_object_hrc\" struct should have a size of 0x468"); + +struct auth_3d_time_event { + float_t frame; + int32_t type; + size_t event_index; +}; + +static_assert(sizeof(auth_3d_time_event) == 0x10, "\"auth_3d_time_event\" struct should have a size of 0x10"); + +struct auth_3d_play_control { + float_t begin; + float_t size; + float_t fps; +}; + +static_assert(sizeof(auth_3d_play_control) == 0x0C, "\"auth_3d_play_control\" struct should have a size of 0x0C"); + +struct auth_3d_point { + prj::string name; + auth_3d_model_transform model_transform; +}; + +static_assert(sizeof(auth_3d_point) == 0x358, "\"auth_3d_point\" struct should have a size of 0x358"); + +struct auth_3d_camera_root_view_point { + auth_3d_model_transform model_transform; + auth_3d_key roll; + bool has_fov; + bool fov_is_horizontal; + auth_3d_key fov; + float_t aspect; + auth_3d_key focal_length; + float_t camera_aperture_w; + float_t camera_aperture_h; +}; + +static_assert(sizeof(auth_3d_camera_root_view_point) == 0x428, "\"auth_3d_camera_root_view_point\" struct should have a size of 0x428"); + +struct auth_3d_camera_root { + auth_3d_model_transform model_transform; + auth_3d_camera_root_view_point view_point; + auth_3d_model_transform interest; +}; + +static_assert(sizeof(auth_3d_camera_root) == 0xA98, "\"auth_3d_camera_root\" struct should have a size of 0xA98"); + +struct auth_3d_camera_auxiliary { + auth_3d_camera_auxiliary_flags flags; + auth_3d_key exposure; + auth_3d_key gamma; + auth_3d_key saturate; + auth_3d_key auto_exposure; + float_t exposure_value; + float_t gamma_value; + float_t saturate_value; + float_t auto_exposure_value; +}; + +static_assert(sizeof(auth_3d_camera_auxiliary) == 0x138, "\"auth_3d_camera_auxiliary\" struct should have a size of 0x138"); + +struct auth_3d_light { + auth_3d_light_flags flags; + auth_3d_light_flags flags_init; + light_id id; + prj::string name; + prj::string type; + auth_3d_model_transform position; + auth_3d_model_transform spot_direction; + auth_3d_rgba Ambient; + auth_3d_rgba Diffuse; + auth_3d_rgba Specular; + auth_3d_rgba Tone_Curve; + vec4 Ambient_init; + vec4 Diffuse_init; + vec4 Specular_init; + vec4 Tone_Curve_init; +}; + +static_assert(sizeof(auth_3d_light) == 0xC00, "\"auth_3d_light\" struct should have a size of 0xC00"); + +struct auth_3d_fog { + auth_3d_fog_flags flags; + auth_3d_fog_flags flags_init; + fog_id id; + prj::string name; + auth_3d_key density; + auth_3d_key start; + auth_3d_key end; + float_t density_value; + float_t start_value; + float_t end_value; + auth_3d_rgba color; + float_t density_init; + float_t start_init; + float_t end_init; + vec4 color_init; +}; + +static_assert(sizeof(auth_3d_fog) == 0x278, "\"auth_3d_fog\" struct should have a size of 0x278"); + +struct auth_3d_post_process { + auth_3d_post_process_flags flags; + auth_3d_post_process_flags flags_init; + auth_3d_key lens_flare; + auth_3d_key lens_shaft; + auth_3d_key lens_ghost; + auth_3d_rgba radius; + auth_3d_rgba intensity; + auth_3d_rgba scene_fade; + vec3 lens_init; + vec4 radius_init_value; + vec4 intensity_init_value; + vec4 scene_fade_value; + vec3 lens_value; +}; + +static_assert(sizeof(auth_3d_post_process) == 0x4E8, "\"auth_3d_post_process\" struct should have a size of 0x4E8"); + +struct auth_3d_dof { + bool has_dof; + auth_3d_model_transform model_transform; +}; + +static_assert(sizeof(auth_3d_dof) == 0x340, "\"auth_3d_dof\" struct should have a size of 0x340"); + +struct auth_3d_chara { + prj::string name; + auth_3d_model_transform model_transform; + int32_t index; +}; + +static_assert(sizeof(auth_3d_chara) == 0x360, "\"auth_3d_chara\" struct should have a size of 0x360"); + +struct auth_3d_motion { + prj::string name; +}; + +static_assert(sizeof(auth_3d_motion) == 0x20, "\"auth_3d_motion\" struct should have a size of 0x20"); + +struct auth_3d_auth_2d { + prj::string name; +}; + +static_assert(sizeof(auth_3d_auth_2d) == 0x20, "\"auth_3d_auth_2d\" struct should have a size of 0x20"); + +struct auth_3d { + int32_t uid; + int32_t id; + bool enable; + bool camera_root_update; + bool visible; + bool repeat; + bool field_C; + bool ended; + bool left_right_reverse; + bool once; + mat4 mat; + float_t alpha; + mdl::ObjFlags obj_flags; + bool field_58; + prj::map field_60; + prj::vector texture_pattern; + int32_t chara_id; + object_info object_info; + mat4* bone_mats; + bool shadow; + chara_index src_chara; + chara_index dst_chara; + int32_t pos; + int64_t field_A8; + void* frame_rate; // FrameRateControl + float_t frame; + float_t req_frame; + float_t max_frame; + bool frame_changed; + float_t frame_offset; + float_t last_frame; + float_t fov_scale; + prj::vector* field_D8; + float_t blend; + int64_t field_E8; + int64_t field_F0; + bool paused; + prj::vector event; + prj::vector event_time; + auth_3d_time_event* event_time_next; + auth_3d_play_control play_control; + prj::vector point; + prj::vector curve; + prj::vector camera_root; + auth_3d_camera_auxiliary camera_auxiliary; + prj::vector light; + prj::vector fog; + auth_3d_post_process post_process; + auth_3d_dof dof; + prj::vector chara; + prj::vector motion; + prj::vector object; + prj::vector object_list; + prj::vector object_hrc; + prj::vector object_hrc_list; + prj::vector m_object_hrc; + prj::vector m_object_hrc_list; + prj::vector field_BE0; + prj::vector object_list_string; + prj::vector object_hrc_list_string; + prj::vector m_object_hrc_list_string; + prj::vector auth_2d; + int32_t state; + prj::vector field_C60; +}; + +static_assert(sizeof(auth_3d) == 0xC78, "\"auth_3d\" struct should have a size of 0xC78"); + +HOOK(void, FASTCALL, auth_3d_m_object_hrc_disp, 0x00000001401D0760, auth_3d_m_object_hrc* moh, auth_3d* auth) { + if (!auth->visible || !moh->model_transform.visible) + return; + + mdl::DispManager& disp_manager = *::disp_manager; + + for (auth_3d_object_instance& i : moh->instance) { + if (!i.model_transform.visible) + return; + + mdl::ObjFlags flags = mdl::OBJ_SSS; + shadow_type_enum shadow_type = SHADOW_CHARA; + if (auth->shadow || i.shadow) { + enum_or(flags, mdl::OBJ_4 | mdl::OBJ_SHADOW); + shadow_type = SHADOW_STAGE; + } + if (auth->alpha < 1.0f) + enum_or(flags, auth->obj_flags); + + disp_manager.set_obj_flags(flags); + disp_manager.set_shadow_type(shadow_type); + + Shadow* shad = shadow_ptr_get(); + if (shad && flags & mdl::OBJ_SHADOW) { + disp_manager.set_shadow_type(SHADOW_STAGE); + + mat4* m = &moh->model_transform.mat; + for (auth_3d_object_node& j : moh->node) + if (j.mat) { + m = j.mat; + break; + } + + mat4 mat = i.model_transform.mat; + mat4 t = *m; + mat4_mul(&mat, &t, &mat); + + vec3 pos = *(vec3*)&mat.row3; + pos.y -= 0.2f; + shad->field_1D0[shadow_type].push_back(pos); + } + + if (i.mats.size()) + disp_manager.entry_obj_by_object_info_object_skin( + i.object_info, 0, 0, auth->alpha, i.mats.data(), 0, 0, &i.model_transform.mat); + } + + disp_manager.set_obj_flags(); + disp_manager.set_shadow_type(SHADOW_CHARA); +} + +HOOK(void, FASTCALL, auth_3d_object_hrc_disp, 0x00000001401D04A0, auth_3d_object_hrc* oh, auth_3d* auth) { + if (!auth->visible || !oh->node.front().model_transform.visible) + return; + + mdl::DispManager& disp_manager = *::disp_manager; + + mdl::ObjFlags flags = mdl::OBJ_SSS; + if (auth->shadow | oh->shadow) + enum_or(flags, mdl::OBJ_4 | mdl::OBJ_SHADOW); + if (oh->reflect) + enum_or(flags, mdl::OBJ_NO_TRANSLUCENCY | mdl::OBJ_REFLECT); + if (oh->refract) + enum_or(flags, mdl::OBJ_NO_TRANSLUCENCY | mdl::OBJ_REFRACT); + if (auth->alpha < 1.0f) + enum_or(flags, auth->obj_flags); + + disp_manager.set_obj_flags(flags); + disp_manager.set_shadow_type(SHADOW_CHARA); + + mat4 mat = mat4_identity; + if (auth->chara_id >= 0 && auth->chara_id < ROB_CHARA_COUNT) { + size_t rob_chara_smth = get_rob_chara_smth(); + if (rob_chara_pv_data_array_check_chara_id(rob_chara_smth, auth->chara_id)) { + size_t rob_chr = rob_chara_array_get(rob_chara_smth, auth->chara_id); + mat4_mul(rob_chara_get_adjust_data_mat(rob_chr), sub_140516740(rob_chr), &mat); + if (auth->chara_id) + disp_manager.set_shadow_type(SHADOW_STAGE); + } + } + else if (flags & mdl::OBJ_SHADOW) { + disp_manager.set_shadow_type(SHADOW_STAGE); + + mat4* m = &oh->node.front().model_transform.mat; + for (auth_3d_object_node& i : oh->node) + if (i.mat) { + m = i.mat; + break; + } + + Shadow* shad = shadow_ptr_get(); + if (shad) { + vec3 pos = *(vec3*)&m->row3; + pos.y -= 0.2f; + shad->field_1D0[SHADOW_STAGE].push_back(pos); + } + } + + if (oh->node_bone_mats.size()) + disp_manager.entry_obj_by_object_info_object_skin( + oh->object_info, 0, 0, auth->alpha, oh->node_bone_mats.data(), 0, 0, &mat); + + disp_manager.set_obj_flags(); + disp_manager.set_shadow_type(SHADOW_CHARA); + + extern void FASTCALL implOfauth_3d_object_disp(auth_3d_object * o, auth_3d * auth); + + for (auth_3d_object*& i : oh->children_object) + implOfauth_3d_object_disp(i, auth); + + for (auth_3d_object_hrc*& i : oh->children_object_hrc) + implOfauth_3d_object_hrc_disp(i, auth); +} + +HOOK(void, FASTCALL, auth_3d_object_disp, 0x00000001401D0970, auth_3d_object* o, auth_3d* auth) { + if (!o->model_transform.visible) + return; + + if (!auth->visible) { + if (auth->pos) + spr::put_rgb_cross(&o->model_transform.mat); + + for (auth_3d_object*& i : o->children_object) + implOfauth_3d_object_disp(i, auth); + for (auth_3d_object_hrc*& i : o->children_object_hrc) + implOfauth_3d_object_hrc_disp(i, auth); + return; + } + + mat4 mat = o->model_transform.mat; + + mdl::DispManager& disp_manager = *::disp_manager; + + if (auth->chara_id >= 0 && auth->chara_id < ROB_CHARA_COUNT) { + size_t rob_chara_smth = get_rob_chara_smth(); + if (rob_chara_pv_data_array_check_chara_id(rob_chara_smth, auth->chara_id)) { + size_t rob_chr = rob_chara_array_get(rob_chara_smth, auth->chara_id); + mat4 m; + mat4_mul(rob_chara_get_adjust_data_mat(rob_chr), sub_140516740(rob_chr), &m); + mat4_mul(&mat, &m, &mat); + disp_manager.set_shadow_type(auth->chara_id ? SHADOW_STAGE : SHADOW_CHARA); + } + } + + mdl::ObjFlags flags = (mdl::ObjFlags)0; + if (auth->shadow) + enum_or(flags, mdl::OBJ_4 | mdl::OBJ_SHADOW); + if (o->reflect) + enum_or(flags, mdl::OBJ_NO_TRANSLUCENCY | mdl::OBJ_REFLECT); + if (o->refract) + enum_or(flags, mdl::OBJ_NO_TRANSLUCENCY | mdl::OBJ_REFRACT); + + disp_manager.set_obj_flags(flags); + + char buf[0x80]; + int32_t tex_pat_count = 0; + texture_pattern_struct tex_pat[TEXTURE_PATTERN_COUNT]; + + for (auth_3d_object_texture_pattern& i : o->texture_pattern) { + if (!i.pattern.curve || i.name.size() <= 3) + continue; + else if (tex_pat_count >= TEXTURE_PATTERN_COUNT) + break; + + sprintf_s(buf, sizeof(buf), "%.*s%03d", + (int32_t)(i.name.size() - 3), i.name.c_str(), (int32_t)prj::roundf(i.pattern.value)); + + tex_pat[tex_pat_count].src = i.texture_id; + tex_pat[tex_pat_count].dst = texture_info_get_id(buf); + tex_pat_count++; + } + + if (tex_pat_count) + disp_manager.set_texture_pattern(tex_pat_count, tex_pat); + + int32_t tex_trans_count = 0; + texture_transform_struct tex_trans[TEXTURE_TRANSFORM_COUNT]; + + for (auth_3d_object_texture_transform& i : o->texture_transform) { + if (tex_trans_count >= TEXTURE_TRANSFORM_COUNT || i.texture_id == -1 + || !texture_handler_get_texture(i.texture_id)) + break; + + tex_trans[tex_trans_count].id = i.texture_id; + tex_trans[tex_trans_count].mat = i.mat; + tex_trans_count++; + } + + if (tex_trans_count) + disp_manager.set_texture_transform(tex_trans_count, tex_trans); + + const char* uid_name = o->uid_name.c_str(); + int32_t uid_name_length = (int32_t)o->uid_name.size(); + + if (uid_name_length <= 3) + disp_manager.entry_obj_by_object_info(&mat, o->object_info); + else if (o->morph.curve) { + float_t morph = o->morph.value; + int32_t morph_int = (int32_t)morph; + morph = fmodf(morph, 1.0f); + if (morph > 0.0f && morph < 1.0f) { + sprintf_s(buf, sizeof(buf), "%.*s%03d", uid_name_length - 3, uid_name, morph_int + 1); + object_info morph_obj_info = obj_database_get_object_info(buf); + if (morph_obj_info.is_null()) + morph_obj_info = o->object_info; + disp_manager.set_morph(morph_obj_info, morph); + + sprintf_s(buf, sizeof(buf), "%.*s%03d", uid_name_length - 3, uid_name, morph_int); + object_info obj_info = obj_database_get_object_info(buf); + if (auth->alpha < 0.999f) + disp_manager.entry_obj_by_object_info(&mat, obj_info, auth->alpha); + else + disp_manager.entry_obj_by_object_info(&mat, obj_info); + disp_manager.set_morph({}, 0.0f); + } + else { + if (morph >= 1.0f) + morph_int++; + + sprintf_s(buf, sizeof(buf), "%.*s%03d", uid_name_length - 3, uid_name, morph_int); + object_info obj_info = obj_database_get_object_info(buf); + if (obj_info.is_null()) + obj_info = o->object_info; + disp_manager.entry_obj_by_object_info(&mat, obj_info); + } + } + else if (o->pattern.curve) { + sprintf_s(buf, sizeof(buf), "%.*s%03d", + uid_name_length - 3, uid_name, (int32_t)prj::roundf(o->pattern.value)); + object_info obj_info = obj_database_get_object_info(buf); + disp_manager.entry_obj_by_object_info(&mat, obj_info); + } + else + disp_manager.entry_obj_by_object_info(&mat, o->object_info); + + disp_manager.set_texture_transform(); + disp_manager.set_texture_pattern(); + disp_manager.set_obj_flags(); + + if (auth->pos) + spr::put_rgb_cross(&o->model_transform.mat); + + for (auth_3d_object*& i : o->children_object) + implOfauth_3d_object_disp(i, auth); + for (auth_3d_object_hrc*& i : o->children_object_hrc) + implOfauth_3d_object_hrc_disp(i, auth); +} + +void auth_3d_patch() { + INSTALL_HOOK(auth_3d_m_object_hrc_disp); + INSTALL_HOOK(auth_3d_object_hrc_disp); + INSTALL_HOOK(auth_3d_object_disp); +} diff --git a/src/DivaGL/auth_3d.hpp b/src/DivaGL/auth_3d.hpp new file mode 100644 index 0000000..b19bd21 --- /dev/null +++ b/src/DivaGL/auth_3d.hpp @@ -0,0 +1,12 @@ +/* + by korenkonder + GitHub/GitLab: korenkonder +*/ + +#pragma once + +#include "../KKdLib/default.hpp" +#include "../KKdLib/mat.hpp" +#include "../KKdLib/vec.hpp" + +extern void auth_3d_patch(); diff --git a/src/DivaGL/camera.cpp b/src/DivaGL/camera.cpp new file mode 100644 index 0000000..09dd676 --- /dev/null +++ b/src/DivaGL/camera.cpp @@ -0,0 +1,92 @@ +/* + by korenkonder + GitHub/GitLab: korenkonder +*/ + +#include "camera.hpp" +#include "render.hpp" +#include "resolution_mode.hpp" +#include + +camera_struct* camera_data = (camera_struct*)0x0000000140FBC2C0; + +static void (FASTCALL* camera_struct__update_view)(camera_struct* cam) + = (void (FASTCALL*)(camera_struct * cam))0x00000001401F7690; + +HOOK(void, FASTCALL, camera_data_update_projection, 0x00000001401F8E90) { + resolution_struct* res_wind_int = res_window_internal_get(); + resolution_struct* res_wind = res_window_get(); + + float_t sprite_half_width = (float_t)res_wind->width * 0.5f; + float_t sprite_half_height = (float_t)res_wind->height * 0.5f; + float_t render_half_width = (float_t)res_wind_int->width * 0.5f; + float_t render_half_height = (float_t)res_wind_int->height * 0.5f; + + static float_t field_20 = tanf(atanf(tanf(0.34557518363f) * 0.75f)); + + float_t aet_depth = sprite_half_height / field_20; + camera_data->aet_depth = aet_depth; + + float_t fov_correct_height = sprite_half_height / tanf(camera_data->fov * 0.5f * DEG_TO_RAD_FLOAT); + camera_data->fov_correct_height = fov_correct_height; + + float_t v8 = (float_t)camera_data->min_distance / aet_depth; + float_t v8a = v8 * sprite_half_width; + float_t v8b = v8 * sprite_half_height; + + mat4 spr_2d_proj; + mat4_frustrum(-v8a, v8a, v8b, -v8b, camera_data->min_distance, 3000.0, &spr_2d_proj); + + vec3 spr_2d_viewpoint = { sprite_half_width, sprite_half_height, aet_depth }; + vec3 spr_2d_interest = { sprite_half_width, sprite_half_height, 0.0f }; + vec3 spr_2d_up = { 0.0f, 1.0f, 0.0f }; + mat4 spr_2d_view; + mat4_look_at(&spr_2d_viewpoint, &spr_2d_interest, &spr_2d_up, &spr_2d_view); + + mat4_mul(&spr_2d_view, &spr_2d_proj, &camera_data->view_projection_aet_2d_matrix); + mat4_transpose(&camera_data->view_projection_aet_2d_matrix, + &camera_data->view_projection_aet_2d_matrix); + + float_t v13c = render_half_height / tanf(camera_data->fov * 0.5f * DEG_TO_RAD_FLOAT); + + float_t v13 = (float_t)camera_data->min_distance / v13c; + float_t v13a = v13 * render_half_width; + float_t v13b = v13 * render_half_height; + + mat4 spr_3d_proj; + mat4_frustrum(-v13a, v13a, v13b, -v13b, camera_data->min_distance, 3000.0, &spr_3d_proj); + + vec3 spr_3d_viewpoint = { render_half_width, render_half_height, v13c }; + vec3 spr_3d_interest = { render_half_width, render_half_height, 0.0f }; + vec3 spr_3d_up = { 0.0f, 1.0f, 0.0f }; + mat4 spr_3d_view; + mat4_look_at(&spr_3d_viewpoint, &spr_3d_interest, &spr_3d_up, &spr_3d_view); + + mat4_mul(&spr_3d_view, &spr_3d_proj, &camera_data->view_projection_aet_3d_matrix); + mat4_transpose(&camera_data->view_projection_aet_3d_matrix, + &camera_data->view_projection_aet_3d_matrix); + + render->calc_projection_matrix(&camera_data->projection_matrix, + camera_data->fov, camera_data->aspect, camera_data->min_distance, camera_data->max_distance, + camera_data->projection_scale.x, camera_data->projection_scale.y, + camera_data->projection_scale.z, camera_data->projection_scale.w); + camera_data->fov_horizontal_rad = tanf(camera_data->fov * 0.5f * DEG_TO_RAD_FLOAT); +} + +HOOK(void, FASTCALL, camera_update, 0x00000001401F8970) { + implOfcamera_data_update_projection(); + camera_struct__update_view(camera_data); + camera_data->fast_change_hist1 = camera_data->fast_change_hist0; + camera_data->fast_change_hist0 = camera_data->fast_change; + camera_data->fast_change = false; +} + +void camera_struct::update_data() { + implOfcamera_data_update_projection(); + camera_struct__update_view(camera_data); +} + +void camera_patch() { + INSTALL_HOOK(camera_data_update_projection); + INSTALL_HOOK(camera_update); +} diff --git a/src/DivaGL/camera.hpp b/src/DivaGL/camera.hpp new file mode 100644 index 0000000..0644066 --- /dev/null +++ b/src/DivaGL/camera.hpp @@ -0,0 +1,58 @@ +/* + by korenkonder + GitHub/GitLab: korenkonder +*/ + +#pragma once + +#include "../KKdLib/default.hpp" +#include "../KKdLib/mat.hpp" +#include "../KKdLib/vec.hpp" + +struct camera_struct { + vec3 view_point; + vec3 interest; + float_t roll; + float_t fov; + float_t field_20; + int32_t field_24; + double_t aspect; + float_t min_distance; + float_t max_distance; + vec4 projection_scale; + bool use_up; + char field_49; + char field_4A; + char field_4B; + vec3 up; + bool ignore_fov; + bool ignore_min_dist; + char field_5A; + char field_5B; + mat4 view_matrix; + mat4 inv_view_matrix; + mat4 projection_matrix; + mat4 view_projection_matrix; + mat4 view_projection_aet_2d_matrix; + mat4 view_projection_aet_3d_matrix; + float_t fov_correct_height; + float_t aet_depth; + vec3 field_1E4; + vec3 field_1F0; + vec3 field_1FC; + vec3 field_208; + float_t distance; + vec3 rotation; + float_t fov_horizontal_rad; + char field_228; + bool fast_change; + bool fast_change_hist0; + bool fast_change_hist1; + int32_t field_22C; + + static void update_data(); +}; + +extern camera_struct* camera_data; + +extern void camera_patch(); diff --git a/src/DivaGL/color.cpp b/src/DivaGL/color.cpp new file mode 100644 index 0000000..c36948a --- /dev/null +++ b/src/DivaGL/color.cpp @@ -0,0 +1,6 @@ +/* + by korenkonder + GitHub/GitLab: korenkonder +*/ + +#include "color.hpp" diff --git a/src/DivaGL/color.hpp b/src/DivaGL/color.hpp new file mode 100644 index 0000000..8d8bb19 --- /dev/null +++ b/src/DivaGL/color.hpp @@ -0,0 +1,77 @@ +/* + by korenkonder + GitHub/GitLab: korenkonder +*/ + +#pragma once + +#include "../KKdLib/default.hpp" +#include "../KKdLib/vec.hpp" + +struct color4u8 { + uint8_t r; + uint8_t g; + uint8_t b; + uint8_t a; + + inline color4u8() : r(), g(), b(), a() { + + } + + inline color4u8(uint8_t r, uint8_t g, uint8_t b, uint8_t a) : r(r), g(g), b(b), a(a) { + + } + + inline color4u8(uint32_t value) { + r = (uint8_t)(value & 0xFF); + g = (uint8_t)((value >> 8) & 0xFF); + b = (uint8_t)((value >> 16) & 0xFF); + a = (uint8_t)((value >> 24) & 0xFF); + } + + inline color4u8(vec4 value) { + vec4i _value = vec4i::store_xmm(_mm_cvtps_epi32(vec4::load_xmm(vec4::clamp(value, 0.0f, 1.0f) * 255.0f))); + r = (uint8_t)_value.x; + g = (uint8_t)_value.y; + b = (uint8_t)_value.z; + a = (uint8_t)_value.w; + } + + inline operator vec4() const { + return vec4::store_xmm(_mm_cvtepi32_ps(vec4i::load_xmm(vec4i(r, g, b, a)))) * (1.0f / 255.0f); + } +}; + +struct color4u8_bgra { + uint8_t b; + uint8_t g; + uint8_t r; + uint8_t a; + + inline color4u8_bgra() : r(), g(), b(), a() { + + } + + inline color4u8_bgra(uint8_t r, uint8_t g, uint8_t b, uint8_t a) : r(r), g(g), b(b), a(a) { + + } + + inline color4u8_bgra(uint32_t value) { + b = (uint8_t)(value & 0xFF); + g = (uint8_t)((value >> 8) & 0xFF); + r = (uint8_t)((value >> 16) & 0xFF); + a = (uint8_t)((value >> 24) & 0xFF); + } + + inline color4u8_bgra(vec4 value) { + vec4i _value = vec4i::store_xmm(_mm_cvtps_epi32(vec4::load_xmm(vec4::clamp(value, 0.0f, 1.0f) * 255.0f))); + r = (uint8_t)_value.x; + g = (uint8_t)_value.y; + b = (uint8_t)_value.z; + a = (uint8_t)_value.w; + } + + inline operator vec4() const { + return vec4::store_xmm(_mm_cvtepi32_ps(vec4i::load_xmm(vec4i(r, g, b, a)))) * (1.0f / 255.0f); + } +}; diff --git a/src/DivaGL/dllmain.cpp b/src/DivaGL/dllmain.cpp new file mode 100644 index 0000000..a9016c6 --- /dev/null +++ b/src/DivaGL/dllmain.cpp @@ -0,0 +1,133 @@ +/* + by korenkonder + GitHub/GitLab: korenkonder +*/ + +#include +#include "../KKdLib/default.hpp" +#include "hook.hpp" +#include "inject.hpp" +#include "print.hpp" +#include "shader_table.hpp" +#include "wrap.hpp" +#include +#include +#include + +size_t diva_handle; +size_t glut_handle; +size_t opengl32_handle; +size_t dll_handle; +bool aes_ni; +bool f16c; + +#if defined(DINPUT8_DLL) +struct dinput8 { + HMODULE dll; + HRESULT(*DirectInput8Create)(HINSTANCE hinst, + DWORD dwVersion, REFIID riidltf, LPVOID* ppvOut, LPUNKNOWN punkOuter); + + void LoadOriginalLibrary(HMODULE module) { + dll = module; + DirectInput8Create = (HRESULT(*)(HINSTANCE hinst, DWORD dwVersion, + REFIID riidltf, LPVOID * ppvOut, LPUNKNOWN punkOuter))GetProcAddress(dll, "DirectInput8Create"); + } +} dinput8; + +extern "C" __declspec(dllexport) HRESULT DirectInput8Create(HINSTANCE hinst, + DWORD dwVersion, REFIID riidltf, LPVOID * ppvOut, LPUNKNOWN punkOuter) { + if (!dinput8.DirectInput8Create) + return (HRESULT)0x80000002; + return dinput8.DirectInput8Create(hinst, dwVersion, riidltf, ppvOut, punkOuter); +} + +void load_original_dll() { + wchar_t dll_file_path[MAX_PATH]; + GetModuleFileNameW((HMODULE)dll_handle, dll_file_path, MAX_PATH); + + wchar_t* dll_file_name = wcsrchr(dll_file_path, '\\'); + if (!dll_file_name) + dll_file_name = wcsrchr(dll_file_path, '/'); + + if (!dll_file_name) + return; + + dll_file_name++; + + _wcslwr_s(dll_file_name, MAX_PATH - (dll_file_name - dll_file_path)); + + wchar_t* sys_folder; + if (dll_file_name && SUCCEEDED(SHGetKnownFolderPath(FOLDERID_System, 0, 0, &sys_folder))) { + size_t dll_path_len = wcslen(sys_folder) + wcslen(dll_file_name) + 2; + wchar_t* dll_path = (wchar_t*)malloc(sizeof(wchar_t) * dll_path_len); + if (dll_path) { + wcscpy_s(dll_path, dll_path_len, sys_folder); + wcscat_s(dll_path, dll_path_len, L"\\"); + wcscat_s(dll_path, dll_path_len, dll_file_name); + if (!wcscmp(dll_file_name, L"dinput8.dll")) { + HMODULE dinput8_handle = LoadLibraryW(dll_path); + if (dinput8_handle) + dinput8.LoadOriginalLibrary(dinput8_handle); + } + free(dll_path); + } + CoTaskMemFree((LPVOID)sys_folder); + } +} +#endif + +void FASTCALL divagl_main() { + int32_t cpuid_data[4] = {}; + __cpuid(cpuid_data, 1); + aes_ni = (cpuid_data[2] & (1 << 25)) ? true : false; + f16c = (cpuid_data[2] & (1 << 29)) ? true : false; + + glut_handle = (size_t)GetModuleHandleW(L"glut32.dll"); + opengl32_handle = (size_t)GetModuleHandleW(L"opengl32.dll"); + +#if defined(DINPUT8_DLL) + load_original_dll(); + LoadLibraryW(L"N:\\DUMP\\plugins\\DivaSound.dva"); + LoadLibraryW(L"N:\\DUMP\\plugins\\TLAC.dva"); +#endif + extern void FASTCALL wrap_addresses(); + wrap_addresses(); + //return; + + printf_divagl("Patching memory"); + hook_funcs(); + wrap_patch(); + inject_patches(); +} + +bool APIENTRY DllMain(HMODULE handle, DWORD ul_reason_for_call, LPVOID lpReserved) { + switch (ul_reason_for_call) { + case DLL_PROCESS_ATTACH: + /*if (!GetConsoleWindow()) + AllocConsole(); + + FILE* f_stdin = 0; + FILE* f_stdout = 0; + freopen_s(&f_stdin, "CONIN$", "r", stdin); + freopen_s(&f_stdout, "CONOUT$", "w", stdout);*/ + + dll_handle = (size_t)handle; + printf_divagl("Current version - v0.1.3.0"); + printf_divagl("Attach"); + divagl_main(); + break; + } + return true; +} + +extern "C" __declspec(dllexport) LPCWSTR GetPluginName(void) { + return L"DivaGL"; +} + +extern "C" __declspec(dllexport) LPCWSTR GetPluginDescription(void) { + return L"DivaGL Plugin by korenkonder"; +} + +extern "C" __declspec(dllexport) LPCWSTR GetBuildDate(void) { + return L"v0.2.0.0"; +} diff --git a/src/DivaGL/gl.hpp b/src/DivaGL/gl.hpp new file mode 100644 index 0000000..28be4ee --- /dev/null +++ b/src/DivaGL/gl.hpp @@ -0,0 +1,6371 @@ +/* + by korenkonder + GitHub/GitLab: korenkonder +*/ + +#pragma once + +#include "../KKdLib/default.hpp" +#include "../KKdLib/half_t.hpp" + +#define GLAPIENTRY APIENTRY + +#undef WGL_FONT_LINES +#undef WGL_FONT_POLYGONS + +typedef void GLvoid; + +typedef char GLchar; +typedef int8_t GLbyte; +typedef int16_t GLshort; +typedef int32_t GLint; +typedef int32_t GLsizei; +typedef int64_t GLint64; + +typedef uint8_t GLboolean; +typedef uint8_t GLubyte; +typedef uint16_t GLushort; +typedef uint32_t GLbitfield; +typedef uint32_t GLenum; +typedef uint32_t GLuint; +typedef uint64_t GLuint64; + +typedef float_t GLfloat; +typedef float_t GLclampf; +typedef double_t GLdouble; +typedef double_t GLclampd; + +typedef ptrdiff_t GLintptr; +typedef ptrdiff_t GLsizeiptr; + +typedef int64_t GLint64EXT; +typedef uint64_t GLuint64EXT; + +typedef half_t GLhalfNV; + +typedef char GLcharARB; +typedef uint32_t GLhandleARB; +typedef ptrdiff_t GLintptrARB; +typedef ptrdiff_t GLsizeiptrARB; + +typedef struct _HPBUFFERARB* HPBUFFERARB; +typedef struct _HPVIDEODEV* HPVIDEODEV; + +typedef enum AttribMask { + GL_CURRENT_BIT = 0x00000001, + GL_POINT_BIT = 0x00000002, + GL_LINE_BIT = 0x00000004, + GL_POLYGON_BIT = 0x00000008, + GL_POLYGON_STIPPLE_BIT = 0x00000010, + GL_PIXEL_MODE_BIT = 0x00000020, + GL_LIGHTING_BIT = 0x00000040, + GL_FOG_BIT = 0x00000080, + GL_DEPTH_BUFFER_BIT = 0x00000100, + GL_ACCUM_BUFFER_BIT = 0x00000200, + GL_STENCIL_BUFFER_BIT = 0x00000400, + GL_VIEWPORT_BIT = 0x00000800, + GL_TRANSFORM_BIT = 0x00001000, + GL_ENABLE_BIT = 0x00002000, + GL_COLOR_BUFFER_BIT = 0x00004000, + GL_HINT_BIT = 0x00008000, + GL_EVAL_BIT = 0x00010000, + GL_LIST_BIT = 0x00020000, + GL_TEXTURE_BIT = 0x00040000, + GL_SCISSOR_BIT = 0x00080000, + GL_MULTISAMPLE_BIT = 0x20000000, + GL_MULTISAMPLE_BIT_ARB = 0x20000000, + GL_MULTISAMPLE_BIT_EXT = 0x20000000, + GL_MULTISAMPLE_BIT_3DFX = 0x20000000, + GL_ALL_ATTRIB_BITS = 0xFFFFFFFF, +} AttribMask; + +typedef enum BufferStorageMask { + GL_DYNAMIC_STORAGE_BIT = 0x0100, + GL_DYNAMIC_STORAGE_BIT_EXT = 0x0100, + GL_CLIENT_STORAGE_BIT = 0x0200, + GL_CLIENT_STORAGE_BIT_EXT = 0x0200, + GL_SPARSE_STORAGE_BIT_ARB = 0x0400, + GL_LGPU_SEPARATE_STORAGE_BIT_NVX = 0x0800, + GL_PER_GPU_STORAGE_BIT_NV = 0x0800, + GL_EXTERNAL_STORAGE_BIT_NVX = 0x2000, +} BufferStorageMask; + +typedef enum ClearBufferMask { + GL_COVERAGE_BUFFER_BIT_NV = 0x00008000, +} ClearBufferMask; + +typedef enum ClientAttribMask { + GL_CLIENT_PIXEL_STORE_BIT = 0x00000001, + GL_CLIENT_VERTEX_ARRAY_BIT = 0x00000002, + GL_CLIENT_ALL_ATTRIB_BITS = 0xFFFFFFFF, +} ClientAttribMask; + +typedef enum ContextFlagMask { + GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT = 0x00000001, + GL_CONTEXT_FLAG_DEBUG_BIT = 0x00000002, + GL_CONTEXT_FLAG_DEBUG_BIT_KHR = 0x00000002, + GL_CONTEXT_FLAG_ROBUST_ACCESS_BIT = 0x00000004, + GL_CONTEXT_FLAG_ROBUST_ACCESS_BIT_ARB = 0x00000004, + GL_CONTEXT_FLAG_NO_ERROR_BIT = 0x00000008, + GL_CONTEXT_FLAG_NO_ERROR_BIT_KHR = 0x00000008, + GL_CONTEXT_FLAG_PROTECTED_CONTENT_BIT_EXT = 0x00000010, +} ContextFlagMask; + +typedef enum ContextProfileMask { + GL_CONTEXT_CORE_PROFILE_BIT = 0x00000001, + GL_CONTEXT_COMPATIBILITY_PROFILE_BIT = 0x00000002, +} ContextProfileMask; + +typedef enum MapBufferAccessMask { + GL_MAP_READ_BIT = 0x0001, + GL_MAP_READ_BIT_EXT = 0x0001, + GL_MAP_WRITE_BIT = 0x0002, + GL_MAP_WRITE_BIT_EXT = 0x0002, + GL_MAP_INVALIDATE_RANGE_BIT = 0x0004, + GL_MAP_INVALIDATE_RANGE_BIT_EXT = 0x0004, + GL_MAP_INVALIDATE_BUFFER_BIT = 0x0008, + GL_MAP_INVALIDATE_BUFFER_BIT_EXT = 0x0008, + GL_MAP_FLUSH_EXPLICIT_BIT = 0x0010, + GL_MAP_FLUSH_EXPLICIT_BIT_EXT = 0x0010, + GL_MAP_UNSYNCHRONIZED_BIT = 0x0020, + GL_MAP_UNSYNCHRONIZED_BIT_EXT = 0x0020, + GL_MAP_PERSISTENT_BIT = 0x0040, + GL_MAP_PERSISTENT_BIT_EXT = 0x0040, + GL_MAP_COHERENT_BIT = 0x0080, + GL_MAP_COHERENT_BIT_EXT = 0x0080, +} MapBufferAccessMask; + +typedef enum MemoryBarrierMask { + GL_VERTEX_ATTRIB_ARRAY_BARRIER_BIT = 0x00000001, + GL_VERTEX_ATTRIB_ARRAY_BARRIER_BIT_EXT = 0x00000001, + GL_ELEMENT_ARRAY_BARRIER_BIT = 0x00000002, + GL_ELEMENT_ARRAY_BARRIER_BIT_EXT = 0x00000002, + GL_UNIFORM_BARRIER_BIT = 0x00000004, + GL_UNIFORM_BARRIER_BIT_EXT = 0x00000004, + GL_TEXTURE_FETCH_BARRIER_BIT = 0x00000008, + GL_TEXTURE_FETCH_BARRIER_BIT_EXT = 0x00000008, + GL_SHADER_GLOBAL_ACCESS_BARRIER_BIT_NV = 0x00000010, + GL_SHADER_IMAGE_ACCESS_BARRIER_BIT = 0x00000020, + GL_SHADER_IMAGE_ACCESS_BARRIER_BIT_EXT = 0x00000020, + GL_COMMAND_BARRIER_BIT = 0x00000040, + GL_COMMAND_BARRIER_BIT_EXT = 0x00000040, + GL_PIXEL_BUFFER_BARRIER_BIT = 0x00000080, + GL_PIXEL_BUFFER_BARRIER_BIT_EXT = 0x00000080, + GL_TEXTURE_UPDATE_BARRIER_BIT = 0x00000100, + GL_TEXTURE_UPDATE_BARRIER_BIT_EXT = 0x00000100, + GL_BUFFER_UPDATE_BARRIER_BIT = 0x00000200, + GL_BUFFER_UPDATE_BARRIER_BIT_EXT = 0x00000200, + GL_FRAMEBUFFER_BARRIER_BIT = 0x00000400, + GL_FRAMEBUFFER_BARRIER_BIT_EXT = 0x00000400, + GL_TRANSFORM_FEEDBACK_BARRIER_BIT = 0x00000800, + GL_TRANSFORM_FEEDBACK_BARRIER_BIT_EXT = 0x00000800, + GL_ATOMIC_COUNTER_BARRIER_BIT = 0x00001000, + GL_ATOMIC_COUNTER_BARRIER_BIT_EXT = 0x00001000, + GL_SHADER_STORAGE_BARRIER_BIT = 0x00002000, + GL_CLIENT_MAPPED_BUFFER_BARRIER_BIT = 0x00004000, + GL_CLIENT_MAPPED_BUFFER_BARRIER_BIT_EXT = 0x00004000, + GL_QUERY_BUFFER_BARRIER_BIT = 0x00008000, + GL_ALL_BARRIER_BITS = 0xFFFFFFFF, + GL_ALL_BARRIER_BITS_EXT = 0xFFFFFFFF, +} MemoryBarrierMask; + +typedef enum OcclusionQueryEventMaskAMD { + GL_QUERY_DEPTH_PASS_EVENT_BIT_AMD = 0x00000001, + GL_QUERY_DEPTH_FAIL_EVENT_BIT_AMD = 0x00000002, + GL_QUERY_STENCIL_FAIL_EVENT_BIT_AMD = 0x00000004, + GL_QUERY_DEPTH_BOUNDS_FAIL_EVENT_BIT_AMD = 0x00000008, + GL_QUERY_ALL_EVENT_BITS_AMD = 0xFFFFFFFF, +} OcclusionQueryEventMaskAMD; + +typedef enum SyncObjectMask { + GL_SYNC_FLUSH_COMMANDS_BIT = 0x00000001, + GL_SYNC_FLUSH_COMMANDS_BIT_APPLE = 0x00000001, +} SyncObjectMask; + +typedef enum UseProgramStageMask { + GL_VERTEX_SHADER_BIT = 0x00000001, + GL_VERTEX_SHADER_BIT_EXT = 0x00000001, + GL_FRAGMENT_SHADER_BIT = 0x00000002, + GL_FRAGMENT_SHADER_BIT_EXT = 0x00000002, + GL_GEOMETRY_SHADER_BIT = 0x00000004, + GL_GEOMETRY_SHADER_BIT_EXT = 0x00000004, + GL_GEOMETRY_SHADER_BIT_OES = 0x00000004, + GL_TESS_CONTROL_SHADER_BIT = 0x00000008, + GL_TESS_CONTROL_SHADER_BIT_EXT = 0x00000008, + GL_TESS_CONTROL_SHADER_BIT_OES = 0x00000008, + GL_TESS_EVALUATION_SHADER_BIT = 0x00000010, + GL_TESS_EVALUATION_SHADER_BIT_EXT = 0x00000010, + GL_TESS_EVALUATION_SHADER_BIT_OES = 0x00000010, + GL_COMPUTE_SHADER_BIT = 0x00000020, + GL_MESH_SHADER_BIT_NV = 0x00000040, + GL_TASK_SHADER_BIT_NV = 0x00000080, + GL_ALL_SHADER_BITS = 0xFFFFFFFF, + GL_ALL_SHADER_BITS_EXT = 0xFFFFFFFF, +} UseProgramStageMask; + +typedef enum SubgroupSupportedFeatures { + GL_SUBGROUP_FEATURE_BASIC_BIT_KHR = 0x00000001, + GL_SUBGROUP_FEATURE_VOTE_BIT_KHR = 0x00000002, + GL_SUBGROUP_FEATURE_ARITHMETIC_BIT_KHR = 0x00000004, + GL_SUBGROUP_FEATURE_BALLOT_BIT_KHR = 0x00000008, + GL_SUBGROUP_FEATURE_SHUFFLE_BIT_KHR = 0x00000010, + GL_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT_KHR = 0x00000020, + GL_SUBGROUP_FEATURE_CLUSTERED_BIT_KHR = 0x00000040, + GL_SUBGROUP_FEATURE_QUAD_BIT_KHR = 0x00000080, + GL_SUBGROUP_FEATURE_PARTITIONED_BIT_NV = 0x00000100, +} SubgroupSupportedFeatures; + +typedef enum TextureStorageMaskAMD { + GL_TEXTURE_STORAGE_SPARSE_BIT_AMD = 0x00000001, +} TextureStorageMaskAMD; + +typedef enum FragmentShaderDestMaskATI { + GL_RED_BIT_ATI = 0x00000001, + GL_GREEN_BIT_ATI = 0x00000002, + GL_BLUE_BIT_ATI = 0x00000004, +} FragmentShaderDestMaskATI; + +typedef enum FragmentShaderDestModMaskATI { + GL_2X_BIT_ATI = 0x00000001, + GL_4X_BIT_ATI = 0x00000002, + GL_8X_BIT_ATI = 0x00000004, + GL_HALF_BIT_ATI = 0x00000008, + GL_QUARTER_BIT_ATI = 0x00000010, + GL_EIGHTH_BIT_ATI = 0x00000020, + GL_SATURATE_BIT_ATI = 0x00000040, +} FragmentShaderDestModMaskATI; + +typedef enum FragmentShaderColorModMaskATI { + GL_COMP_BIT_ATI = 0x00000002, + GL_NEGATE_BIT_ATI = 0x00000004, + GL_BIAS_BIT_ATI = 0x00000008, +} FragmentShaderColorModMaskATI; + +typedef enum TraceMaskMESA { + GL_TRACE_OPERATIONS_BIT_MESA = 0x0001, + GL_TRACE_PRIMITIVES_BIT_MESA = 0x0002, + GL_TRACE_ARRAYS_BIT_MESA = 0x0004, + GL_TRACE_TEXTURES_BIT_MESA = 0x0008, + GL_TRACE_PIXELS_BIT_MESA = 0x0010, + GL_TRACE_ERRORS_BIT_MESA = 0x0020, + GL_TRACE_ALL_BITS_MESA = 0xFFFF, +} TraceMaskMESA; + +typedef enum PathRenderingMaskNV { + GL_BOLD_BIT_NV = 0x01, + GL_ITALIC_BIT_NV = 0x02, + GL_GLYPH_WIDTH_BIT_NV = 0x01, + GL_GLYPH_HEIGHT_BIT_NV = 0x02, + GL_GLYPH_HORIZONTAL_BEARING_X_BIT_NV = 0x04, + GL_GLYPH_HORIZONTAL_BEARING_Y_BIT_NV = 0x08, + GL_GLYPH_HORIZONTAL_BEARING_ADVANCE_BIT_NV = 0x10, + GL_GLYPH_VERTICAL_BEARING_X_BIT_NV = 0x20, + GL_GLYPH_VERTICAL_BEARING_Y_BIT_NV = 0x40, + GL_GLYPH_VERTICAL_BEARING_ADVANCE_BIT_NV = 0x80, + GL_GLYPH_HAS_KERNING_BIT_NV = 0x100, + GL_FONT_X_MIN_BOUNDS_BIT_NV = 0x00010000, + GL_FONT_Y_MIN_BOUNDS_BIT_NV = 0x00020000, + GL_FONT_X_MAX_BOUNDS_BIT_NV = 0x00040000, + GL_FONT_Y_MAX_BOUNDS_BIT_NV = 0x00080000, + GL_FONT_UNITS_PER_EM_BIT_NV = 0x00100000, + GL_FONT_ASCENDER_BIT_NV = 0x00200000, + GL_FONT_DESCENDER_BIT_NV = 0x00400000, + GL_FONT_HEIGHT_BIT_NV = 0x00800000, + GL_FONT_MAX_ADVANCE_WIDTH_BIT_NV = 0x01000000, + GL_FONT_MAX_ADVANCE_HEIGHT_BIT_NV = 0x02000000, + GL_FONT_UNDERLINE_POSITION_BIT_NV = 0x04000000, + GL_FONT_UNDERLINE_THICKNESS_BIT_NV = 0x08000000, + GL_FONT_HAS_KERNING_BIT_NV = 0x10000000, + GL_FONT_NUM_GLYPH_INDICES_BIT_NV = 0x20000000, +} PathRenderingMaskNV; + +typedef enum PerformanceQueryCapsMaskINTEL { + GL_PERFQUERY_SINGLE_CONTEXT_INTEL = 0x00000000, + GL_PERFQUERY_GLOBAL_CONTEXT_INTEL = 0x00000001, +} PerformanceQueryCapsMaskINTEL; + +typedef enum VertexHintsMaskPGI { + GL_VERTEX23_BIT_PGI = 0x00000004, + GL_VERTEX4_BIT_PGI = 0x00000008, + GL_COLOR3_BIT_PGI = 0x00010000, + GL_COLOR4_BIT_PGI = 0x00020000, + GL_EDGEFLAG_BIT_PGI = 0x00040000, + GL_INDEX_BIT_PGI = 0x00080000, + GL_MAT_AMBIENT_BIT_PGI = 0x00100000, + GL_MAT_AMBIENT_AND_DIFFUSE_BIT_PGI = 0x00200000, + GL_MAT_DIFFUSE_BIT_PGI = 0x00400000, + GL_MAT_EMISSION_BIT_PGI = 0x00800000, + GL_MAT_COLOR_INDEXES_BIT_PGI = 0x01000000, + GL_MAT_SHININESS_BIT_PGI = 0x02000000, + GL_MAT_SPECULAR_BIT_PGI = 0x04000000, + GL_NORMAL_BIT_PGI = 0x08000000, + GL_TEXCOORD1_BIT_PGI = 0x10000000, + GL_TEXCOORD2_BIT_PGI = 0x20000000, + GL_TEXCOORD3_BIT_PGI = 0x40000000, + GL_TEXCOORD4_BIT_PGI = 0x80000000, +} VertexHintsMaskPGI; + +typedef enum BufferBitQCOM { + GL_COLOR_BUFFER_BIT0_QCOM = 0x00000001, + GL_COLOR_BUFFER_BIT1_QCOM = 0x00000002, + GL_COLOR_BUFFER_BIT2_QCOM = 0x00000004, + GL_COLOR_BUFFER_BIT3_QCOM = 0x00000008, + GL_COLOR_BUFFER_BIT4_QCOM = 0x00000010, + GL_COLOR_BUFFER_BIT5_QCOM = 0x00000020, + GL_COLOR_BUFFER_BIT6_QCOM = 0x00000040, + GL_COLOR_BUFFER_BIT7_QCOM = 0x00000080, + GL_DEPTH_BUFFER_BIT0_QCOM = 0x00000100, + GL_DEPTH_BUFFER_BIT1_QCOM = 0x00000200, + GL_DEPTH_BUFFER_BIT2_QCOM = 0x00000400, + GL_DEPTH_BUFFER_BIT3_QCOM = 0x00000800, + GL_DEPTH_BUFFER_BIT4_QCOM = 0x00001000, + GL_DEPTH_BUFFER_BIT5_QCOM = 0x00002000, + GL_DEPTH_BUFFER_BIT6_QCOM = 0x00004000, + GL_DEPTH_BUFFER_BIT7_QCOM = 0x00008000, + GL_STENCIL_BUFFER_BIT0_QCOM = 0x00010000, + GL_STENCIL_BUFFER_BIT1_QCOM = 0x00020000, + GL_STENCIL_BUFFER_BIT2_QCOM = 0x00040000, + GL_STENCIL_BUFFER_BIT3_QCOM = 0x00080000, + GL_STENCIL_BUFFER_BIT4_QCOM = 0x00100000, + GL_STENCIL_BUFFER_BIT5_QCOM = 0x00200000, + GL_STENCIL_BUFFER_BIT6_QCOM = 0x00400000, + GL_STENCIL_BUFFER_BIT7_QCOM = 0x00800000, + GL_MULTISAMPLE_BUFFER_BIT0_QCOM = 0x01000000, + GL_MULTISAMPLE_BUFFER_BIT1_QCOM = 0x02000000, + GL_MULTISAMPLE_BUFFER_BIT2_QCOM = 0x04000000, + GL_MULTISAMPLE_BUFFER_BIT3_QCOM = 0x08000000, + GL_MULTISAMPLE_BUFFER_BIT4_QCOM = 0x10000000, + GL_MULTISAMPLE_BUFFER_BIT5_QCOM = 0x20000000, + GL_MULTISAMPLE_BUFFER_BIT6_QCOM = 0x40000000, + GL_MULTISAMPLE_BUFFER_BIT7_QCOM = 0x80000000, +} BufferBitQCOM; + +typedef enum FoveationConfigBitQCOM { + GL_FOVEATION_ENABLE_BIT_QCOM = 0x00000001, + GL_FOVEATION_SCALED_BIN_METHOD_BIT_QCOM = 0x00000002, + GL_FOVEATION_SUBSAMPLED_LAYOUT_METHOD_BIT_QCOM = 0x00000004, +} FoveationConfigBitQCOM; + +typedef enum FfdMaskSGIX { + GL_TEXTURE_DEFORMATION_BIT_SGIX = 0x00000001, + GL_GEOMETRY_DEFORMATION_BIT_SGIX = 0x00000002, +} FfdMaskSGIX; + +typedef enum CommandOpcodesNV { + GL_TERMINATE_SEQUENCE_COMMAND_NV = 0x0000, + GL_NOP_COMMAND_NV = 0x0001, + GL_DRAW_ELEMENTS_COMMAND_NV = 0x0002, + GL_DRAW_ARRAYS_COMMAND_NV = 0x0003, + GL_DRAW_ELEMENTS_STRIP_COMMAND_NV = 0x0004, + GL_DRAW_ARRAYS_STRIP_COMMAND_NV = 0x0005, + GL_DRAW_ELEMENTS_INSTANCED_COMMAND_NV = 0x0006, + GL_DRAW_ARRAYS_INSTANCED_COMMAND_NV = 0x0007, + GL_ELEMENT_ADDRESS_COMMAND_NV = 0x0008, + GL_ATTRIBUTE_ADDRESS_COMMAND_NV = 0x0009, + GL_UNIFORM_ADDRESS_COMMAND_NV = 0x000A, + GL_BLEND_COLOR_COMMAND_NV = 0x000B, + GL_STENCIL_REF_COMMAND_NV = 0x000C, + GL_LINE_WIDTH_COMMAND_NV = 0x000D, + GL_POLYGON_OFFSET_COMMAND_NV = 0x000E, + GL_ALPHA_REF_COMMAND_NV = 0x000F, + GL_VIEWPORT_COMMAND_NV = 0x0010, + GL_SCISSOR_COMMAND_NV = 0x0011, + GL_FRONT_FACE_COMMAND_NV = 0x0012, +} CommandOpcodesNV; + +typedef enum MapTextureFormatINTEL { + GL_LAYOUT_DEFAULT_INTEL = 0, + GL_LAYOUT_LINEAR_INTEL = 1, + GL_LAYOUT_LINEAR_CPU_CACHED_INTEL = 2, +} MapTextureFormatINTEL; + +typedef enum PathRenderingTokenNV { + GL_CLOSE_PATH_NV = 0x00, + GL_MOVE_TO_NV = 0x02, + GL_RELATIVE_MOVE_TO_NV = 0x03, + GL_LINE_TO_NV = 0x04, + GL_RELATIVE_LINE_TO_NV = 0x05, + GL_HORIZONTAL_LINE_TO_NV = 0x06, + GL_RELATIVE_HORIZONTAL_LINE_TO_NV = 0x07, + GL_VERTICAL_LINE_TO_NV = 0x08, + GL_RELATIVE_VERTICAL_LINE_TO_NV = 0x09, + GL_QUADRATIC_CURVE_TO_NV = 0x0A, + GL_RELATIVE_QUADRATIC_CURVE_TO_NV = 0x0B, + GL_CUBIC_CURVE_TO_NV = 0x0C, + GL_RELATIVE_CUBIC_CURVE_TO_NV = 0x0D, + GL_SMOOTH_QUADRATIC_CURVE_TO_NV = 0x0E, + GL_RELATIVE_SMOOTH_QUADRATIC_CURVE_TO_NV = 0x0F, + GL_SMOOTH_CUBIC_CURVE_TO_NV = 0x10, + GL_RELATIVE_SMOOTH_CUBIC_CURVE_TO_NV = 0x11, + GL_SMALL_CCW_ARC_TO_NV = 0x12, + GL_RELATIVE_SMALL_CCW_ARC_TO_NV = 0x13, + GL_SMALL_CW_ARC_TO_NV = 0x14, + GL_RELATIVE_SMALL_CW_ARC_TO_NV = 0x15, + GL_LARGE_CCW_ARC_TO_NV = 0x16, + GL_RELATIVE_LARGE_CCW_ARC_TO_NV = 0x17, + GL_LARGE_CW_ARC_TO_NV = 0x18, + GL_RELATIVE_LARGE_CW_ARC_TO_NV = 0x19, + GL_CONIC_CURVE_TO_NV = 0x1A, + GL_RELATIVE_CONIC_CURVE_TO_NV = 0x1B, + GL_SHARED_EDGE_NV = 0xC0, + GL_ROUNDED_RECT_NV = 0xE8, + GL_RELATIVE_ROUNDED_RECT_NV = 0xE9, + GL_ROUNDED_RECT2_NV = 0xEA, + GL_RELATIVE_ROUNDED_RECT2_NV = 0xEB, + GL_ROUNDED_RECT4_NV = 0xEC, + GL_RELATIVE_ROUNDED_RECT4_NV = 0xED, + GL_ROUNDED_RECT8_NV = 0xEE, + GL_RELATIVE_ROUNDED_RECT8_NV = 0xEF, + GL_RESTART_PATH_NV = 0xF0, + GL_DUP_FIRST_CUBIC_CURVE_TO_NV = 0xF2, + GL_DUP_LAST_CUBIC_CURVE_TO_NV = 0xF4, + GL_RECT_NV = 0xF6, + GL_RELATIVE_RECT_NV = 0xF7, + GL_CIRCULAR_CCW_ARC_TO_NV = 0xF8, + GL_CIRCULAR_CW_ARC_TO_NV = 0xFA, + GL_CIRCULAR_TANGENT_ARC_TO_NV = 0xFC, + GL_ARC_TO_NV = 0xFE, + GL_RELATIVE_ARC_TO_NV = 0xFF, +} PathRenderingTokenNV; + +typedef enum TransformFeedbackTokenNV { + GL_NEXT_BUFFER_NV = -2, + GL_SKIP_COMPONENTS4_NV = -3, + GL_SKIP_COMPONENTS3_NV = -4, + GL_SKIP_COMPONENTS2_NV = -5, + GL_SKIP_COMPONENTS1_NV = -6, +} TransformFeedbackTokenNV; + +typedef enum TriangleListSUN { + GL_RESTART_SUN = 0x0001, + GL_REPLACE_MIDDLE_SUN = 0x0002, + GL_REPLACE_OLDEST_SUN = 0x0003, +} TriangleListSUN; + +typedef enum SpecialNumbers { + GL_FALSE = 0, + GL_NO_ERROR = 0, + GL_ZERO = 0, + GL_NONE = 0, + GL_NONE_OES = 0, + GL_TRUE = 1, + GL_ONE = 1, + GL_INVALID_INDEX = 0xFFFFFFFF, + GL_ALL_PIXELS_AMD = 0xFFFFFFFF, + GL_TIMEOUT_IGNORED = 0xFFFFFFFFFFFFFFFF, + GL_TIMEOUT_IGNORED_APPLE = 0xFFFFFFFFFFFFFFFF, + GL_VERSION_ES_CL_1_0 = 1, + GL_VERSION_ES_CM_1_1 = 1, + GL_VERSION_ES_CL_1_1 = 1, + GL_UUID_SIZE_EXT = 16, + GL_LUID_SIZE_EXT = 8, + WGL_CONTEXT_RELEASE_BEHAVIOR_NONE_ARB = 0, + WGL_FONT_LINES = 0, + WGL_FONT_POLYGONS = 1, +} SpecialNumbers; + +typedef enum GL { + GL_POINTS = 0x0000, + GL_LINES = 0x0001, + GL_LINE_LOOP = 0x0002, + GL_LINE_STRIP = 0x0003, + GL_TRIANGLES = 0x0004, + GL_TRIANGLE_STRIP = 0x0005, + GL_TRIANGLE_FAN = 0x0006, + GL_QUADS = 0x0007, + GL_QUADS_EXT = 0x0007, + GL_QUADS_OES = 0x0007, + GL_QUAD_STRIP = 0x0008, + GL_POLYGON = 0x0009, + GL_LINES_ADJACENCY = 0x000A, + GL_LINES_ADJACENCY_ARB = 0x000A, + GL_LINES_ADJACENCY_EXT = 0x000A, + GL_LINES_ADJACENCY_OES = 0x000A, + GL_LINE_STRIP_ADJACENCY = 0x000B, + GL_LINE_STRIP_ADJACENCY_ARB = 0x000B, + GL_LINE_STRIP_ADJACENCY_EXT = 0x000B, + GL_LINE_STRIP_ADJACENCY_OES = 0x000B, + GL_TRIANGLES_ADJACENCY = 0x000C, + GL_TRIANGLES_ADJACENCY_ARB = 0x000C, + GL_TRIANGLES_ADJACENCY_EXT = 0x000C, + GL_TRIANGLES_ADJACENCY_OES = 0x000C, + GL_TRIANGLE_STRIP_ADJACENCY = 0x000D, + GL_TRIANGLE_STRIP_ADJACENCY_ARB = 0x000D, + GL_TRIANGLE_STRIP_ADJACENCY_EXT = 0x000D, + GL_TRIANGLE_STRIP_ADJACENCY_OES = 0x000D, + GL_PATCHES = 0x000E, + GL_PATCHES_EXT = 0x000E, + GL_PATCHES_OES = 0x000E, + GL_ACCUM = 0x0100, + GL_LOAD = 0x0101, + GL_RETURN = 0x0102, + GL_MULT = 0x0103, + GL_ADD = 0x0104, + GL_NEVER = 0x0200, + GL_LESS = 0x0201, + GL_EQUAL = 0x0202, + GL_LEQUAL = 0x0203, + GL_GREATER = 0x0204, + GL_NOTEQUAL = 0x0205, + GL_GEQUAL = 0x0206, + GL_ALWAYS = 0x0207, + GL_SRC_COLOR = 0x0300, + GL_ONE_MINUS_SRC_COLOR = 0x0301, + GL_SRC_ALPHA = 0x0302, + GL_ONE_MINUS_SRC_ALPHA = 0x0303, + GL_DST_ALPHA = 0x0304, + GL_ONE_MINUS_DST_ALPHA = 0x0305, + GL_DST_COLOR = 0x0306, + GL_ONE_MINUS_DST_COLOR = 0x0307, + GL_SRC_ALPHA_SATURATE = 0x0308, + GL_SRC_ALPHA_SATURATE_EXT = 0x0308, + GL_FRONT_LEFT = 0x0400, + GL_FRONT_RIGHT = 0x0401, + GL_BACK_LEFT = 0x0402, + GL_BACK_RIGHT = 0x0403, + GL_FRONT = 0x0404, + GL_BACK = 0x0405, + GL_LEFT = 0x0406, + GL_RIGHT = 0x0407, + GL_FRONT_AND_BACK = 0x0408, + GL_AUX0 = 0x0409, + GL_AUX1 = 0x040A, + GL_AUX2 = 0x040B, + GL_AUX3 = 0x040C, + GL_INVALID_ENUM = 0x0500, + GL_INVALID_VALUE = 0x0501, + GL_INVALID_OPERATION = 0x0502, + GL_STACK_OVERFLOW = 0x0503, + GL_STACK_OVERFLOW_KHR = 0x0503, + GL_STACK_UNDERFLOW = 0x0504, + GL_STACK_UNDERFLOW_KHR = 0x0504, + GL_OUT_OF_MEMORY = 0x0505, + GL_INVALID_FRAMEBUFFER_OPERATION = 0x0506, + GL_INVALID_FRAMEBUFFER_OPERATION_EXT = 0x0506, + GL_INVALID_FRAMEBUFFER_OPERATION_OES = 0x0506, + GL_CONTEXT_LOST = 0x0507, + GL_CONTEXT_LOST_KHR = 0x0507, + GL_2D = 0x0600, + GL_3D = 0x0601, + GL_3D_COLOR = 0x0602, + GL_3D_COLOR_TEXTURE = 0x0603, + GL_4D_COLOR_TEXTURE = 0x0604, + GL_PASS_THROUGH_TOKEN = 0x0700, + GL_POINT_TOKEN = 0x0701, + GL_LINE_TOKEN = 0x0702, + GL_POLYGON_TOKEN = 0x0703, + GL_BITMAP_TOKEN = 0x0704, + GL_DRAW_PIXEL_TOKEN = 0x0705, + GL_COPY_PIXEL_TOKEN = 0x0706, + GL_LINE_RESET_TOKEN = 0x0707, + GL_EXP = 0x0800, + GL_EXP2 = 0x0801, + GL_CW = 0x0900, + GL_CCW = 0x0901, + GL_COEFF = 0x0A00, + GL_ORDER = 0x0A01, + GL_DOMAIN = 0x0A02, + GL_CURRENT_COLOR = 0x0B00, + GL_CURRENT_INDEX = 0x0B01, + GL_CURRENT_NORMAL = 0x0B02, + GL_CURRENT_TEXTURE_COORDS = 0x0B03, + GL_CURRENT_RASTER_COLOR = 0x0B04, + GL_CURRENT_RASTER_INDEX = 0x0B05, + GL_CURRENT_RASTER_TEXTURE_COORDS = 0x0B06, + GL_CURRENT_RASTER_POSITION = 0x0B07, + GL_CURRENT_RASTER_POSITION_VALID = 0x0B08, + GL_CURRENT_RASTER_DISTANCE = 0x0B09, + GL_POINT_SMOOTH = 0x0B10, + GL_POINT_SIZE = 0x0B11, + GL_POINT_SIZE_RANGE = 0x0B12, + GL_SMOOTH_POINT_SIZE_RANGE = 0x0B12, + GL_POINT_SIZE_GRANULARITY = 0x0B13, + GL_SMOOTH_POINT_SIZE_GRANULARITY = 0x0B13, + GL_LINE_SMOOTH = 0x0B20, + GL_LINE_WIDTH = 0x0B21, + GL_LINE_WIDTH_RANGE = 0x0B22, + GL_SMOOTH_LINE_WIDTH_RANGE = 0x0B22, + GL_LINE_WIDTH_GRANULARITY = 0x0B23, + GL_SMOOTH_LINE_WIDTH_GRANULARITY = 0x0B23, + GL_LINE_STIPPLE = 0x0B24, + GL_LINE_STIPPLE_PATTERN = 0x0B25, + GL_LINE_STIPPLE_REPEAT = 0x0B26, + GL_LIST_MODE = 0x0B30, + GL_MAX_LIST_NESTING = 0x0B31, + GL_LIST_BASE = 0x0B32, + GL_LIST_INDEX = 0x0B33, + GL_POLYGON_MODE = 0x0B40, + GL_POLYGON_MODE_NV = 0x0B40, + GL_POLYGON_SMOOTH = 0x0B41, + GL_POLYGON_STIPPLE = 0x0B42, + GL_EDGE_FLAG = 0x0B43, + GL_CULL_FACE = 0x0B44, + GL_CULL_FACE_MODE = 0x0B45, + GL_FRONT_FACE = 0x0B46, + GL_LIGHTING = 0x0B50, + GL_LIGHT_MODEL_LOCAL_VIEWER = 0x0B51, + GL_LIGHT_MODEL_TWO_SIDE = 0x0B52, + GL_LIGHT_MODEL_AMBIENT = 0x0B53, + GL_SHADE_MODEL = 0x0B54, + GL_COLOR_MATERIAL_FACE = 0x0B55, + GL_COLOR_MATERIAL_PARAMETER = 0x0B56, + GL_COLOR_MATERIAL = 0x0B57, + GL_FOG = 0x0B60, + GL_FOG_INDEX = 0x0B61, + GL_FOG_DENSITY = 0x0B62, + GL_FOG_START = 0x0B63, + GL_FOG_END = 0x0B64, + GL_FOG_MODE = 0x0B65, + GL_FOG_COLOR = 0x0B66, + GL_DEPTH_RANGE = 0x0B70, + GL_DEPTH_TEST = 0x0B71, + GL_DEPTH_WRITEMASK = 0x0B72, + GL_DEPTH_CLEAR_VALUE = 0x0B73, + GL_DEPTH_FUNC = 0x0B74, + GL_ACCUM_CLEAR_VALUE = 0x0B80, + GL_STENCIL_TEST = 0x0B90, + GL_STENCIL_CLEAR_VALUE = 0x0B91, + GL_STENCIL_FUNC = 0x0B92, + GL_STENCIL_VALUE_MASK = 0x0B93, + GL_STENCIL_FAIL = 0x0B94, + GL_STENCIL_PASS_DEPTH_FAIL = 0x0B95, + GL_STENCIL_PASS_DEPTH_PASS = 0x0B96, + GL_STENCIL_REF = 0x0B97, + GL_STENCIL_WRITEMASK = 0x0B98, + GL_MATRIX_MODE = 0x0BA0, + GL_NORMALIZE = 0x0BA1, + GL_VIEWPORT = 0x0BA2, + GL_MODELVIEW_STACK_DEPTH = 0x0BA3, + GL_MODELVIEW0_STACK_DEPTH_EXT = 0x0BA3, + GL_PATH_MODELVIEW_STACK_DEPTH_NV = 0x0BA3, + GL_PROJECTION_STACK_DEPTH = 0x0BA4, + GL_PATH_PROJECTION_STACK_DEPTH_NV = 0x0BA4, + GL_TEXTURE_STACK_DEPTH = 0x0BA5, + GL_MODELVIEW_MATRIX = 0x0BA6, + GL_MODELVIEW0_MATRIX_EXT = 0x0BA6, + GL_PATH_MODELVIEW_MATRIX_NV = 0x0BA6, + GL_PROJECTION_MATRIX = 0x0BA7, + GL_PATH_PROJECTION_MATRIX_NV = 0x0BA7, + GL_TEXTURE_MATRIX = 0x0BA8, + GL_ATTRIB_STACK_DEPTH = 0x0BB0, + GL_CLIENT_ATTRIB_STACK_DEPTH = 0x0BB1, + GL_ALPHA_TEST = 0x0BC0, + GL_ALPHA_TEST_QCOM = 0x0BC0, + GL_ALPHA_TEST_FUNC = 0x0BC1, + GL_ALPHA_TEST_FUNC_QCOM = 0x0BC1, + GL_ALPHA_TEST_REF = 0x0BC2, + GL_ALPHA_TEST_REF_QCOM = 0x0BC2, + GL_DITHER = 0x0BD0, + GL_BLEND_DST = 0x0BE0, + GL_BLEND_SRC = 0x0BE1, + GL_BLEND = 0x0BE2, + GL_LOGIC_OP_MODE = 0x0BF0, + GL_INDEX_LOGIC_OP = 0x0BF1, + GL_LOGIC_OP = 0x0BF1, + GL_COLOR_LOGIC_OP = 0x0BF2, + GL_AUX_BUFFERS = 0x0C00, + GL_DRAW_BUFFER = 0x0C01, + GL_DRAW_BUFFER_EXT = 0x0C01, + GL_READ_BUFFER = 0x0C02, + GL_READ_BUFFER_EXT = 0x0C02, + GL_READ_BUFFER_NV = 0x0C02, + GL_SCISSOR_BOX = 0x0C10, + GL_SCISSOR_TEST = 0x0C11, + GL_INDEX_CLEAR_VALUE = 0x0C20, + GL_INDEX_WRITEMASK = 0x0C21, + GL_COLOR_CLEAR_VALUE = 0x0C22, + GL_COLOR_WRITEMASK = 0x0C23, + GL_INDEX_MODE = 0x0C30, + GL_RGBA_MODE = 0x0C31, + GL_DOUBLEBUFFER = 0x0C32, + GL_STEREO = 0x0C33, + GL_RENDER_MODE = 0x0C40, + GL_PERSPECTIVE_CORRECTION_HINT = 0x0C50, + GL_POINT_SMOOTH_HINT = 0x0C51, + GL_LINE_SMOOTH_HINT = 0x0C52, + GL_POLYGON_SMOOTH_HINT = 0x0C53, + GL_FOG_HINT = 0x0C54, + GL_TEXTURE_GEN_S = 0x0C60, + GL_TEXTURE_GEN_T = 0x0C61, + GL_TEXTURE_GEN_R = 0x0C62, + GL_TEXTURE_GEN_Q = 0x0C63, + GL_PIXEL_MAP_I_TO_I = 0x0C70, + GL_PIXEL_MAP_S_TO_S = 0x0C71, + GL_PIXEL_MAP_I_TO_R = 0x0C72, + GL_PIXEL_MAP_I_TO_G = 0x0C73, + GL_PIXEL_MAP_I_TO_B = 0x0C74, + GL_PIXEL_MAP_I_TO_A = 0x0C75, + GL_PIXEL_MAP_R_TO_R = 0x0C76, + GL_PIXEL_MAP_G_TO_G = 0x0C77, + GL_PIXEL_MAP_B_TO_B = 0x0C78, + GL_PIXEL_MAP_A_TO_A = 0x0C79, + GL_PIXEL_MAP_I_TO_I_SIZE = 0x0CB0, + GL_PIXEL_MAP_S_TO_S_SIZE = 0x0CB1, + GL_PIXEL_MAP_I_TO_R_SIZE = 0x0CB2, + GL_PIXEL_MAP_I_TO_G_SIZE = 0x0CB3, + GL_PIXEL_MAP_I_TO_B_SIZE = 0x0CB4, + GL_PIXEL_MAP_I_TO_A_SIZE = 0x0CB5, + GL_PIXEL_MAP_R_TO_R_SIZE = 0x0CB6, + GL_PIXEL_MAP_G_TO_G_SIZE = 0x0CB7, + GL_PIXEL_MAP_B_TO_B_SIZE = 0x0CB8, + GL_PIXEL_MAP_A_TO_A_SIZE = 0x0CB9, + GL_UNPACK_SWAP_BYTES = 0x0CF0, + GL_UNPACK_LSB_FIRST = 0x0CF1, + GL_UNPACK_ROW_LENGTH = 0x0CF2, + GL_UNPACK_ROW_LENGTH_EXT = 0x0CF2, + GL_UNPACK_SKIP_ROWS = 0x0CF3, + GL_UNPACK_SKIP_ROWS_EXT = 0x0CF3, + GL_UNPACK_SKIP_PIXELS = 0x0CF4, + GL_UNPACK_SKIP_PIXELS_EXT = 0x0CF4, + GL_UNPACK_ALIGNMENT = 0x0CF5, + GL_PACK_SWAP_BYTES = 0x0D00, + GL_PACK_LSB_FIRST = 0x0D01, + GL_PACK_ROW_LENGTH = 0x0D02, + GL_PACK_SKIP_ROWS = 0x0D03, + GL_PACK_SKIP_PIXELS = 0x0D04, + GL_PACK_ALIGNMENT = 0x0D05, + GL_MAP_COLOR = 0x0D10, + GL_MAP_STENCIL = 0x0D11, + GL_INDEX_SHIFT = 0x0D12, + GL_INDEX_OFFSET = 0x0D13, + GL_RED_SCALE = 0x0D14, + GL_RED_BIAS = 0x0D15, + GL_ZOOM_X = 0x0D16, + GL_ZOOM_Y = 0x0D17, + GL_GREEN_SCALE = 0x0D18, + GL_GREEN_BIAS = 0x0D19, + GL_BLUE_SCALE = 0x0D1A, + GL_BLUE_BIAS = 0x0D1B, + GL_ALPHA_SCALE = 0x0D1C, + GL_ALPHA_BIAS = 0x0D1D, + GL_DEPTH_SCALE = 0x0D1E, + GL_DEPTH_BIAS = 0x0D1F, + GL_MAX_EVAL_ORDER = 0x0D30, + GL_MAX_LIGHTS = 0x0D31, + GL_MAX_CLIP_PLANES = 0x0D32, + GL_MAX_CLIP_PLANES_IMG = 0x0D32, + GL_MAX_CLIP_DISTANCES = 0x0D32, + GL_MAX_CLIP_DISTANCES_EXT = 0x0D32, + GL_MAX_CLIP_DISTANCES_APPLE = 0x0D32, + GL_MAX_TEXTURE_SIZE = 0x0D33, + GL_MAX_PIXEL_MAP_TABLE = 0x0D34, + GL_MAX_ATTRIB_STACK_DEPTH = 0x0D35, + GL_MAX_MODELVIEW_STACK_DEPTH = 0x0D36, + GL_PATH_MAX_MODELVIEW_STACK_DEPTH_NV = 0x0D36, + GL_MAX_NAME_STACK_DEPTH = 0x0D37, + GL_MAX_PROJECTION_STACK_DEPTH = 0x0D38, + GL_PATH_MAX_PROJECTION_STACK_DEPTH_NV = 0x0D38, + GL_MAX_TEXTURE_STACK_DEPTH = 0x0D39, + GL_MAX_VIEWPORT_DIMS = 0x0D3A, + GL_MAX_CLIENT_ATTRIB_STACK_DEPTH = 0x0D3B, + GL_SUBPIXEL_BITS = 0x0D50, + GL_INDEX_BITS = 0x0D51, + GL_RED_BITS = 0x0D52, + GL_GREEN_BITS = 0x0D53, + GL_BLUE_BITS = 0x0D54, + GL_ALPHA_BITS = 0x0D55, + GL_DEPTH_BITS = 0x0D56, + GL_STENCIL_BITS = 0x0D57, + GL_ACCUM_RED_BITS = 0x0D58, + GL_ACCUM_GREEN_BITS = 0x0D59, + GL_ACCUM_BLUE_BITS = 0x0D5A, + GL_ACCUM_ALPHA_BITS = 0x0D5B, + GL_NAME_STACK_DEPTH = 0x0D70, + GL_AUTO_NORMAL = 0x0D80, + GL_MAP1_COLOR_4 = 0x0D90, + GL_MAP1_INDEX = 0x0D91, + GL_MAP1_NORMAL = 0x0D92, + GL_MAP1_TEXTURE_COORD_1 = 0x0D93, + GL_MAP1_TEXTURE_COORD_2 = 0x0D94, + GL_MAP1_TEXTURE_COORD_3 = 0x0D95, + GL_MAP1_TEXTURE_COORD_4 = 0x0D96, + GL_MAP1_VERTEX_3 = 0x0D97, + GL_MAP1_VERTEX_4 = 0x0D98, + GL_MAP2_COLOR_4 = 0x0DB0, + GL_MAP2_INDEX = 0x0DB1, + GL_MAP2_NORMAL = 0x0DB2, + GL_MAP2_TEXTURE_COORD_1 = 0x0DB3, + GL_MAP2_TEXTURE_COORD_2 = 0x0DB4, + GL_MAP2_TEXTURE_COORD_3 = 0x0DB5, + GL_MAP2_TEXTURE_COORD_4 = 0x0DB6, + GL_MAP2_VERTEX_3 = 0x0DB7, + GL_MAP2_VERTEX_4 = 0x0DB8, + GL_MAP1_GRID_DOMAIN = 0x0DD0, + GL_MAP1_GRID_SEGMENTS = 0x0DD1, + GL_MAP2_GRID_DOMAIN = 0x0DD2, + GL_MAP2_GRID_SEGMENTS = 0x0DD3, + GL_TEXTURE_1D = 0x0DE0, + GL_TEXTURE_2D = 0x0DE1, + GL_FEEDBACK_BUFFER_POINTER = 0x0DF0, + GL_FEEDBACK_BUFFER_SIZE = 0x0DF1, + GL_FEEDBACK_BUFFER_TYPE = 0x0DF2, + GL_SELECTION_BUFFER_POINTER = 0x0DF3, + GL_SELECTION_BUFFER_SIZE = 0x0DF4, + GL_TEXTURE_WIDTH = 0x1000, + GL_TEXTURE_HEIGHT = 0x1001, + GL_TEXTURE_INTERNAL_FORMAT = 0x1003, + GL_TEXTURE_COMPONENTS = 0x1003, + GL_TEXTURE_BORDER_COLOR = 0x1004, + GL_TEXTURE_BORDER_COLOR_EXT = 0x1004, + GL_TEXTURE_BORDER_COLOR_NV = 0x1004, + GL_TEXTURE_BORDER_COLOR_OES = 0x1004, + GL_TEXTURE_BORDER = 0x1005, + GL_TEXTURE_TARGET = 0x1006, + GL_DONT_CARE = 0x1100, + GL_FASTEST = 0x1101, + GL_NICEST = 0x1102, + GL_AMBIENT = 0x1200, + GL_DIFFUSE = 0x1201, + GL_SPECULAR = 0x1202, + GL_POSITION = 0x1203, + GL_SPOT_DIRECTION = 0x1204, + GL_SPOT_EXPONENT = 0x1205, + GL_SPOT_CUTOFF = 0x1206, + GL_CONSTANT_ATTENUATION = 0x1207, + GL_LINEAR_ATTENUATION = 0x1208, + GL_QUADRATIC_ATTENUATION = 0x1209, + GL_COMPILE = 0x1300, + GL_COMPILE_AND_EXECUTE = 0x1301, + GL_BYTE = 0x1400, + GL_UNSIGNED_BYTE = 0x1401, + GL_SHORT = 0x1402, + GL_UNSIGNED_SHORT = 0x1403, + GL_INT = 0x1404, + GL_UNSIGNED_INT = 0x1405, + GL_FLOAT = 0x1406, + GL_2_BYTES = 0x1407, + GL_2_BYTES_NV = 0x1407, + GL_3_BYTES = 0x1408, + GL_3_BYTES_NV = 0x1408, + GL_4_BYTES = 0x1409, + GL_4_BYTES_NV = 0x1409, + GL_DOUBLE = 0x140A, + GL_DOUBLE_EXT = 0x140A, + GL_HALF_FLOAT = 0x140B, + GL_HALF_FLOAT_ARB = 0x140B, + GL_HALF_FLOAT_NV = 0x140B, + GL_HALF_APPLE = 0x140B, + GL_FIXED = 0x140C, + GL_FIXED_OES = 0x140C, + GL_INT64_ARB = 0x140E, + GL_INT64_NV = 0x140E, + GL_UNSIGNED_INT64_ARB = 0x140F, + GL_UNSIGNED_INT64_NV = 0x140F, + GL_CLEAR = 0x1500, + GL_AND = 0x1501, + GL_AND_REVERSE = 0x1502, + GL_COPY = 0x1503, + GL_AND_INVERTED = 0x1504, + GL_NOOP = 0x1505, + GL_XOR = 0x1506, + GL_XOR_NV = 0x1506, + GL_OR = 0x1507, + GL_NOR = 0x1508, + GL_EQUIV = 0x1509, + GL_INVERT = 0x150A, + GL_OR_REVERSE = 0x150B, + GL_COPY_INVERTED = 0x150C, + GL_OR_INVERTED = 0x150D, + GL_NAND = 0x150E, + GL_SET = 0x150F, + GL_EMISSION = 0x1600, + GL_SHININESS = 0x1601, + GL_AMBIENT_AND_DIFFUSE = 0x1602, + GL_COLOR_INDEXES = 0x1603, + GL_MODELVIEW = 0x1700, + GL_MODELVIEW0_ARB = 0x1700, + GL_MODELVIEW0_EXT = 0x1700, + GL_PATH_MODELVIEW_NV = 0x1700, + GL_PROJECTION = 0x1701, + GL_PATH_PROJECTION_NV = 0x1701, + GL_TEXTURE = 0x1702, + GL_COLOR = 0x1800, + GL_COLOR_EXT = 0x1800, + GL_DEPTH = 0x1801, + GL_DEPTH_EXT = 0x1801, + GL_STENCIL = 0x1802, + GL_STENCIL_EXT = 0x1802, + GL_COLOR_INDEX = 0x1900, + GL_STENCIL_INDEX = 0x1901, + GL_STENCIL_INDEX_OES = 0x1901, + GL_DEPTH_COMPONENT = 0x1902, + GL_RED = 0x1903, + GL_RED_EXT = 0x1903, + GL_RED_NV = 0x1903, + GL_GREEN = 0x1904, + GL_GREEN_NV = 0x1904, + GL_BLUE = 0x1905, + GL_BLUE_NV = 0x1905, + GL_ALPHA = 0x1906, + GL_RGB = 0x1907, + GL_RGBA = 0x1908, + GL_LUMINANCE = 0x1909, + GL_LUMINANCE_ALPHA = 0x190A, + GL_BITMAP = 0x1A00, + GL_POINT = 0x1B00, + GL_POINT_NV = 0x1B00, + GL_LINE = 0x1B01, + GL_LINE_NV = 0x1B01, + GL_FILL = 0x1B02, + GL_FILL_NV = 0x1B02, + GL_RENDER = 0x1C00, + GL_FEEDBACK = 0x1C01, + GL_SELECT = 0x1C02, + GL_FLAT = 0x1D00, + GL_SMOOTH = 0x1D01, + GL_KEEP = 0x1E00, + GL_REPLACE = 0x1E01, + GL_INCR = 0x1E02, + GL_DECR = 0x1E03, + GL_VENDOR = 0x1F00, + GL_RENDERER = 0x1F01, + GL_VERSION = 0x1F02, + GL_EXTENSIONS = 0x1F03, + GL_S = 0x2000, + GL_T = 0x2001, + GL_R = 0x2002, + GL_Q = 0x2003, + GL_MODULATE = 0x2100, + GL_DECAL = 0x2101, + GL_TEXTURE_ENV_MODE = 0x2200, + GL_TEXTURE_ENV_COLOR = 0x2201, + GL_TEXTURE_ENV = 0x2300, + GL_EYE_LINEAR = 0x2400, + GL_EYE_LINEAR_NV = 0x2400, + GL_OBJECT_LINEAR = 0x2401, + GL_OBJECT_LINEAR_NV = 0x2401, + GL_SPHERE_MAP = 0x2402, + GL_TEXTURE_GEN_MODE = 0x2500, + GL_TEXTURE_GEN_MODE_OES = 0x2500, + GL_OBJECT_PLANE = 0x2501, + GL_EYE_PLANE = 0x2502, + GL_NEAREST = 0x2600, + GL_LINEAR = 0x2601, + GL_NEAREST_MIPMAP_NEAREST = 0x2700, + GL_LINEAR_MIPMAP_NEAREST = 0x2701, + GL_NEAREST_MIPMAP_LINEAR = 0x2702, + GL_LINEAR_MIPMAP_LINEAR = 0x2703, + GL_TEXTURE_MAG_FILTER = 0x2800, + GL_TEXTURE_MIN_FILTER = 0x2801, + GL_TEXTURE_WRAP_S = 0x2802, + GL_TEXTURE_WRAP_T = 0x2803, + GL_CLAMP = 0x2900, + GL_REPEAT = 0x2901, + GL_POLYGON_OFFSET_UNITS = 0x2A00, + GL_POLYGON_OFFSET_POINT = 0x2A01, + GL_POLYGON_OFFSET_POINT_NV = 0x2A01, + GL_POLYGON_OFFSET_LINE = 0x2A02, + GL_POLYGON_OFFSET_LINE_NV = 0x2A02, + GL_R3_G3_B2 = 0x2A10, + GL_V2F = 0x2A20, + GL_V3F = 0x2A21, + GL_C4UB_V2F = 0x2A22, + GL_C4UB_V3F = 0x2A23, + GL_C3F_V3F = 0x2A24, + GL_N3F_V3F = 0x2A25, + GL_C4F_N3F_V3F = 0x2A26, + GL_T2F_V3F = 0x2A27, + GL_T4F_V4F = 0x2A28, + GL_T2F_C4UB_V3F = 0x2A29, + GL_T2F_C3F_V3F = 0x2A2A, + GL_T2F_N3F_V3F = 0x2A2B, + GL_T2F_C4F_N3F_V3F = 0x2A2C, + GL_T4F_C4F_N3F_V4F = 0x2A2D, + GL_CLIP_PLANE0 = 0x3000, + GL_CLIP_PLANE0_IMG = 0x3000, + GL_CLIP_DISTANCE0 = 0x3000, + GL_CLIP_DISTANCE0_EXT = 0x3000, + GL_CLIP_DISTANCE0_APPLE = 0x3000, + GL_CLIP_PLANE1 = 0x3001, + GL_CLIP_PLANE1_IMG = 0x3001, + GL_CLIP_DISTANCE1 = 0x3001, + GL_CLIP_DISTANCE1_EXT = 0x3001, + GL_CLIP_DISTANCE1_APPLE = 0x3001, + GL_CLIP_PLANE2 = 0x3002, + GL_CLIP_PLANE2_IMG = 0x3002, + GL_CLIP_DISTANCE2 = 0x3002, + GL_CLIP_DISTANCE2_EXT = 0x3002, + GL_CLIP_DISTANCE2_APPLE = 0x3002, + GL_CLIP_PLANE3 = 0x3003, + GL_CLIP_PLANE3_IMG = 0x3003, + GL_CLIP_DISTANCE3 = 0x3003, + GL_CLIP_DISTANCE3_EXT = 0x3003, + GL_CLIP_DISTANCE3_APPLE = 0x3003, + GL_CLIP_PLANE4 = 0x3004, + GL_CLIP_PLANE4_IMG = 0x3004, + GL_CLIP_DISTANCE4 = 0x3004, + GL_CLIP_DISTANCE4_EXT = 0x3004, + GL_CLIP_DISTANCE4_APPLE = 0x3004, + GL_CLIP_PLANE5 = 0x3005, + GL_CLIP_PLANE5_IMG = 0x3005, + GL_CLIP_DISTANCE5 = 0x3005, + GL_CLIP_DISTANCE5_EXT = 0x3005, + GL_CLIP_DISTANCE5_APPLE = 0x3005, + GL_CLIP_DISTANCE6 = 0x3006, + GL_CLIP_DISTANCE6_EXT = 0x3006, + GL_CLIP_DISTANCE6_APPLE = 0x3006, + GL_CLIP_DISTANCE7 = 0x3007, + GL_CLIP_DISTANCE7_EXT = 0x3007, + GL_CLIP_DISTANCE7_APPLE = 0x3007, + GL_LIGHT0 = 0x4000, + GL_LIGHT1 = 0x4001, + GL_LIGHT2 = 0x4002, + GL_LIGHT3 = 0x4003, + GL_LIGHT4 = 0x4004, + GL_LIGHT5 = 0x4005, + GL_LIGHT6 = 0x4006, + GL_LIGHT7 = 0x4007, + GL_ABGR_EXT = 0x8000, + GL_CONSTANT_COLOR = 0x8001, + GL_CONSTANT_COLOR_EXT = 0x8001, + GL_ONE_MINUS_CONSTANT_COLOR = 0x8002, + GL_ONE_MINUS_CONSTANT_COLOR_EXT = 0x8002, + GL_CONSTANT_ALPHA = 0x8003, + GL_CONSTANT_ALPHA_EXT = 0x8003, + GL_ONE_MINUS_CONSTANT_ALPHA = 0x8004, + GL_ONE_MINUS_CONSTANT_ALPHA_EXT = 0x8004, + GL_BLEND_COLOR = 0x8005, + GL_BLEND_COLOR_EXT = 0x8005, + GL_FUNC_ADD = 0x8006, + GL_FUNC_ADD_EXT = 0x8006, + GL_FUNC_ADD_OES = 0x8006, + GL_MIN = 0x8007, + GL_MIN_EXT = 0x8007, + GL_MAX = 0x8008, + GL_MAX_EXT = 0x8008, + GL_BLEND_EQUATION = 0x8009, + GL_BLEND_EQUATION_EXT = 0x8009, + GL_BLEND_EQUATION_OES = 0x8009, + GL_BLEND_EQUATION_RGB = 0x8009, + GL_BLEND_EQUATION_RGB_EXT = 0x8009, + GL_BLEND_EQUATION_RGB_OES = 0x8009, + GL_FUNC_SUBTRACT = 0x800A, + GL_FUNC_SUBTRACT_EXT = 0x800A, + GL_FUNC_SUBTRACT_OES = 0x800A, + GL_FUNC_REVERSE_SUBTRACT = 0x800B, + GL_FUNC_REVERSE_SUBTRACT_EXT = 0x800B, + GL_FUNC_REVERSE_SUBTRACT_OES = 0x800B, + GL_CMYK_EXT = 0x800C, + GL_CMYKA_EXT = 0x800D, + GL_PACK_CMYK_HINT_EXT = 0x800E, + GL_UNPACK_CMYK_HINT_EXT = 0x800F, + GL_CONVOLUTION_1D = 0x8010, + GL_CONVOLUTION_1D_EXT = 0x8010, + GL_CONVOLUTION_2D = 0x8011, + GL_CONVOLUTION_2D_EXT = 0x8011, + GL_SEPARABLE_2D = 0x8012, + GL_SEPARABLE_2D_EXT = 0x8012, + GL_CONVOLUTION_BORDER_MODE = 0x8013, + GL_CONVOLUTION_BORDER_MODE_EXT = 0x8013, + GL_CONVOLUTION_FILTER_SCALE = 0x8014, + GL_CONVOLUTION_FILTER_SCALE_EXT = 0x8014, + GL_CONVOLUTION_FILTER_BIAS = 0x8015, + GL_CONVOLUTION_FILTER_BIAS_EXT = 0x8015, + GL_REDUCE = 0x8016, + GL_REDUCE_EXT = 0x8016, + GL_CONVOLUTION_FORMAT = 0x8017, + GL_CONVOLUTION_FORMAT_EXT = 0x8017, + GL_CONVOLUTION_WIDTH = 0x8018, + GL_CONVOLUTION_WIDTH_EXT = 0x8018, + GL_CONVOLUTION_HEIGHT = 0x8019, + GL_CONVOLUTION_HEIGHT_EXT = 0x8019, + GL_MAX_CONVOLUTION_WIDTH = 0x801A, + GL_MAX_CONVOLUTION_WIDTH_EXT = 0x801A, + GL_MAX_CONVOLUTION_HEIGHT = 0x801B, + GL_MAX_CONVOLUTION_HEIGHT_EXT = 0x801B, + GL_POST_CONVOLUTION_RED_SCALE = 0x801C, + GL_POST_CONVOLUTION_RED_SCALE_EXT = 0x801C, + GL_POST_CONVOLUTION_GREEN_SCALE = 0x801D, + GL_POST_CONVOLUTION_GREEN_SCALE_EXT = 0x801D, + GL_POST_CONVOLUTION_BLUE_SCALE = 0x801E, + GL_POST_CONVOLUTION_BLUE_SCALE_EXT = 0x801E, + GL_POST_CONVOLUTION_ALPHA_SCALE = 0x801F, + GL_POST_CONVOLUTION_ALPHA_SCALE_EXT = 0x801F, + GL_POST_CONVOLUTION_RED_BIAS = 0x8020, + GL_POST_CONVOLUTION_RED_BIAS_EXT = 0x8020, + GL_POST_CONVOLUTION_GREEN_BIAS = 0x8021, + GL_POST_CONVOLUTION_GREEN_BIAS_EXT = 0x8021, + GL_POST_CONVOLUTION_BLUE_BIAS = 0x8022, + GL_POST_CONVOLUTION_BLUE_BIAS_EXT = 0x8022, + GL_POST_CONVOLUTION_ALPHA_BIAS = 0x8023, + GL_POST_CONVOLUTION_ALPHA_BIAS_EXT = 0x8023, + GL_HISTOGRAM = 0x8024, + GL_HISTOGRAM_EXT = 0x8024, + GL_PROXY_HISTOGRAM = 0x8025, + GL_PROXY_HISTOGRAM_EXT = 0x8025, + GL_HISTOGRAM_WIDTH = 0x8026, + GL_HISTOGRAM_WIDTH_EXT = 0x8026, + GL_HISTOGRAM_FORMAT = 0x8027, + GL_HISTOGRAM_FORMAT_EXT = 0x8027, + GL_HISTOGRAM_RED_SIZE = 0x8028, + GL_HISTOGRAM_RED_SIZE_EXT = 0x8028, + GL_HISTOGRAM_GREEN_SIZE = 0x8029, + GL_HISTOGRAM_GREEN_SIZE_EXT = 0x8029, + GL_HISTOGRAM_BLUE_SIZE = 0x802A, + GL_HISTOGRAM_BLUE_SIZE_EXT = 0x802A, + GL_HISTOGRAM_ALPHA_SIZE = 0x802B, + GL_HISTOGRAM_ALPHA_SIZE_EXT = 0x802B, + GL_HISTOGRAM_LUMINANCE_SIZE = 0x802C, + GL_HISTOGRAM_LUMINANCE_SIZE_EXT = 0x802C, + GL_HISTOGRAM_SINK = 0x802D, + GL_HISTOGRAM_SINK_EXT = 0x802D, + GL_MINMAX = 0x802E, + GL_MINMAX_EXT = 0x802E, + GL_MINMAX_FORMAT = 0x802F, + GL_MINMAX_FORMAT_EXT = 0x802F, + GL_MINMAX_SINK = 0x8030, + GL_MINMAX_SINK_EXT = 0x8030, + GL_TABLE_TOO_LARGE_EXT = 0x8031, + GL_TABLE_TOO_LARGE = 0x8031, + GL_UNSIGNED_BYTE_3_3_2 = 0x8032, + GL_UNSIGNED_BYTE_3_3_2_EXT = 0x8032, + GL_UNSIGNED_SHORT_4_4_4_4 = 0x8033, + GL_UNSIGNED_SHORT_4_4_4_4_EXT = 0x8033, + GL_UNSIGNED_SHORT_5_5_5_1 = 0x8034, + GL_UNSIGNED_SHORT_5_5_5_1_EXT = 0x8034, + GL_UNSIGNED_INT_8_8_8_8 = 0x8035, + GL_UNSIGNED_INT_8_8_8_8_EXT = 0x8035, + GL_UNSIGNED_INT_10_10_10_2 = 0x8036, + GL_UNSIGNED_INT_10_10_10_2_EXT = 0x8036, + GL_POLYGON_OFFSET_EXT = 0x8037, + GL_POLYGON_OFFSET_FILL = 0x8037, + GL_POLYGON_OFFSET_FACTOR = 0x8038, + GL_POLYGON_OFFSET_FACTOR_EXT = 0x8038, + GL_POLYGON_OFFSET_BIAS_EXT = 0x8039, + GL_RESCALE_NORMAL = 0x803A, + GL_RESCALE_NORMAL_EXT = 0x803A, + GL_ALPHA4 = 0x803B, + GL_ALPHA4_EXT = 0x803B, + GL_ALPHA8 = 0x803C, + GL_ALPHA8_EXT = 0x803C, + GL_ALPHA8_OES = 0x803C, + GL_ALPHA12 = 0x803D, + GL_ALPHA12_EXT = 0x803D, + GL_ALPHA16 = 0x803E, + GL_ALPHA16_EXT = 0x803E, + GL_LUMINANCE4 = 0x803F, + GL_LUMINANCE4_EXT = 0x803F, + GL_LUMINANCE8 = 0x8040, + GL_LUMINANCE8_EXT = 0x8040, + GL_LUMINANCE8_OES = 0x8040, + GL_LUMINANCE12 = 0x8041, + GL_LUMINANCE12_EXT = 0x8041, + GL_LUMINANCE16 = 0x8042, + GL_LUMINANCE16_EXT = 0x8042, + GL_LUMINANCE4_ALPHA4 = 0x8043, + GL_LUMINANCE4_ALPHA4_EXT = 0x8043, + GL_LUMINANCE4_ALPHA4_OES = 0x8043, + GL_LUMINANCE6_ALPHA2 = 0x8044, + GL_LUMINANCE6_ALPHA2_EXT = 0x8044, + GL_LUMINANCE8_ALPHA8 = 0x8045, + GL_LUMINANCE8_ALPHA8_EXT = 0x8045, + GL_LUMINANCE8_ALPHA8_OES = 0x8045, + GL_LUMINANCE12_ALPHA4 = 0x8046, + GL_LUMINANCE12_ALPHA4_EXT = 0x8046, + GL_LUMINANCE12_ALPHA12 = 0x8047, + GL_LUMINANCE12_ALPHA12_EXT = 0x8047, + GL_LUMINANCE16_ALPHA16 = 0x8048, + GL_LUMINANCE16_ALPHA16_EXT = 0x8048, + GL_INTENSITY = 0x8049, + GL_INTENSITY_EXT = 0x8049, + GL_INTENSITY4 = 0x804A, + GL_INTENSITY4_EXT = 0x804A, + GL_INTENSITY8 = 0x804B, + GL_INTENSITY8_EXT = 0x804B, + GL_INTENSITY12 = 0x804C, + GL_INTENSITY12_EXT = 0x804C, + GL_INTENSITY16 = 0x804D, + GL_INTENSITY16_EXT = 0x804D, + GL_RGB2_EXT = 0x804E, + GL_RGB4 = 0x804F, + GL_RGB4_EXT = 0x804F, + GL_RGB5 = 0x8050, + GL_RGB5_EXT = 0x8050, + GL_RGB8 = 0x8051, + GL_RGB8_EXT = 0x8051, + GL_RGB8_OES = 0x8051, + GL_RGB10 = 0x8052, + GL_RGB10_EXT = 0x8052, + GL_RGB12 = 0x8053, + GL_RGB12_EXT = 0x8053, + GL_RGB16 = 0x8054, + GL_RGB16_EXT = 0x8054, + GL_RGBA2 = 0x8055, + GL_RGBA2_EXT = 0x8055, + GL_RGBA4 = 0x8056, + GL_RGBA4_EXT = 0x8056, + GL_RGBA4_OES = 0x8056, + GL_RGB5_A1 = 0x8057, + GL_RGB5_A1_EXT = 0x8057, + GL_RGB5_A1_OES = 0x8057, + GL_RGBA8 = 0x8058, + GL_RGBA8_EXT = 0x8058, + GL_RGBA8_OES = 0x8058, + GL_RGB10_A2 = 0x8059, + GL_RGB10_A2_EXT = 0x8059, + GL_RGBA12 = 0x805A, + GL_RGBA12_EXT = 0x805A, + GL_RGBA16 = 0x805B, + GL_RGBA16_EXT = 0x805B, + GL_TEXTURE_RED_SIZE = 0x805C, + GL_TEXTURE_RED_SIZE_EXT = 0x805C, + GL_TEXTURE_GREEN_SIZE = 0x805D, + GL_TEXTURE_GREEN_SIZE_EXT = 0x805D, + GL_TEXTURE_BLUE_SIZE = 0x805E, + GL_TEXTURE_BLUE_SIZE_EXT = 0x805E, + GL_TEXTURE_ALPHA_SIZE = 0x805F, + GL_TEXTURE_ALPHA_SIZE_EXT = 0x805F, + GL_TEXTURE_LUMINANCE_SIZE = 0x8060, + GL_TEXTURE_LUMINANCE_SIZE_EXT = 0x8060, + GL_TEXTURE_INTENSITY_SIZE = 0x8061, + GL_TEXTURE_INTENSITY_SIZE_EXT = 0x8061, + GL_REPLACE_EXT = 0x8062, + GL_PROXY_TEXTURE_1D = 0x8063, + GL_PROXY_TEXTURE_1D_EXT = 0x8063, + GL_PROXY_TEXTURE_2D = 0x8064, + GL_PROXY_TEXTURE_2D_EXT = 0x8064, + GL_TEXTURE_TOO_LARGE_EXT = 0x8065, + GL_TEXTURE_PRIORITY = 0x8066, + GL_TEXTURE_PRIORITY_EXT = 0x8066, + GL_TEXTURE_RESIDENT = 0x8067, + GL_TEXTURE_RESIDENT_EXT = 0x8067, + GL_TEXTURE_1D_BINDING_EXT = 0x8068, + GL_TEXTURE_BINDING_1D = 0x8068, + GL_TEXTURE_2D_BINDING_EXT = 0x8069, + GL_TEXTURE_BINDING_2D = 0x8069, + GL_TEXTURE_3D_BINDING_EXT = 0x806A, + GL_TEXTURE_3D_BINDING_OES = 0x806A, + GL_TEXTURE_BINDING_3D = 0x806A, + GL_TEXTURE_BINDING_3D_OES = 0x806A, + GL_PACK_SKIP_IMAGES = 0x806B, + GL_PACK_SKIP_IMAGES_EXT = 0x806B, + GL_PACK_IMAGE_HEIGHT = 0x806C, + GL_PACK_IMAGE_HEIGHT_EXT = 0x806C, + GL_UNPACK_SKIP_IMAGES = 0x806D, + GL_UNPACK_SKIP_IMAGES_EXT = 0x806D, + GL_UNPACK_IMAGE_HEIGHT = 0x806E, + GL_UNPACK_IMAGE_HEIGHT_EXT = 0x806E, + GL_TEXTURE_3D = 0x806F, + GL_TEXTURE_3D_EXT = 0x806F, + GL_TEXTURE_3D_OES = 0x806F, + GL_PROXY_TEXTURE_3D = 0x8070, + GL_PROXY_TEXTURE_3D_EXT = 0x8070, + GL_TEXTURE_DEPTH = 0x8071, + GL_TEXTURE_DEPTH_EXT = 0x8071, + GL_TEXTURE_WRAP_R = 0x8072, + GL_TEXTURE_WRAP_R_EXT = 0x8072, + GL_TEXTURE_WRAP_R_OES = 0x8072, + GL_MAX_3D_TEXTURE_SIZE = 0x8073, + GL_MAX_3D_TEXTURE_SIZE_EXT = 0x8073, + GL_MAX_3D_TEXTURE_SIZE_OES = 0x8073, + GL_VERTEX_ARRAY = 0x8074, + GL_VERTEX_ARRAY_EXT = 0x8074, + GL_VERTEX_ARRAY_KHR = 0x8074, + GL_NORMAL_ARRAY = 0x8075, + GL_NORMAL_ARRAY_EXT = 0x8075, + GL_COLOR_ARRAY = 0x8076, + GL_COLOR_ARRAY_EXT = 0x8076, + GL_INDEX_ARRAY = 0x8077, + GL_INDEX_ARRAY_EXT = 0x8077, + GL_TEXTURE_COORD_ARRAY = 0x8078, + GL_TEXTURE_COORD_ARRAY_EXT = 0x8078, + GL_EDGE_FLAG_ARRAY = 0x8079, + GL_EDGE_FLAG_ARRAY_EXT = 0x8079, + GL_VERTEX_ARRAY_SIZE = 0x807A, + GL_VERTEX_ARRAY_SIZE_EXT = 0x807A, + GL_VERTEX_ARRAY_TYPE = 0x807B, + GL_VERTEX_ARRAY_TYPE_EXT = 0x807B, + GL_VERTEX_ARRAY_STRIDE = 0x807C, + GL_VERTEX_ARRAY_STRIDE_EXT = 0x807C, + GL_VERTEX_ARRAY_COUNT_EXT = 0x807D, + GL_NORMAL_ARRAY_TYPE = 0x807E, + GL_NORMAL_ARRAY_TYPE_EXT = 0x807E, + GL_NORMAL_ARRAY_STRIDE = 0x807F, + GL_NORMAL_ARRAY_STRIDE_EXT = 0x807F, + GL_NORMAL_ARRAY_COUNT_EXT = 0x8080, + GL_COLOR_ARRAY_SIZE = 0x8081, + GL_COLOR_ARRAY_SIZE_EXT = 0x8081, + GL_COLOR_ARRAY_TYPE = 0x8082, + GL_COLOR_ARRAY_TYPE_EXT = 0x8082, + GL_COLOR_ARRAY_STRIDE = 0x8083, + GL_COLOR_ARRAY_STRIDE_EXT = 0x8083, + GL_COLOR_ARRAY_COUNT_EXT = 0x8084, + GL_INDEX_ARRAY_TYPE = 0x8085, + GL_INDEX_ARRAY_TYPE_EXT = 0x8085, + GL_INDEX_ARRAY_STRIDE = 0x8086, + GL_INDEX_ARRAY_STRIDE_EXT = 0x8086, + GL_INDEX_ARRAY_COUNT_EXT = 0x8087, + GL_TEXTURE_COORD_ARRAY_SIZE = 0x8088, + GL_TEXTURE_COORD_ARRAY_SIZE_EXT = 0x8088, + GL_TEXTURE_COORD_ARRAY_TYPE = 0x8089, + GL_TEXTURE_COORD_ARRAY_TYPE_EXT = 0x8089, + GL_TEXTURE_COORD_ARRAY_STRIDE = 0x808A, + GL_TEXTURE_COORD_ARRAY_STRIDE_EXT = 0x808A, + GL_TEXTURE_COORD_ARRAY_COUNT_EXT = 0x808B, + GL_EDGE_FLAG_ARRAY_STRIDE = 0x808C, + GL_EDGE_FLAG_ARRAY_STRIDE_EXT = 0x808C, + GL_EDGE_FLAG_ARRAY_COUNT_EXT = 0x808D, + GL_VERTEX_ARRAY_POINTER = 0x808E, + GL_VERTEX_ARRAY_POINTER_EXT = 0x808E, + GL_NORMAL_ARRAY_POINTER = 0x808F, + GL_NORMAL_ARRAY_POINTER_EXT = 0x808F, + GL_COLOR_ARRAY_POINTER = 0x8090, + GL_COLOR_ARRAY_POINTER_EXT = 0x8090, + GL_INDEX_ARRAY_POINTER = 0x8091, + GL_INDEX_ARRAY_POINTER_EXT = 0x8091, + GL_TEXTURE_COORD_ARRAY_POINTER = 0x8092, + GL_TEXTURE_COORD_ARRAY_POINTER_EXT = 0x8092, + GL_EDGE_FLAG_ARRAY_POINTER = 0x8093, + GL_EDGE_FLAG_ARRAY_POINTER_EXT = 0x8093, + GL_INTERLACE_SGIX = 0x8094, + GL_DETAIL_TEXTURE_2D_SGIS = 0x8095, + GL_DETAIL_TEXTURE_2D_BINDING_SGIS = 0x8096, + GL_LINEAR_DETAIL_SGIS = 0x8097, + GL_LINEAR_DETAIL_ALPHA_SGIS = 0x8098, + GL_LINEAR_DETAIL_COLOR_SGIS = 0x8099, + GL_DETAIL_TEXTURE_LEVEL_SGIS = 0x809A, + GL_DETAIL_TEXTURE_MODE_SGIS = 0x809B, + GL_DETAIL_TEXTURE_FUNC_POINTS_SGIS = 0x809C, + GL_MULTISAMPLE = 0x809D, + GL_MULTISAMPLE_ARB = 0x809D, + GL_MULTISAMPLE_EXT = 0x809D, + GL_MULTISAMPLE_SGIS = 0x809D, + GL_SAMPLE_ALPHA_TO_COVERAGE = 0x809E, + GL_SAMPLE_ALPHA_TO_COVERAGE_ARB = 0x809E, + GL_SAMPLE_ALPHA_TO_MASK_EXT = 0x809E, + GL_SAMPLE_ALPHA_TO_MASK_SGIS = 0x809E, + GL_SAMPLE_ALPHA_TO_ONE = 0x809F, + GL_SAMPLE_ALPHA_TO_ONE_ARB = 0x809F, + GL_SAMPLE_ALPHA_TO_ONE_EXT = 0x809F, + GL_SAMPLE_ALPHA_TO_ONE_SGIS = 0x809F, + GL_SAMPLE_COVERAGE = 0x80A0, + GL_SAMPLE_COVERAGE_ARB = 0x80A0, + GL_SAMPLE_MASK_EXT = 0x80A0, + GL_SAMPLE_MASK_SGIS = 0x80A0, + GL_1PASS_EXT = 0x80A1, + GL_1PASS_SGIS = 0x80A1, + GL_2PASS_0_EXT = 0x80A2, + GL_2PASS_0_SGIS = 0x80A2, + GL_2PASS_1_EXT = 0x80A3, + GL_2PASS_1_SGIS = 0x80A3, + GL_4PASS_0_EXT = 0x80A4, + GL_4PASS_0_SGIS = 0x80A4, + GL_4PASS_1_EXT = 0x80A5, + GL_4PASS_1_SGIS = 0x80A5, + GL_4PASS_2_EXT = 0x80A6, + GL_4PASS_2_SGIS = 0x80A6, + GL_4PASS_3_EXT = 0x80A7, + GL_4PASS_3_SGIS = 0x80A7, + GL_SAMPLE_BUFFERS = 0x80A8, + GL_SAMPLE_BUFFERS_ARB = 0x80A8, + GL_SAMPLE_BUFFERS_EXT = 0x80A8, + GL_SAMPLE_BUFFERS_SGIS = 0x80A8, + GL_SAMPLES = 0x80A9, + GL_SAMPLES_ARB = 0x80A9, + GL_SAMPLES_EXT = 0x80A9, + GL_SAMPLES_SGIS = 0x80A9, + GL_SAMPLE_COVERAGE_VALUE = 0x80AA, + GL_SAMPLE_COVERAGE_VALUE_ARB = 0x80AA, + GL_SAMPLE_MASK_VALUE_EXT = 0x80AA, + GL_SAMPLE_MASK_VALUE_SGIS = 0x80AA, + GL_SAMPLE_COVERAGE_INVERT = 0x80AB, + GL_SAMPLE_COVERAGE_INVERT_ARB = 0x80AB, + GL_SAMPLE_MASK_INVERT_EXT = 0x80AB, + GL_SAMPLE_MASK_INVERT_SGIS = 0x80AB, + GL_SAMPLE_PATTERN_EXT = 0x80AC, + GL_SAMPLE_PATTERN_SGIS = 0x80AC, + GL_LINEAR_SHARPEN_SGIS = 0x80AD, + GL_LINEAR_SHARPEN_ALPHA_SGIS = 0x80AE, + GL_LINEAR_SHARPEN_COLOR_SGIS = 0x80AF, + GL_SHARPEN_TEXTURE_FUNC_POINTS_SGIS = 0x80B0, + GL_COLOR_MATRIX = 0x80B1, + GL_COLOR_MATRIX_SGI = 0x80B1, + GL_COLOR_MATRIX_STACK_DEPTH = 0x80B2, + GL_COLOR_MATRIX_STACK_DEPTH_SGI = 0x80B2, + GL_MAX_COLOR_MATRIX_STACK_DEPTH = 0x80B3, + GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI = 0x80B3, + GL_POST_COLOR_MATRIX_RED_SCALE = 0x80B4, + GL_POST_COLOR_MATRIX_RED_SCALE_SGI = 0x80B4, + GL_POST_COLOR_MATRIX_GREEN_SCALE = 0x80B5, + GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI = 0x80B5, + GL_POST_COLOR_MATRIX_BLUE_SCALE = 0x80B6, + GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI = 0x80B6, + GL_POST_COLOR_MATRIX_ALPHA_SCALE = 0x80B7, + GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI = 0x80B7, + GL_POST_COLOR_MATRIX_RED_BIAS = 0x80B8, + GL_POST_COLOR_MATRIX_RED_BIAS_SGI = 0x80B8, + GL_POST_COLOR_MATRIX_GREEN_BIAS = 0x80B9, + GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI = 0x80B9, + GL_POST_COLOR_MATRIX_BLUE_BIAS = 0x80BA, + GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI = 0x80BA, + GL_POST_COLOR_MATRIX_ALPHA_BIAS = 0x80BB, + GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI = 0x80BB, + GL_TEXTURE_COLOR_TABLE_SGI = 0x80BC, + GL_PROXY_TEXTURE_COLOR_TABLE_SGI = 0x80BD, + GL_TEXTURE_ENV_BIAS_SGIX = 0x80BE, + GL_SHADOW_AMBIENT_SGIX = 0x80BF, + GL_TEXTURE_COMPARE_FAIL_VALUE_ARB = 0x80BF, + GL_BLEND_DST_RGB = 0x80C8, + GL_BLEND_DST_RGB_EXT = 0x80C8, + GL_BLEND_DST_RGB_OES = 0x80C8, + GL_BLEND_SRC_RGB = 0x80C9, + GL_BLEND_SRC_RGB_EXT = 0x80C9, + GL_BLEND_SRC_RGB_OES = 0x80C9, + GL_BLEND_DST_ALPHA = 0x80CA, + GL_BLEND_DST_ALPHA_EXT = 0x80CA, + GL_BLEND_DST_ALPHA_OES = 0x80CA, + GL_BLEND_SRC_ALPHA = 0x80CB, + GL_BLEND_SRC_ALPHA_EXT = 0x80CB, + GL_BLEND_SRC_ALPHA_OES = 0x80CB, + GL_422_EXT = 0x80CC, + GL_422_REV_EXT = 0x80CD, + GL_422_AVERAGE_EXT = 0x80CE, + GL_422_REV_AVERAGE_EXT = 0x80CF, + GL_COLOR_TABLE = 0x80D0, + GL_COLOR_TABLE_SGI = 0x80D0, + GL_POST_CONVOLUTION_COLOR_TABLE = 0x80D1, + GL_POST_CONVOLUTION_COLOR_TABLE_SGI = 0x80D1, + GL_POST_COLOR_MATRIX_COLOR_TABLE = 0x80D2, + GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI = 0x80D2, + GL_PROXY_COLOR_TABLE = 0x80D3, + GL_PROXY_COLOR_TABLE_SGI = 0x80D3, + GL_PROXY_POST_CONVOLUTION_COLOR_TABLE = 0x80D4, + GL_PROXY_POST_CONVOLUTION_COLOR_TABLE_SGI = 0x80D4, + GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE = 0x80D5, + GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE_SGI = 0x80D5, + GL_COLOR_TABLE_SCALE = 0x80D6, + GL_COLOR_TABLE_SCALE_SGI = 0x80D6, + GL_COLOR_TABLE_BIAS = 0x80D7, + GL_COLOR_TABLE_BIAS_SGI = 0x80D7, + GL_COLOR_TABLE_FORMAT = 0x80D8, + GL_COLOR_TABLE_FORMAT_SGI = 0x80D8, + GL_COLOR_TABLE_WIDTH = 0x80D9, + GL_COLOR_TABLE_WIDTH_SGI = 0x80D9, + GL_COLOR_TABLE_RED_SIZE = 0x80DA, + GL_COLOR_TABLE_RED_SIZE_SGI = 0x80DA, + GL_COLOR_TABLE_GREEN_SIZE = 0x80DB, + GL_COLOR_TABLE_GREEN_SIZE_SGI = 0x80DB, + GL_COLOR_TABLE_BLUE_SIZE = 0x80DC, + GL_COLOR_TABLE_BLUE_SIZE_SGI = 0x80DC, + GL_COLOR_TABLE_ALPHA_SIZE = 0x80DD, + GL_COLOR_TABLE_ALPHA_SIZE_SGI = 0x80DD, + GL_COLOR_TABLE_LUMINANCE_SIZE = 0x80DE, + GL_COLOR_TABLE_LUMINANCE_SIZE_SGI = 0x80DE, + GL_COLOR_TABLE_INTENSITY_SIZE = 0x80DF, + GL_COLOR_TABLE_INTENSITY_SIZE_SGI = 0x80DF, + GL_BGR = 0x80E0, + GL_BGR_EXT = 0x80E0, + GL_BGRA = 0x80E1, + GL_BGRA_EXT = 0x80E1, + GL_BGRA_IMG = 0x80E1, + GL_COLOR_INDEX1_EXT = 0x80E2, + GL_COLOR_INDEX2_EXT = 0x80E3, + GL_COLOR_INDEX4_EXT = 0x80E4, + GL_COLOR_INDEX8_EXT = 0x80E5, + GL_COLOR_INDEX12_EXT = 0x80E6, + GL_COLOR_INDEX16_EXT = 0x80E7, + GL_MAX_ELEMENTS_VERTICES = 0x80E8, + GL_MAX_ELEMENTS_VERTICES_EXT = 0x80E8, + GL_MAX_ELEMENTS_INDICES = 0x80E9, + GL_MAX_ELEMENTS_INDICES_EXT = 0x80E9, + GL_PHONG_WIN = 0x80EA, + GL_PHONG_HINT_WIN = 0x80EB, + GL_FOG_SPECULAR_TEXTURE_WIN = 0x80EC, + GL_TEXTURE_INDEX_SIZE_EXT = 0x80ED, + GL_PARAMETER_BUFFER = 0x80EE, + GL_PARAMETER_BUFFER_ARB = 0x80EE, + GL_PARAMETER_BUFFER_BINDING = 0x80EF, + GL_PARAMETER_BUFFER_BINDING_ARB = 0x80EF, + GL_CLIP_VOLUME_CLIPPING_HINT_EXT = 0x80F0, + GL_DUAL_ALPHA4_SGIS = 0x8110, + GL_DUAL_ALPHA8_SGIS = 0x8111, + GL_DUAL_ALPHA12_SGIS = 0x8112, + GL_DUAL_ALPHA16_SGIS = 0x8113, + GL_DUAL_LUMINANCE4_SGIS = 0x8114, + GL_DUAL_LUMINANCE8_SGIS = 0x8115, + GL_DUAL_LUMINANCE12_SGIS = 0x8116, + GL_DUAL_LUMINANCE16_SGIS = 0x8117, + GL_DUAL_INTENSITY4_SGIS = 0x8118, + GL_DUAL_INTENSITY8_SGIS = 0x8119, + GL_DUAL_INTENSITY12_SGIS = 0x811A, + GL_DUAL_INTENSITY16_SGIS = 0x811B, + GL_DUAL_LUMINANCE_ALPHA4_SGIS = 0x811C, + GL_DUAL_LUMINANCE_ALPHA8_SGIS = 0x811D, + GL_QUAD_ALPHA4_SGIS = 0x811E, + GL_QUAD_ALPHA8_SGIS = 0x811F, + GL_QUAD_LUMINANCE4_SGIS = 0x8120, + GL_QUAD_LUMINANCE8_SGIS = 0x8121, + GL_QUAD_INTENSITY4_SGIS = 0x8122, + GL_QUAD_INTENSITY8_SGIS = 0x8123, + GL_DUAL_TEXTURE_SELECT_SGIS = 0x8124, + GL_QUAD_TEXTURE_SELECT_SGIS = 0x8125, + GL_POINT_SIZE_MIN = 0x8126, + GL_POINT_SIZE_MIN_ARB = 0x8126, + GL_POINT_SIZE_MIN_EXT = 0x8126, + GL_POINT_SIZE_MIN_SGIS = 0x8126, + GL_POINT_SIZE_MAX = 0x8127, + GL_POINT_SIZE_MAX_ARB = 0x8127, + GL_POINT_SIZE_MAX_EXT = 0x8127, + GL_POINT_SIZE_MAX_SGIS = 0x8127, + GL_POINT_FADE_THRESHOLD_SIZE = 0x8128, + GL_POINT_FADE_THRESHOLD_SIZE_ARB = 0x8128, + GL_POINT_FADE_THRESHOLD_SIZE_EXT = 0x8128, + GL_POINT_FADE_THRESHOLD_SIZE_SGIS = 0x8128, + GL_DISTANCE_ATTENUATION_EXT = 0x8129, + GL_DISTANCE_ATTENUATION_SGIS = 0x8129, + GL_POINT_DISTANCE_ATTENUATION = 0x8129, + GL_POINT_DISTANCE_ATTENUATION_ARB = 0x8129, + GL_FOG_FUNC_SGIS = 0x812A, + GL_FOG_FUNC_POINTS_SGIS = 0x812B, + GL_MAX_FOG_FUNC_POINTS_SGIS = 0x812C, + GL_CLAMP_TO_BORDER = 0x812D, + GL_CLAMP_TO_BORDER_ARB = 0x812D, + GL_CLAMP_TO_BORDER_EXT = 0x812D, + GL_CLAMP_TO_BORDER_NV = 0x812D, + GL_CLAMP_TO_BORDER_SGIS = 0x812D, + GL_CLAMP_TO_BORDER_OES = 0x812D, + GL_TEXTURE_MULTI_BUFFER_HINT_SGIX = 0x812E, + GL_CLAMP_TO_EDGE = 0x812F, + GL_CLAMP_TO_EDGE_SGIS = 0x812F, + GL_PACK_SKIP_VOLUMES_SGIS = 0x8130, + GL_PACK_IMAGE_DEPTH_SGIS = 0x8131, + GL_UNPACK_SKIP_VOLUMES_SGIS = 0x8132, + GL_UNPACK_IMAGE_DEPTH_SGIS = 0x8133, + GL_TEXTURE_4D_SGIS = 0x8134, + GL_PROXY_TEXTURE_4D_SGIS = 0x8135, + GL_TEXTURE_4DSIZE_SGIS = 0x8136, + GL_TEXTURE_WRAP_Q_SGIS = 0x8137, + GL_MAX_4D_TEXTURE_SIZE_SGIS = 0x8138, + GL_PIXEL_TEX_GEN_SGIX = 0x8139, + GL_TEXTURE_MIN_LOD = 0x813A, + GL_TEXTURE_MIN_LOD_SGIS = 0x813A, + GL_TEXTURE_MAX_LOD = 0x813B, + GL_TEXTURE_MAX_LOD_SGIS = 0x813B, + GL_TEXTURE_BASE_LEVEL = 0x813C, + GL_TEXTURE_BASE_LEVEL_SGIS = 0x813C, + GL_TEXTURE_MAX_LEVEL = 0x813D, + GL_TEXTURE_MAX_LEVEL_APPLE = 0x813D, + GL_TEXTURE_MAX_LEVEL_SGIS = 0x813D, + GL_PIXEL_TILE_BEST_ALIGNMENT_SGIX = 0x813E, + GL_PIXEL_TILE_CACHE_INCREMENT_SGIX = 0x813F, + GL_PIXEL_TILE_WIDTH_SGIX = 0x8140, + GL_PIXEL_TILE_HEIGHT_SGIX = 0x8141, + GL_PIXEL_TILE_GRID_WIDTH_SGIX = 0x8142, + GL_PIXEL_TILE_GRID_HEIGHT_SGIX = 0x8143, + GL_PIXEL_TILE_GRID_DEPTH_SGIX = 0x8144, + GL_PIXEL_TILE_CACHE_SIZE_SGIX = 0x8145, + GL_FILTER4_SGIS = 0x8146, + GL_TEXTURE_FILTER4_SIZE_SGIS = 0x8147, + GL_SPRITE_SGIX = 0x8148, + GL_SPRITE_MODE_SGIX = 0x8149, + GL_SPRITE_AXIS_SGIX = 0x814A, + GL_SPRITE_TRANSLATION_SGIX = 0x814B, + GL_SPRITE_AXIAL_SGIX = 0x814C, + GL_SPRITE_OBJECT_ALIGNED_SGIX = 0x814D, + GL_SPRITE_EYE_ALIGNED_SGIX = 0x814E, + GL_TEXTURE_4D_BINDING_SGIS = 0x814F, + GL_IGNORE_BORDER_HP = 0x8150, + GL_CONSTANT_BORDER = 0x8151, + GL_CONSTANT_BORDER_HP = 0x8151, + GL_REPLICATE_BORDER = 0x8153, + GL_REPLICATE_BORDER_HP = 0x8153, + GL_CONVOLUTION_BORDER_COLOR = 0x8154, + GL_CONVOLUTION_BORDER_COLOR_HP = 0x8154, + GL_IMAGE_SCALE_X_HP = 0x8155, + GL_IMAGE_SCALE_Y_HP = 0x8156, + GL_IMAGE_TRANSLATE_X_HP = 0x8157, + GL_IMAGE_TRANSLATE_Y_HP = 0x8158, + GL_IMAGE_ROTATE_ANGLE_HP = 0x8159, + GL_IMAGE_ROTATE_ORIGIN_X_HP = 0x815A, + GL_IMAGE_ROTATE_ORIGIN_Y_HP = 0x815B, + GL_IMAGE_MAG_FILTER_HP = 0x815C, + GL_IMAGE_MIN_FILTER_HP = 0x815D, + GL_IMAGE_CUBIC_WEIGHT_HP = 0x815E, + GL_CUBIC_HP = 0x815F, + GL_AVERAGE_HP = 0x8160, + GL_IMAGE_TRANSFORM_2D_HP = 0x8161, + GL_POST_IMAGE_TRANSFORM_COLOR_TABLE_HP = 0x8162, + GL_PROXY_POST_IMAGE_TRANSFORM_COLOR_TABLE_HP = 0x8163, + GL_OCCLUSION_TEST_HP = 0x8165, + GL_OCCLUSION_TEST_RESULT_HP = 0x8166, + GL_TEXTURE_LIGHTING_MODE_HP = 0x8167, + GL_TEXTURE_POST_SPECULAR_HP = 0x8168, + GL_TEXTURE_PRE_SPECULAR_HP = 0x8169, + GL_LINEAR_CLIPMAP_LINEAR_SGIX = 0x8170, + GL_TEXTURE_CLIPMAP_CENTER_SGIX = 0x8171, + GL_TEXTURE_CLIPMAP_FRAME_SGIX = 0x8172, + GL_TEXTURE_CLIPMAP_OFFSET_SGIX = 0x8173, + GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX = 0x8174, + GL_TEXTURE_CLIPMAP_LOD_OFFSET_SGIX = 0x8175, + GL_TEXTURE_CLIPMAP_DEPTH_SGIX = 0x8176, + GL_MAX_CLIPMAP_DEPTH_SGIX = 0x8177, + GL_MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX = 0x8178, + GL_POST_TEXTURE_FILTER_BIAS_SGIX = 0x8179, + GL_POST_TEXTURE_FILTER_SCALE_SGIX = 0x817A, + GL_POST_TEXTURE_FILTER_BIAS_RANGE_SGIX = 0x817B, + GL_POST_TEXTURE_FILTER_SCALE_RANGE_SGIX = 0x817C, + GL_REFERENCE_PLANE_SGIX = 0x817D, + GL_REFERENCE_PLANE_EQUATION_SGIX = 0x817E, + GL_IR_INSTRUMENT1_SGIX = 0x817F, + GL_INSTRUMENT_BUFFER_POINTER_SGIX = 0x8180, + GL_INSTRUMENT_MEASUREMENTS_SGIX = 0x8181, + GL_LIST_PRIORITY_SGIX = 0x8182, + GL_CALLIGRAPHIC_FRAGMENT_SGIX = 0x8183, + GL_PIXEL_TEX_GEN_Q_CEILING_SGIX = 0x8184, + GL_PIXEL_TEX_GEN_Q_ROUND_SGIX = 0x8185, + GL_PIXEL_TEX_GEN_Q_FLOOR_SGIX = 0x8186, + GL_PIXEL_TEX_GEN_ALPHA_REPLACE_SGIX = 0x8187, + GL_PIXEL_TEX_GEN_ALPHA_NO_REPLACE_SGIX = 0x8188, + GL_PIXEL_TEX_GEN_ALPHA_LS_SGIX = 0x8189, + GL_PIXEL_TEX_GEN_ALPHA_MS_SGIX = 0x818A, + GL_FRAMEZOOM_SGIX = 0x818B, + GL_FRAMEZOOM_FACTOR_SGIX = 0x818C, + GL_MAX_FRAMEZOOM_FACTOR_SGIX = 0x818D, + GL_TEXTURE_LOD_BIAS_S_SGIX = 0x818E, + GL_TEXTURE_LOD_BIAS_T_SGIX = 0x818F, + GL_TEXTURE_LOD_BIAS_R_SGIX = 0x8190, + GL_GENERATE_MIPMAP = 0x8191, + GL_GENERATE_MIPMAP_SGIS = 0x8191, + GL_GENERATE_MIPMAP_HINT = 0x8192, + GL_GENERATE_MIPMAP_HINT_SGIS = 0x8192, + GL_GEOMETRY_DEFORMATION_SGIX = 0x8194, + GL_TEXTURE_DEFORMATION_SGIX = 0x8195, + GL_DEFORMATIONS_MASK_SGIX = 0x8196, + GL_MAX_DEFORMATION_ORDER_SGIX = 0x8197, + GL_FOG_OFFSET_SGIX = 0x8198, + GL_FOG_OFFSET_VALUE_SGIX = 0x8199, + GL_TEXTURE_COMPARE_SGIX = 0x819A, + GL_TEXTURE_COMPARE_OPERATOR_SGIX = 0x819B, + GL_TEXTURE_LEQUAL_R_SGIX = 0x819C, + GL_TEXTURE_GEQUAL_R_SGIX = 0x819D, + GL_DEPTH_COMPONENT16 = 0x81A5, + GL_DEPTH_COMPONENT16_ARB = 0x81A5, + GL_DEPTH_COMPONENT16_OES = 0x81A5, + GL_DEPTH_COMPONENT16_SGIX = 0x81A5, + GL_DEPTH_COMPONENT24 = 0x81A6, + GL_DEPTH_COMPONENT24_ARB = 0x81A6, + GL_DEPTH_COMPONENT24_OES = 0x81A6, + GL_DEPTH_COMPONENT24_SGIX = 0x81A6, + GL_DEPTH_COMPONENT32 = 0x81A7, + GL_DEPTH_COMPONENT32_ARB = 0x81A7, + GL_DEPTH_COMPONENT32_OES = 0x81A7, + GL_DEPTH_COMPONENT32_SGIX = 0x81A7, + GL_ARRAY_ELEMENT_LOCK_FIRST_EXT = 0x81A8, + GL_ARRAY_ELEMENT_LOCK_COUNT_EXT = 0x81A9, + GL_CULL_VERTEX_EXT = 0x81AA, + GL_CULL_VERTEX_EYE_POSITION_EXT = 0x81AB, + GL_CULL_VERTEX_OBJECT_POSITION_EXT = 0x81AC, + GL_IUI_V2F_EXT = 0x81AD, + GL_IUI_V3F_EXT = 0x81AE, + GL_IUI_N3F_V2F_EXT = 0x81AF, + GL_IUI_N3F_V3F_EXT = 0x81B0, + GL_T2F_IUI_V2F_EXT = 0x81B1, + GL_T2F_IUI_V3F_EXT = 0x81B2, + GL_T2F_IUI_N3F_V2F_EXT = 0x81B3, + GL_T2F_IUI_N3F_V3F_EXT = 0x81B4, + GL_INDEX_TEST_EXT = 0x81B5, + GL_INDEX_TEST_FUNC_EXT = 0x81B6, + GL_INDEX_TEST_REF_EXT = 0x81B7, + GL_INDEX_MATERIAL_EXT = 0x81B8, + GL_INDEX_MATERIAL_PARAMETER_EXT = 0x81B9, + GL_INDEX_MATERIAL_FACE_EXT = 0x81BA, + GL_YCRCB_422_SGIX = 0x81BB, + GL_YCRCB_444_SGIX = 0x81BC, + GL_WRAP_BORDER_SUN = 0x81D4, + GL_UNPACK_CONSTANT_DATA_SUNX = 0x81D5, + GL_TEXTURE_CONSTANT_DATA_SUNX = 0x81D6, + GL_TRIANGLE_LIST_SUN = 0x81D7, + GL_REPLACEMENT_CODE_SUN = 0x81D8, + GL_GLOBAL_ALPHA_SUN = 0x81D9, + GL_GLOBAL_ALPHA_FACTOR_SUN = 0x81DA, + GL_TEXTURE_COLOR_WRITEMASK_SGIS = 0x81EF, + GL_EYE_DISTANCE_TO_POINT_SGIS = 0x81F0, + GL_OBJECT_DISTANCE_TO_POINT_SGIS = 0x81F1, + GL_EYE_DISTANCE_TO_LINE_SGIS = 0x81F2, + GL_OBJECT_DISTANCE_TO_LINE_SGIS = 0x81F3, + GL_EYE_POINT_SGIS = 0x81F4, + GL_OBJECT_POINT_SGIS = 0x81F5, + GL_EYE_LINE_SGIS = 0x81F6, + GL_OBJECT_LINE_SGIS = 0x81F7, + GL_LIGHT_MODEL_COLOR_CONTROL = 0x81F8, + GL_LIGHT_MODEL_COLOR_CONTROL_EXT = 0x81F8, + GL_SINGLE_COLOR = 0x81F9, + GL_SINGLE_COLOR_EXT = 0x81F9, + GL_SEPARATE_SPECULAR_COLOR = 0x81FA, + GL_SEPARATE_SPECULAR_COLOR_EXT = 0x81FA, + GL_SHARED_TEXTURE_PALETTE_EXT = 0x81FB, + GL_TEXT_FRAGMENT_SHADER_ATI = 0x8200, + GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING = 0x8210, + GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING_EXT = 0x8210, + GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE = 0x8211, + GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE_EXT = 0x8211, + GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE = 0x8212, + GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE = 0x8213, + GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE = 0x8214, + GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE = 0x8215, + GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE = 0x8216, + GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE = 0x8217, + GL_FRAMEBUFFER_DEFAULT = 0x8218, + GL_FRAMEBUFFER_UNDEFINED = 0x8219, + GL_FRAMEBUFFER_UNDEFINED_OES = 0x8219, + GL_DEPTH_STENCIL_ATTACHMENT = 0x821A, + GL_MAJOR_VERSION = 0x821B, + GL_MINOR_VERSION = 0x821C, + GL_NUM_EXTENSIONS = 0x821D, + GL_CONTEXT_FLAGS = 0x821E, + GL_BUFFER_IMMUTABLE_STORAGE = 0x821F, + GL_BUFFER_IMMUTABLE_STORAGE_EXT = 0x821F, + GL_BUFFER_STORAGE_FLAGS = 0x8220, + GL_BUFFER_STORAGE_FLAGS_EXT = 0x8220, + GL_PRIMITIVE_RESTART_FOR_PATCHES_SUPPORTED = 0x8221, + GL_PRIMITIVE_RESTART_FOR_PATCHES_SUPPORTED_OES = 0x8221, + GL_INDEX = 0x8222, + GL_COMPRESSED_RED = 0x8225, + GL_COMPRESSED_RG = 0x8226, + GL_RG = 0x8227, + GL_RG_EXT = 0x8227, + GL_RG_INTEGER = 0x8228, + GL_R8 = 0x8229, + GL_R8_EXT = 0x8229, + GL_R16 = 0x822A, + GL_R16_EXT = 0x822A, + GL_RG8 = 0x822B, + GL_RG8_EXT = 0x822B, + GL_RG16 = 0x822C, + GL_RG16_EXT = 0x822C, + GL_R16F = 0x822D, + GL_R16F_EXT = 0x822D, + GL_R32F = 0x822E, + GL_R32F_EXT = 0x822E, + GL_RG16F = 0x822F, + GL_RG16F_EXT = 0x822F, + GL_RG32F = 0x8230, + GL_RG32F_EXT = 0x8230, + GL_R8I = 0x8231, + GL_R8UI = 0x8232, + GL_R16I = 0x8233, + GL_R16UI = 0x8234, + GL_R32I = 0x8235, + GL_R32UI = 0x8236, + GL_RG8I = 0x8237, + GL_RG8UI = 0x8238, + GL_RG16I = 0x8239, + GL_RG16UI = 0x823A, + GL_RG32I = 0x823B, + GL_RG32UI = 0x823C, + GL_SYNC_CL_EVENT_ARB = 0x8240, + GL_SYNC_CL_EVENT_COMPLETE_ARB = 0x8241, + GL_DEBUG_OUTPUT_SYNCHRONOUS = 0x8242, + GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB = 0x8242, + GL_DEBUG_OUTPUT_SYNCHRONOUS_KHR = 0x8242, + GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH = 0x8243, + GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH_ARB = 0x8243, + GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH_KHR = 0x8243, + GL_DEBUG_CALLBACK_FUNCTION = 0x8244, + GL_DEBUG_CALLBACK_FUNCTION_ARB = 0x8244, + GL_DEBUG_CALLBACK_FUNCTION_KHR = 0x8244, + GL_DEBUG_CALLBACK_USER_PARAM = 0x8245, + GL_DEBUG_CALLBACK_USER_PARAM_ARB = 0x8245, + GL_DEBUG_CALLBACK_USER_PARAM_KHR = 0x8245, + GL_DEBUG_SOURCE_API = 0x8246, + GL_DEBUG_SOURCE_API_ARB = 0x8246, + GL_DEBUG_SOURCE_API_KHR = 0x8246, + GL_DEBUG_SOURCE_WINDOW_SYSTEM = 0x8247, + GL_DEBUG_SOURCE_WINDOW_SYSTEM_ARB = 0x8247, + GL_DEBUG_SOURCE_WINDOW_SYSTEM_KHR = 0x8247, + GL_DEBUG_SOURCE_SHADER_COMPILER = 0x8248, + GL_DEBUG_SOURCE_SHADER_COMPILER_ARB = 0x8248, + GL_DEBUG_SOURCE_SHADER_COMPILER_KHR = 0x8248, + GL_DEBUG_SOURCE_THIRD_PARTY = 0x8249, + GL_DEBUG_SOURCE_THIRD_PARTY_ARB = 0x8249, + GL_DEBUG_SOURCE_THIRD_PARTY_KHR = 0x8249, + GL_DEBUG_SOURCE_APPLICATION = 0x824A, + GL_DEBUG_SOURCE_APPLICATION_ARB = 0x824A, + GL_DEBUG_SOURCE_APPLICATION_KHR = 0x824A, + GL_DEBUG_SOURCE_OTHER = 0x824B, + GL_DEBUG_SOURCE_OTHER_ARB = 0x824B, + GL_DEBUG_SOURCE_OTHER_KHR = 0x824B, + GL_DEBUG_TYPE_ERROR = 0x824C, + GL_DEBUG_TYPE_ERROR_ARB = 0x824C, + GL_DEBUG_TYPE_ERROR_KHR = 0x824C, + GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR = 0x824D, + GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR_ARB = 0x824D, + GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR_KHR = 0x824D, + GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR = 0x824E, + GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR_ARB = 0x824E, + GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR_KHR = 0x824E, + GL_DEBUG_TYPE_PORTABILITY = 0x824F, + GL_DEBUG_TYPE_PORTABILITY_ARB = 0x824F, + GL_DEBUG_TYPE_PORTABILITY_KHR = 0x824F, + GL_DEBUG_TYPE_PERFORMANCE = 0x8250, + GL_DEBUG_TYPE_PERFORMANCE_ARB = 0x8250, + GL_DEBUG_TYPE_PERFORMANCE_KHR = 0x8250, + GL_DEBUG_TYPE_OTHER = 0x8251, + GL_DEBUG_TYPE_OTHER_ARB = 0x8251, + GL_DEBUG_TYPE_OTHER_KHR = 0x8251, + GL_LOSE_CONTEXT_ON_RESET = 0x8252, + GL_LOSE_CONTEXT_ON_RESET_ARB = 0x8252, + GL_LOSE_CONTEXT_ON_RESET_EXT = 0x8252, + GL_LOSE_CONTEXT_ON_RESET_KHR = 0x8252, + GL_GUILTY_CONTEXT_RESET = 0x8253, + GL_GUILTY_CONTEXT_RESET_ARB = 0x8253, + GL_GUILTY_CONTEXT_RESET_EXT = 0x8253, + GL_GUILTY_CONTEXT_RESET_KHR = 0x8253, + GL_INNOCENT_CONTEXT_RESET = 0x8254, + GL_INNOCENT_CONTEXT_RESET_ARB = 0x8254, + GL_INNOCENT_CONTEXT_RESET_EXT = 0x8254, + GL_INNOCENT_CONTEXT_RESET_KHR = 0x8254, + GL_UNKNOWN_CONTEXT_RESET = 0x8255, + GL_UNKNOWN_CONTEXT_RESET_ARB = 0x8255, + GL_UNKNOWN_CONTEXT_RESET_EXT = 0x8255, + GL_UNKNOWN_CONTEXT_RESET_KHR = 0x8255, + GL_RESET_NOTIFICATION_STRATEGY = 0x8256, + GL_RESET_NOTIFICATION_STRATEGY_ARB = 0x8256, + GL_RESET_NOTIFICATION_STRATEGY_EXT = 0x8256, + GL_RESET_NOTIFICATION_STRATEGY_KHR = 0x8256, + GL_PROGRAM_BINARY_RETRIEVABLE_HINT = 0x8257, + GL_PROGRAM_SEPARABLE = 0x8258, + GL_PROGRAM_SEPARABLE_EXT = 0x8258, + GL_ACTIVE_PROGRAM = 0x8259, + GL_ACTIVE_PROGRAM_EXT = 0x8259, + GL_PROGRAM_PIPELINE_BINDING = 0x825A, + GL_PROGRAM_PIPELINE_BINDING_EXT = 0x825A, + GL_MAX_VIEWPORTS = 0x825B, + GL_MAX_VIEWPORTS_NV = 0x825B, + GL_MAX_VIEWPORTS_OES = 0x825B, + GL_VIEWPORT_SUBPIXEL_BITS = 0x825C, + GL_VIEWPORT_SUBPIXEL_BITS_EXT = 0x825C, + GL_VIEWPORT_SUBPIXEL_BITS_NV = 0x825C, + GL_VIEWPORT_SUBPIXEL_BITS_OES = 0x825C, + GL_VIEWPORT_BOUNDS_RANGE = 0x825D, + GL_VIEWPORT_BOUNDS_RANGE_EXT = 0x825D, + GL_VIEWPORT_BOUNDS_RANGE_NV = 0x825D, + GL_VIEWPORT_BOUNDS_RANGE_OES = 0x825D, + GL_LAYER_PROVOKING_VERTEX = 0x825E, + GL_LAYER_PROVOKING_VERTEX_EXT = 0x825E, + GL_LAYER_PROVOKING_VERTEX_OES = 0x825E, + GL_VIEWPORT_INDEX_PROVOKING_VERTEX = 0x825F, + GL_VIEWPORT_INDEX_PROVOKING_VERTEX_EXT = 0x825F, + GL_VIEWPORT_INDEX_PROVOKING_VERTEX_NV = 0x825F, + GL_VIEWPORT_INDEX_PROVOKING_VERTEX_OES = 0x825F, + GL_UNDEFINED_VERTEX = 0x8260, + GL_UNDEFINED_VERTEX_EXT = 0x8260, + GL_UNDEFINED_VERTEX_OES = 0x8260, + GL_NO_RESET_NOTIFICATION = 0x8261, + GL_NO_RESET_NOTIFICATION_ARB = 0x8261, + GL_NO_RESET_NOTIFICATION_EXT = 0x8261, + GL_NO_RESET_NOTIFICATION_KHR = 0x8261, + GL_MAX_COMPUTE_SHARED_MEMORY_SIZE = 0x8262, + GL_MAX_COMPUTE_UNIFORM_COMPONENTS = 0x8263, + GL_MAX_COMPUTE_ATOMIC_COUNTER_BUFFERS = 0x8264, + GL_MAX_COMPUTE_ATOMIC_COUNTERS = 0x8265, + GL_MAX_COMBINED_COMPUTE_UNIFORM_COMPONENTS = 0x8266, + GL_COMPUTE_WORK_GROUP_SIZE = 0x8267, + GL_DEBUG_TYPE_MARKER = 0x8268, + GL_DEBUG_TYPE_MARKER_KHR = 0x8268, + GL_DEBUG_TYPE_PUSH_GROUP = 0x8269, + GL_DEBUG_TYPE_PUSH_GROUP_KHR = 0x8269, + GL_DEBUG_TYPE_POP_GROUP = 0x826A, + GL_DEBUG_TYPE_POP_GROUP_KHR = 0x826A, + GL_DEBUG_SEVERITY_NOTIFICATION = 0x826B, + GL_DEBUG_SEVERITY_NOTIFICATION_KHR = 0x826B, + GL_MAX_DEBUG_GROUP_STACK_DEPTH = 0x826C, + GL_MAX_DEBUG_GROUP_STACK_DEPTH_KHR = 0x826C, + GL_DEBUG_GROUP_STACK_DEPTH = 0x826D, + GL_DEBUG_GROUP_STACK_DEPTH_KHR = 0x826D, + GL_MAX_UNIFORM_LOCATIONS = 0x826E, + GL_INTERNALFORMAT_SUPPORTED = 0x826F, + GL_INTERNALFORMAT_PREFERRED = 0x8270, + GL_INTERNALFORMAT_RED_SIZE = 0x8271, + GL_INTERNALFORMAT_GREEN_SIZE = 0x8272, + GL_INTERNALFORMAT_BLUE_SIZE = 0x8273, + GL_INTERNALFORMAT_ALPHA_SIZE = 0x8274, + GL_INTERNALFORMAT_DEPTH_SIZE = 0x8275, + GL_INTERNALFORMAT_STENCIL_SIZE = 0x8276, + GL_INTERNALFORMAT_SHARED_SIZE = 0x8277, + GL_INTERNALFORMAT_RED_TYPE = 0x8278, + GL_INTERNALFORMAT_GREEN_TYPE = 0x8279, + GL_INTERNALFORMAT_BLUE_TYPE = 0x827A, + GL_INTERNALFORMAT_ALPHA_TYPE = 0x827B, + GL_INTERNALFORMAT_DEPTH_TYPE = 0x827C, + GL_INTERNALFORMAT_STENCIL_TYPE = 0x827D, + GL_MAX_WIDTH = 0x827E, + GL_MAX_HEIGHT = 0x827F, + GL_MAX_DEPTH = 0x8280, + GL_MAX_LAYERS = 0x8281, + GL_MAX_COMBINED_DIMENSIONS = 0x8282, + GL_COLOR_COMPONENTS = 0x8283, + GL_DEPTH_COMPONENTS = 0x8284, + GL_STENCIL_COMPONENTS = 0x8285, + GL_COLOR_RENDERABLE = 0x8286, + GL_DEPTH_RENDERABLE = 0x8287, + GL_STENCIL_RENDERABLE = 0x8288, + GL_FRAMEBUFFER_RENDERABLE = 0x8289, + GL_FRAMEBUFFER_RENDERABLE_LAYERED = 0x828A, + GL_FRAMEBUFFER_BLEND = 0x828B, + GL_READ_PIXELS = 0x828C, + GL_READ_PIXELS_FORMAT = 0x828D, + GL_READ_PIXELS_TYPE = 0x828E, + GL_TEXTURE_IMAGE_FORMAT = 0x828F, + GL_TEXTURE_IMAGE_TYPE = 0x8290, + GL_GET_TEXTURE_IMAGE_FORMAT = 0x8291, + GL_GET_TEXTURE_IMAGE_TYPE = 0x8292, + GL_MIPMAP = 0x8293, + GL_MANUAL_GENERATE_MIPMAP = 0x8294, + GL_AUTO_GENERATE_MIPMAP = 0x8295, + GL_COLOR_ENCODING = 0x8296, + GL_SRGB_READ = 0x8297, + GL_SRGB_WRITE = 0x8298, + GL_SRGB_DECODE_ARB = 0x8299, + GL_FILTER = 0x829A, + GL_VERTEX_TEXTURE = 0x829B, + GL_TESS_CONTROL_TEXTURE = 0x829C, + GL_TESS_EVALUATION_TEXTURE = 0x829D, + GL_GEOMETRY_TEXTURE = 0x829E, + GL_FRAGMENT_TEXTURE = 0x829F, + GL_COMPUTE_TEXTURE = 0x82A0, + GL_TEXTURE_SHADOW = 0x82A1, + GL_TEXTURE_GATHER = 0x82A2, + GL_TEXTURE_GATHER_SHADOW = 0x82A3, + GL_SHADER_IMAGE_LOAD = 0x82A4, + GL_SHADER_IMAGE_STORE = 0x82A5, + GL_SHADER_IMAGE_ATOMIC = 0x82A6, + GL_IMAGE_TEXEL_SIZE = 0x82A7, + GL_IMAGE_COMPATIBILITY_CLASS = 0x82A8, + GL_IMAGE_PIXEL_FORMAT = 0x82A9, + GL_IMAGE_PIXEL_TYPE = 0x82AA, + GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_TEST = 0x82AC, + GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_TEST = 0x82AD, + GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_WRITE = 0x82AE, + GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_WRITE = 0x82AF, + GL_TEXTURE_COMPRESSED_BLOCK_WIDTH = 0x82B1, + GL_TEXTURE_COMPRESSED_BLOCK_HEIGHT = 0x82B2, + GL_TEXTURE_COMPRESSED_BLOCK_SIZE = 0x82B3, + GL_CLEAR_BUFFER = 0x82B4, + GL_TEXTURE_VIEW = 0x82B5, + GL_VIEW_COMPATIBILITY_CLASS = 0x82B6, + GL_FULL_SUPPORT = 0x82B7, + GL_CAVEAT_SUPPORT = 0x82B8, + GL_IMAGE_CLASS_4_X_32 = 0x82B9, + GL_IMAGE_CLASS_2_X_32 = 0x82BA, + GL_IMAGE_CLASS_1_X_32 = 0x82BB, + GL_IMAGE_CLASS_4_X_16 = 0x82BC, + GL_IMAGE_CLASS_2_X_16 = 0x82BD, + GL_IMAGE_CLASS_1_X_16 = 0x82BE, + GL_IMAGE_CLASS_4_X_8 = 0x82BF, + GL_IMAGE_CLASS_2_X_8 = 0x82C0, + GL_IMAGE_CLASS_1_X_8 = 0x82C1, + GL_IMAGE_CLASS_11_11_10 = 0x82C2, + GL_IMAGE_CLASS_10_10_10_2 = 0x82C3, + GL_VIEW_CLASS_128_BITS = 0x82C4, + GL_VIEW_CLASS_96_BITS = 0x82C5, + GL_VIEW_CLASS_64_BITS = 0x82C6, + GL_VIEW_CLASS_48_BITS = 0x82C7, + GL_VIEW_CLASS_32_BITS = 0x82C8, + GL_VIEW_CLASS_24_BITS = 0x82C9, + GL_VIEW_CLASS_16_BITS = 0x82CA, + GL_VIEW_CLASS_8_BITS = 0x82CB, + GL_VIEW_CLASS_S3TC_DXT1_RGB = 0x82CC, + GL_VIEW_CLASS_S3TC_DXT1_RGBA = 0x82CD, + GL_VIEW_CLASS_S3TC_DXT3_RGBA = 0x82CE, + GL_VIEW_CLASS_S3TC_DXT5_RGBA = 0x82CF, + GL_VIEW_CLASS_RGTC1_RED = 0x82D0, + GL_VIEW_CLASS_RGTC2_RG = 0x82D1, + GL_VIEW_CLASS_BPTC_UNORM = 0x82D2, + GL_VIEW_CLASS_BPTC_FLOAT = 0x82D3, + GL_VERTEX_ATTRIB_BINDING = 0x82D4, + GL_VERTEX_ATTRIB_RELATIVE_OFFSET = 0x82D5, + GL_VERTEX_BINDING_DIVISOR = 0x82D6, + GL_VERTEX_BINDING_OFFSET = 0x82D7, + GL_VERTEX_BINDING_STRIDE = 0x82D8, + GL_MAX_VERTEX_ATTRIB_RELATIVE_OFFSET = 0x82D9, + GL_MAX_VERTEX_ATTRIB_BINDINGS = 0x82DA, + GL_TEXTURE_VIEW_MIN_LEVEL = 0x82DB, + GL_TEXTURE_VIEW_MIN_LEVEL_EXT = 0x82DB, + GL_TEXTURE_VIEW_MIN_LEVEL_OES = 0x82DB, + GL_TEXTURE_VIEW_NUM_LEVELS = 0x82DC, + GL_TEXTURE_VIEW_NUM_LEVELS_EXT = 0x82DC, + GL_TEXTURE_VIEW_NUM_LEVELS_OES = 0x82DC, + GL_TEXTURE_VIEW_MIN_LAYER = 0x82DD, + GL_TEXTURE_VIEW_MIN_LAYER_EXT = 0x82DD, + GL_TEXTURE_VIEW_MIN_LAYER_OES = 0x82DD, + GL_TEXTURE_VIEW_NUM_LAYERS = 0x82DE, + GL_TEXTURE_VIEW_NUM_LAYERS_EXT = 0x82DE, + GL_TEXTURE_VIEW_NUM_LAYERS_OES = 0x82DE, + GL_TEXTURE_IMMUTABLE_LEVELS = 0x82DF, + GL_BUFFER = 0x82E0, + GL_BUFFER_KHR = 0x82E0, + GL_SHADER = 0x82E1, + GL_SHADER_KHR = 0x82E1, + GL_PROGRAM = 0x82E2, + GL_PROGRAM_KHR = 0x82E2, + GL_QUERY = 0x82E3, + GL_QUERY_KHR = 0x82E3, + GL_PROGRAM_PIPELINE = 0x82E4, + GL_PROGRAM_PIPELINE_KHR = 0x82E4, + GL_MAX_VERTEX_ATTRIB_STRIDE = 0x82E5, + GL_SAMPLER = 0x82E6, + GL_SAMPLER_KHR = 0x82E6, + GL_DISPLAY_LIST = 0x82E7, + GL_MAX_LABEL_LENGTH = 0x82E8, + GL_MAX_LABEL_LENGTH_KHR = 0x82E8, + GL_NUM_SHADING_LANGUAGE_VERSIONS = 0x82E9, + GL_QUERY_TARGET = 0x82EA, + GL_TRANSFORM_FEEDBACK_OVERFLOW = 0x82EC, + GL_TRANSFORM_FEEDBACK_OVERFLOW_ARB = 0x82EC, + GL_TRANSFORM_FEEDBACK_STREAM_OVERFLOW = 0x82ED, + GL_TRANSFORM_FEEDBACK_STREAM_OVERFLOW_ARB = 0x82ED, + GL_VERTICES_SUBMITTED = 0x82EE, + GL_VERTICES_SUBMITTED_ARB = 0x82EE, + GL_PRIMITIVES_SUBMITTED = 0x82EF, + GL_PRIMITIVES_SUBMITTED_ARB = 0x82EF, + GL_VERTEX_SHADER_INVOCATIONS = 0x82F0, + GL_VERTEX_SHADER_INVOCATIONS_ARB = 0x82F0, + GL_TESS_CONTROL_SHADER_PATCHES = 0x82F1, + GL_TESS_CONTROL_SHADER_PATCHES_ARB = 0x82F1, + GL_TESS_EVALUATION_SHADER_INVOCATIONS = 0x82F2, + GL_TESS_EVALUATION_SHADER_INVOCATIONS_ARB = 0x82F2, + GL_GEOMETRY_SHADER_PRIMITIVES_EMITTED = 0x82F3, + GL_GEOMETRY_SHADER_PRIMITIVES_EMITTED_ARB = 0x82F3, + GL_FRAGMENT_SHADER_INVOCATIONS = 0x82F4, + GL_FRAGMENT_SHADER_INVOCATIONS_ARB = 0x82F4, + GL_COMPUTE_SHADER_INVOCATIONS = 0x82F5, + GL_COMPUTE_SHADER_INVOCATIONS_ARB = 0x82F5, + GL_CLIPPING_INPUT_PRIMITIVES = 0x82F6, + GL_CLIPPING_INPUT_PRIMITIVES_ARB = 0x82F6, + GL_CLIPPING_OUTPUT_PRIMITIVES = 0x82F7, + GL_CLIPPING_OUTPUT_PRIMITIVES_ARB = 0x82F7, + GL_SPARSE_BUFFER_PAGE_SIZE_ARB = 0x82F8, + GL_MAX_CULL_DISTANCES = 0x82F9, + GL_MAX_CULL_DISTANCES_EXT = 0x82F9, + GL_MAX_COMBINED_CLIP_AND_CULL_DISTANCES = 0x82FA, + GL_MAX_COMBINED_CLIP_AND_CULL_DISTANCES_EXT = 0x82FA, + GL_CONTEXT_RELEASE_BEHAVIOR = 0x82FB, + GL_CONTEXT_RELEASE_BEHAVIOR_KHR = 0x82FB, + GL_CONTEXT_RELEASE_BEHAVIOR_FLUSH = 0x82FC, + GL_CONTEXT_RELEASE_BEHAVIOR_FLUSH_KHR = 0x82FC, + GL_ROBUST_GPU_TIMEOUT_MS_KHR = 0x82FD, + GL_DEPTH_PASS_INSTRUMENT_SGIX = 0x8310, + GL_DEPTH_PASS_INSTRUMENT_COUNTERS_SGIX = 0x8311, + GL_DEPTH_PASS_INSTRUMENT_MAX_SGIX = 0x8312, + GL_FRAGMENTS_INSTRUMENT_SGIX = 0x8313, + GL_FRAGMENTS_INSTRUMENT_COUNTERS_SGIX = 0x8314, + GL_FRAGMENTS_INSTRUMENT_MAX_SGIX = 0x8315, + GL_CONVOLUTION_HINT_SGIX = 0x8316, + GL_YCRCB_SGIX = 0x8318, + GL_YCRCBA_SGIX = 0x8319, + GL_UNPACK_COMPRESSED_SIZE_SGIX = 0x831A, + GL_PACK_MAX_COMPRESSED_SIZE_SGIX = 0x831B, + GL_PACK_COMPRESSED_SIZE_SGIX = 0x831C, + GL_SLIM8U_SGIX = 0x831D, + GL_SLIM10U_SGIX = 0x831E, + GL_SLIM12S_SGIX = 0x831F, + GL_ALPHA_MIN_SGIX = 0x8320, + GL_ALPHA_MAX_SGIX = 0x8321, + GL_SCALEBIAS_HINT_SGIX = 0x8322, + GL_ASYNC_MARKER_SGIX = 0x8329, + GL_PIXEL_TEX_GEN_MODE_SGIX = 0x832B, + GL_ASYNC_HISTOGRAM_SGIX = 0x832C, + GL_MAX_ASYNC_HISTOGRAM_SGIX = 0x832D, + GL_PIXEL_TRANSFORM_2D_EXT = 0x8330, + GL_PIXEL_MAG_FILTER_EXT = 0x8331, + GL_PIXEL_MIN_FILTER_EXT = 0x8332, + GL_PIXEL_CUBIC_WEIGHT_EXT = 0x8333, + GL_CUBIC_EXT = 0x8334, + GL_AVERAGE_EXT = 0x8335, + GL_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT = 0x8336, + GL_MAX_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT = 0x8337, + GL_PIXEL_TRANSFORM_2D_MATRIX_EXT = 0x8338, + GL_FRAGMENT_MATERIAL_EXT = 0x8349, + GL_FRAGMENT_NORMAL_EXT = 0x834A, + GL_FRAGMENT_COLOR_EXT = 0x834C, + GL_ATTENUATION_EXT = 0x834D, + GL_SHADOW_ATTENUATION_EXT = 0x834E, + GL_TEXTURE_APPLICATION_MODE_EXT = 0x834F, + GL_TEXTURE_LIGHT_EXT = 0x8350, + GL_TEXTURE_MATERIAL_FACE_EXT = 0x8351, + GL_TEXTURE_MATERIAL_PARAMETER_EXT = 0x8352, + GL_PIXEL_TEXTURE_SGIS = 0x8353, + GL_PIXEL_FRAGMENT_RGB_SOURCE_SGIS = 0x8354, + GL_PIXEL_FRAGMENT_ALPHA_SOURCE_SGIS = 0x8355, + GL_PIXEL_GROUP_COLOR_SGIS = 0x8356, + GL_LINE_QUALITY_HINT_SGIX = 0x835B, + GL_ASYNC_TEX_IMAGE_SGIX = 0x835C, + GL_ASYNC_DRAW_PIXELS_SGIX = 0x835D, + GL_ASYNC_READ_PIXELS_SGIX = 0x835E, + GL_MAX_ASYNC_TEX_IMAGE_SGIX = 0x835F, + GL_MAX_ASYNC_DRAW_PIXELS_SGIX = 0x8360, + GL_MAX_ASYNC_READ_PIXELS_SGIX = 0x8361, + GL_UNSIGNED_BYTE_2_3_3_REV = 0x8362, + GL_UNSIGNED_BYTE_2_3_3_REV_EXT = 0x8362, + GL_UNSIGNED_SHORT_5_6_5 = 0x8363, + GL_UNSIGNED_SHORT_5_6_5_EXT = 0x8363, + GL_UNSIGNED_SHORT_5_6_5_REV = 0x8364, + GL_UNSIGNED_SHORT_5_6_5_REV_EXT = 0x8364, + GL_UNSIGNED_SHORT_4_4_4_4_REV = 0x8365, + GL_UNSIGNED_SHORT_4_4_4_4_REV_EXT = 0x8365, + GL_UNSIGNED_SHORT_4_4_4_4_REV_IMG = 0x8365, + GL_UNSIGNED_SHORT_1_5_5_5_REV = 0x8366, + GL_UNSIGNED_SHORT_1_5_5_5_REV_EXT = 0x8366, + GL_UNSIGNED_INT_8_8_8_8_REV = 0x8367, + GL_UNSIGNED_INT_8_8_8_8_REV_EXT = 0x8367, + GL_UNSIGNED_INT_2_10_10_10_REV = 0x8368, + GL_UNSIGNED_INT_2_10_10_10_REV_EXT = 0x8368, + GL_TEXTURE_MAX_CLAMP_S_SGIX = 0x8369, + GL_TEXTURE_MAX_CLAMP_T_SGIX = 0x836A, + GL_TEXTURE_MAX_CLAMP_R_SGIX = 0x836B, + GL_MIRRORED_REPEAT = 0x8370, + GL_MIRRORED_REPEAT_ARB = 0x8370, + GL_MIRRORED_REPEAT_IBM = 0x8370, + GL_MIRRORED_REPEAT_OES = 0x8370, + GL_RGB_S3TC = 0x83A0, + GL_RGB4_S3TC = 0x83A1, + GL_RGBA_S3TC = 0x83A2, + GL_RGBA4_S3TC = 0x83A3, + GL_RGBA_DXT5_S3TC = 0x83A4, + GL_RGBA4_DXT5_S3TC = 0x83A5, + GL_VERTEX_PRECLIP_SGIX = 0x83EE, + GL_VERTEX_PRECLIP_HINT_SGIX = 0x83EF, + GL_COMPRESSED_RGB_S3TC_DXT1_EXT = 0x83F0, + GL_COMPRESSED_RGBA_S3TC_DXT1_EXT = 0x83F1, + GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE = 0x83F2, + GL_COMPRESSED_RGBA_S3TC_DXT3_EXT = 0x83F2, + GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE = 0x83F3, + GL_COMPRESSED_RGBA_S3TC_DXT5_EXT = 0x83F3, + GL_PARALLEL_ARRAYS_INTEL = 0x83F4, + GL_VERTEX_ARRAY_PARALLEL_POINTERS_INTEL = 0x83F5, + GL_NORMAL_ARRAY_PARALLEL_POINTERS_INTEL = 0x83F6, + GL_COLOR_ARRAY_PARALLEL_POINTERS_INTEL = 0x83F7, + GL_TEXTURE_COORD_ARRAY_PARALLEL_POINTERS_INTEL = 0x83F8, + GL_PERFQUERY_DONOT_FLUSH_INTEL = 0x83F9, + GL_PERFQUERY_FLUSH_INTEL = 0x83FA, + GL_PERFQUERY_WAIT_INTEL = 0x83FB, + GL_BLACKHOLE_RENDER_INTEL = 0x83FC, + GL_CONSERVATIVE_RASTERIZATION_INTEL = 0x83FE, + GL_TEXTURE_MEMORY_LAYOUT_INTEL = 0x83FF, + GL_FRAGMENT_LIGHTING_SGIX = 0x8400, + GL_FRAGMENT_COLOR_MATERIAL_SGIX = 0x8401, + GL_FRAGMENT_COLOR_MATERIAL_FACE_SGIX = 0x8402, + GL_FRAGMENT_COLOR_MATERIAL_PARAMETER_SGIX = 0x8403, + GL_MAX_FRAGMENT_LIGHTS_SGIX = 0x8404, + GL_MAX_ACTIVE_LIGHTS_SGIX = 0x8405, + GL_CURRENT_RASTER_NORMAL_SGIX = 0x8406, + GL_LIGHT_ENV_MODE_SGIX = 0x8407, + GL_FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER_SGIX = 0x8408, + GL_FRAGMENT_LIGHT_MODEL_TWO_SIDE_SGIX = 0x8409, + GL_FRAGMENT_LIGHT_MODEL_AMBIENT_SGIX = 0x840A, + GL_FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_SGIX = 0x840B, + GL_FRAGMENT_LIGHT0_SGIX = 0x840C, + GL_FRAGMENT_LIGHT1_SGIX = 0x840D, + GL_FRAGMENT_LIGHT2_SGIX = 0x840E, + GL_FRAGMENT_LIGHT3_SGIX = 0x840F, + GL_FRAGMENT_LIGHT4_SGIX = 0x8410, + GL_FRAGMENT_LIGHT5_SGIX = 0x8411, + GL_FRAGMENT_LIGHT6_SGIX = 0x8412, + GL_FRAGMENT_LIGHT7_SGIX = 0x8413, + GL_PACK_RESAMPLE_SGIX = 0x842E, + GL_UNPACK_RESAMPLE_SGIX = 0x842F, + GL_RESAMPLE_DECIMATE_SGIX = 0x8430, + GL_RESAMPLE_REPLICATE_SGIX = 0x8433, + GL_RESAMPLE_ZERO_FILL_SGIX = 0x8434, + GL_TANGENT_ARRAY_EXT = 0x8439, + GL_BINORMAL_ARRAY_EXT = 0x843A, + GL_CURRENT_TANGENT_EXT = 0x843B, + GL_CURRENT_BINORMAL_EXT = 0x843C, + GL_TANGENT_ARRAY_TYPE_EXT = 0x843E, + GL_TANGENT_ARRAY_STRIDE_EXT = 0x843F, + GL_BINORMAL_ARRAY_TYPE_EXT = 0x8440, + GL_BINORMAL_ARRAY_STRIDE_EXT = 0x8441, + GL_TANGENT_ARRAY_POINTER_EXT = 0x8442, + GL_BINORMAL_ARRAY_POINTER_EXT = 0x8443, + GL_MAP1_TANGENT_EXT = 0x8444, + GL_MAP2_TANGENT_EXT = 0x8445, + GL_MAP1_BINORMAL_EXT = 0x8446, + GL_MAP2_BINORMAL_EXT = 0x8447, + GL_NEAREST_CLIPMAP_NEAREST_SGIX = 0x844D, + GL_NEAREST_CLIPMAP_LINEAR_SGIX = 0x844E, + GL_LINEAR_CLIPMAP_NEAREST_SGIX = 0x844F, + GL_FOG_COORDINATE_SOURCE = 0x8450, + GL_FOG_COORDINATE_SOURCE_EXT = 0x8450, + GL_FOG_COORD_SRC = 0x8450, + GL_FOG_COORDINATE = 0x8451, + GL_FOG_COORD = 0x8451, + GL_FOG_COORDINATE_EXT = 0x8451, + GL_FRAGMENT_DEPTH = 0x8452, + GL_FRAGMENT_DEPTH_EXT = 0x8452, + GL_CURRENT_FOG_COORDINATE = 0x8453, + GL_CURRENT_FOG_COORD = 0x8453, + GL_CURRENT_FOG_COORDINATE_EXT = 0x8453, + GL_FOG_COORDINATE_ARRAY_TYPE = 0x8454, + GL_FOG_COORDINATE_ARRAY_TYPE_EXT = 0x8454, + GL_FOG_COORD_ARRAY_TYPE = 0x8454, + GL_FOG_COORDINATE_ARRAY_STRIDE = 0x8455, + GL_FOG_COORDINATE_ARRAY_STRIDE_EXT = 0x8455, + GL_FOG_COORD_ARRAY_STRIDE = 0x8455, + GL_FOG_COORDINATE_ARRAY_POINTER = 0x8456, + GL_FOG_COORDINATE_ARRAY_POINTER_EXT = 0x8456, + GL_FOG_COORD_ARRAY_POINTER = 0x8456, + GL_FOG_COORDINATE_ARRAY = 0x8457, + GL_FOG_COORDINATE_ARRAY_EXT = 0x8457, + GL_FOG_COORD_ARRAY = 0x8457, + GL_COLOR_SUM = 0x8458, + GL_COLOR_SUM_ARB = 0x8458, + GL_COLOR_SUM_EXT = 0x8458, + GL_CURRENT_SECONDARY_COLOR = 0x8459, + GL_CURRENT_SECONDARY_COLOR_EXT = 0x8459, + GL_SECONDARY_COLOR_ARRAY_SIZE = 0x845A, + GL_SECONDARY_COLOR_ARRAY_SIZE_EXT = 0x845A, + GL_SECONDARY_COLOR_ARRAY_TYPE = 0x845B, + GL_SECONDARY_COLOR_ARRAY_TYPE_EXT = 0x845B, + GL_SECONDARY_COLOR_ARRAY_STRIDE = 0x845C, + GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT = 0x845C, + GL_SECONDARY_COLOR_ARRAY_POINTER = 0x845D, + GL_SECONDARY_COLOR_ARRAY_POINTER_EXT = 0x845D, + GL_SECONDARY_COLOR_ARRAY = 0x845E, + GL_SECONDARY_COLOR_ARRAY_EXT = 0x845E, + GL_CURRENT_RASTER_SECONDARY_COLOR = 0x845F, + GL_ALIASED_POINT_SIZE_RANGE = 0x846D, + GL_ALIASED_LINE_WIDTH_RANGE = 0x846E, + GL_SCREEN_COORDINATES_REND = 0x8490, + GL_INVERTED_SCREEN_W_REND = 0x8491, + GL_TEXTURE0 = 0x84C0, + GL_TEXTURE0_ARB = 0x84C0, + GL_TEXTURE1 = 0x84C1, + GL_TEXTURE1_ARB = 0x84C1, + GL_TEXTURE2 = 0x84C2, + GL_TEXTURE2_ARB = 0x84C2, + GL_TEXTURE3 = 0x84C3, + GL_TEXTURE3_ARB = 0x84C3, + GL_TEXTURE4 = 0x84C4, + GL_TEXTURE4_ARB = 0x84C4, + GL_TEXTURE5 = 0x84C5, + GL_TEXTURE5_ARB = 0x84C5, + GL_TEXTURE6 = 0x84C6, + GL_TEXTURE6_ARB = 0x84C6, + GL_TEXTURE7 = 0x84C7, + GL_TEXTURE7_ARB = 0x84C7, + GL_TEXTURE8 = 0x84C8, + GL_TEXTURE8_ARB = 0x84C8, + GL_TEXTURE9 = 0x84C9, + GL_TEXTURE9_ARB = 0x84C9, + GL_TEXTURE10 = 0x84CA, + GL_TEXTURE10_ARB = 0x84CA, + GL_TEXTURE11 = 0x84CB, + GL_TEXTURE11_ARB = 0x84CB, + GL_TEXTURE12 = 0x84CC, + GL_TEXTURE12_ARB = 0x84CC, + GL_TEXTURE13 = 0x84CD, + GL_TEXTURE13_ARB = 0x84CD, + GL_TEXTURE14 = 0x84CE, + GL_TEXTURE14_ARB = 0x84CE, + GL_TEXTURE15 = 0x84CF, + GL_TEXTURE15_ARB = 0x84CF, + GL_TEXTURE16 = 0x84D0, + GL_TEXTURE16_ARB = 0x84D0, + GL_TEXTURE17 = 0x84D1, + GL_TEXTURE17_ARB = 0x84D1, + GL_TEXTURE18 = 0x84D2, + GL_TEXTURE18_ARB = 0x84D2, + GL_TEXTURE19 = 0x84D3, + GL_TEXTURE19_ARB = 0x84D3, + GL_TEXTURE20 = 0x84D4, + GL_TEXTURE20_ARB = 0x84D4, + GL_TEXTURE21 = 0x84D5, + GL_TEXTURE21_ARB = 0x84D5, + GL_TEXTURE22 = 0x84D6, + GL_TEXTURE22_ARB = 0x84D6, + GL_TEXTURE23 = 0x84D7, + GL_TEXTURE23_ARB = 0x84D7, + GL_TEXTURE24 = 0x84D8, + GL_TEXTURE24_ARB = 0x84D8, + GL_TEXTURE25 = 0x84D9, + GL_TEXTURE25_ARB = 0x84D9, + GL_TEXTURE26 = 0x84DA, + GL_TEXTURE26_ARB = 0x84DA, + GL_TEXTURE27 = 0x84DB, + GL_TEXTURE27_ARB = 0x84DB, + GL_TEXTURE28 = 0x84DC, + GL_TEXTURE28_ARB = 0x84DC, + GL_TEXTURE29 = 0x84DD, + GL_TEXTURE29_ARB = 0x84DD, + GL_TEXTURE30 = 0x84DE, + GL_TEXTURE30_ARB = 0x84DE, + GL_TEXTURE31 = 0x84DF, + GL_TEXTURE31_ARB = 0x84DF, + GL_ACTIVE_TEXTURE = 0x84E0, + GL_ACTIVE_TEXTURE_ARB = 0x84E0, + GL_CLIENT_ACTIVE_TEXTURE = 0x84E1, + GL_CLIENT_ACTIVE_TEXTURE_ARB = 0x84E1, + GL_MAX_TEXTURE_UNITS = 0x84E2, + GL_MAX_TEXTURE_UNITS_ARB = 0x84E2, + GL_TRANSPOSE_MODELVIEW_MATRIX = 0x84E3, + GL_TRANSPOSE_MODELVIEW_MATRIX_ARB = 0x84E3, + GL_PATH_TRANSPOSE_MODELVIEW_MATRIX_NV = 0x84E3, + GL_TRANSPOSE_PROJECTION_MATRIX = 0x84E4, + GL_TRANSPOSE_PROJECTION_MATRIX_ARB = 0x84E4, + GL_PATH_TRANSPOSE_PROJECTION_MATRIX_NV = 0x84E4, + GL_TRANSPOSE_TEXTURE_MATRIX = 0x84E5, + GL_TRANSPOSE_TEXTURE_MATRIX_ARB = 0x84E5, + GL_TRANSPOSE_COLOR_MATRIX = 0x84E6, + GL_TRANSPOSE_COLOR_MATRIX_ARB = 0x84E6, + GL_SUBTRACT = 0x84E7, + GL_SUBTRACT_ARB = 0x84E7, + GL_MAX_RENDERBUFFER_SIZE = 0x84E8, + GL_MAX_RENDERBUFFER_SIZE_EXT = 0x84E8, + GL_MAX_RENDERBUFFER_SIZE_OES = 0x84E8, + GL_COMPRESSED_ALPHA = 0x84E9, + GL_COMPRESSED_ALPHA_ARB = 0x84E9, + GL_COMPRESSED_LUMINANCE = 0x84EA, + GL_COMPRESSED_LUMINANCE_ARB = 0x84EA, + GL_COMPRESSED_LUMINANCE_ALPHA = 0x84EB, + GL_COMPRESSED_LUMINANCE_ALPHA_ARB = 0x84EB, + GL_COMPRESSED_INTENSITY = 0x84EC, + GL_COMPRESSED_INTENSITY_ARB = 0x84EC, + GL_COMPRESSED_RGB = 0x84ED, + GL_COMPRESSED_RGB_ARB = 0x84ED, + GL_COMPRESSED_RGBA = 0x84EE, + GL_COMPRESSED_RGBA_ARB = 0x84EE, + GL_TEXTURE_COMPRESSION_HINT = 0x84EF, + GL_TEXTURE_COMPRESSION_HINT_ARB = 0x84EF, + GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_CONTROL_SHADER = 0x84F0, + GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_EVALUATION_SHADER = 0x84F1, + GL_ALL_COMPLETED_NV = 0x84F2, + GL_FENCE_STATUS_NV = 0x84F3, + GL_FENCE_CONDITION_NV = 0x84F4, + GL_TEXTURE_RECTANGLE = 0x84F5, + GL_TEXTURE_RECTANGLE_ARB = 0x84F5, + GL_TEXTURE_RECTANGLE_NV = 0x84F5, + GL_TEXTURE_BINDING_RECTANGLE = 0x84F6, + GL_TEXTURE_BINDING_RECTANGLE_ARB = 0x84F6, + GL_TEXTURE_BINDING_RECTANGLE_NV = 0x84F6, + GL_PROXY_TEXTURE_RECTANGLE = 0x84F7, + GL_PROXY_TEXTURE_RECTANGLE_ARB = 0x84F7, + GL_PROXY_TEXTURE_RECTANGLE_NV = 0x84F7, + GL_MAX_RECTANGLE_TEXTURE_SIZE = 0x84F8, + GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB = 0x84F8, + GL_MAX_RECTANGLE_TEXTURE_SIZE_NV = 0x84F8, + GL_DEPTH_STENCIL = 0x84F9, + GL_DEPTH_STENCIL_EXT = 0x84F9, + GL_DEPTH_STENCIL_NV = 0x84F9, + GL_DEPTH_STENCIL_OES = 0x84F9, + GL_UNSIGNED_INT_24_8 = 0x84FA, + GL_UNSIGNED_INT_24_8_EXT = 0x84FA, + GL_UNSIGNED_INT_24_8_NV = 0x84FA, + GL_UNSIGNED_INT_24_8_OES = 0x84FA, + GL_MAX_TEXTURE_LOD_BIAS = 0x84FD, + GL_MAX_TEXTURE_LOD_BIAS_EXT = 0x84FD, + GL_TEXTURE_MAX_ANISOTROPY = 0x84FE, + GL_TEXTURE_MAX_ANISOTROPY_EXT = 0x84FE, + GL_MAX_TEXTURE_MAX_ANISOTROPY = 0x84FF, + GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT = 0x84FF, + GL_TEXTURE_FILTER_CONTROL = 0x8500, + GL_TEXTURE_FILTER_CONTROL_EXT = 0x8500, + GL_TEXTURE_LOD_BIAS = 0x8501, + GL_TEXTURE_LOD_BIAS_EXT = 0x8501, + GL_MODELVIEW1_STACK_DEPTH_EXT = 0x8502, + GL_COMBINE4_NV = 0x8503, + GL_MAX_SHININESS_NV = 0x8504, + GL_MAX_SPOT_EXPONENT_NV = 0x8505, + GL_MODELVIEW1_MATRIX_EXT = 0x8506, + GL_INCR_WRAP = 0x8507, + GL_INCR_WRAP_EXT = 0x8507, + GL_INCR_WRAP_OES = 0x8507, + GL_DECR_WRAP = 0x8508, + GL_DECR_WRAP_EXT = 0x8508, + GL_DECR_WRAP_OES = 0x8508, + GL_VERTEX_WEIGHTING_EXT = 0x8509, + GL_MODELVIEW1_ARB = 0x850A, + GL_MODELVIEW1_EXT = 0x850A, + GL_CURRENT_VERTEX_WEIGHT_EXT = 0x850B, + GL_VERTEX_WEIGHT_ARRAY_EXT = 0x850C, + GL_VERTEX_WEIGHT_ARRAY_SIZE_EXT = 0x850D, + GL_VERTEX_WEIGHT_ARRAY_TYPE_EXT = 0x850E, + GL_VERTEX_WEIGHT_ARRAY_STRIDE_EXT = 0x850F, + GL_VERTEX_WEIGHT_ARRAY_POINTER_EXT = 0x8510, + GL_NORMAL_MAP = 0x8511, + GL_NORMAL_MAP_ARB = 0x8511, + GL_NORMAL_MAP_EXT = 0x8511, + GL_NORMAL_MAP_NV = 0x8511, + GL_NORMAL_MAP_OES = 0x8511, + GL_REFLECTION_MAP = 0x8512, + GL_REFLECTION_MAP_ARB = 0x8512, + GL_REFLECTION_MAP_EXT = 0x8512, + GL_REFLECTION_MAP_NV = 0x8512, + GL_REFLECTION_MAP_OES = 0x8512, + GL_TEXTURE_CUBE_MAP = 0x8513, + GL_TEXTURE_CUBE_MAP_ARB = 0x8513, + GL_TEXTURE_CUBE_MAP_EXT = 0x8513, + GL_TEXTURE_CUBE_MAP_OES = 0x8513, + GL_TEXTURE_BINDING_CUBE_MAP = 0x8514, + GL_TEXTURE_BINDING_CUBE_MAP_ARB = 0x8514, + GL_TEXTURE_BINDING_CUBE_MAP_EXT = 0x8514, + GL_TEXTURE_BINDING_CUBE_MAP_OES = 0x8514, + GL_TEXTURE_CUBE_MAP_POSITIVE_X = 0x8515, + GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB = 0x8515, + GL_TEXTURE_CUBE_MAP_POSITIVE_X_EXT = 0x8515, + GL_TEXTURE_CUBE_MAP_POSITIVE_X_OES = 0x8515, + GL_TEXTURE_CUBE_MAP_NEGATIVE_X = 0x8516, + GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB = 0x8516, + GL_TEXTURE_CUBE_MAP_NEGATIVE_X_EXT = 0x8516, + GL_TEXTURE_CUBE_MAP_NEGATIVE_X_OES = 0x8516, + GL_TEXTURE_CUBE_MAP_POSITIVE_Y = 0x8517, + GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB = 0x8517, + GL_TEXTURE_CUBE_MAP_POSITIVE_Y_EXT = 0x8517, + GL_TEXTURE_CUBE_MAP_POSITIVE_Y_OES = 0x8517, + GL_TEXTURE_CUBE_MAP_NEGATIVE_Y = 0x8518, + GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB = 0x8518, + GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_EXT = 0x8518, + GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_OES = 0x8518, + GL_TEXTURE_CUBE_MAP_POSITIVE_Z = 0x8519, + GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB = 0x8519, + GL_TEXTURE_CUBE_MAP_POSITIVE_Z_EXT = 0x8519, + GL_TEXTURE_CUBE_MAP_POSITIVE_Z_OES = 0x8519, + GL_TEXTURE_CUBE_MAP_NEGATIVE_Z = 0x851A, + GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB = 0x851A, + GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_EXT = 0x851A, + GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_OES = 0x851A, + GL_PROXY_TEXTURE_CUBE_MAP = 0x851B, + GL_PROXY_TEXTURE_CUBE_MAP_ARB = 0x851B, + GL_PROXY_TEXTURE_CUBE_MAP_EXT = 0x851B, + GL_MAX_CUBE_MAP_TEXTURE_SIZE = 0x851C, + GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB = 0x851C, + GL_MAX_CUBE_MAP_TEXTURE_SIZE_EXT = 0x851C, + GL_MAX_CUBE_MAP_TEXTURE_SIZE_OES = 0x851C, + GL_VERTEX_ARRAY_RANGE_APPLE = 0x851D, + GL_VERTEX_ARRAY_RANGE_NV = 0x851D, + GL_VERTEX_ARRAY_RANGE_LENGTH_APPLE = 0x851E, + GL_VERTEX_ARRAY_RANGE_LENGTH_NV = 0x851E, + GL_VERTEX_ARRAY_RANGE_VALID_NV = 0x851F, + GL_VERTEX_ARRAY_STORAGE_HINT_APPLE = 0x851F, + GL_MAX_VERTEX_ARRAY_RANGE_ELEMENT_NV = 0x8520, + GL_VERTEX_ARRAY_RANGE_POINTER_APPLE = 0x8521, + GL_VERTEX_ARRAY_RANGE_POINTER_NV = 0x8521, + GL_REGISTER_COMBINERS_NV = 0x8522, + GL_VARIABLE_A_NV = 0x8523, + GL_VARIABLE_B_NV = 0x8524, + GL_VARIABLE_C_NV = 0x8525, + GL_VARIABLE_D_NV = 0x8526, + GL_VARIABLE_E_NV = 0x8527, + GL_VARIABLE_F_NV = 0x8528, + GL_VARIABLE_G_NV = 0x8529, + GL_CONSTANT_COLOR0_NV = 0x852A, + GL_CONSTANT_COLOR1_NV = 0x852B, + GL_PRIMARY_COLOR_NV = 0x852C, + GL_SECONDARY_COLOR_NV = 0x852D, + GL_SPARE0_NV = 0x852E, + GL_SPARE1_NV = 0x852F, + GL_DISCARD_NV = 0x8530, + GL_E_TIMES_F_NV = 0x8531, + GL_SPARE0_PLUS_SECONDARY_COLOR_NV = 0x8532, + GL_VERTEX_ARRAY_RANGE_WITHOUT_FLUSH_NV = 0x8533, + GL_MULTISAMPLE_FILTER_HINT_NV = 0x8534, + GL_PER_STAGE_CONSTANTS_NV = 0x8535, + GL_UNSIGNED_IDENTITY_NV = 0x8536, + GL_UNSIGNED_INVERT_NV = 0x8537, + GL_EXPAND_NORMAL_NV = 0x8538, + GL_EXPAND_NEGATE_NV = 0x8539, + GL_HALF_BIAS_NORMAL_NV = 0x853A, + GL_HALF_BIAS_NEGATE_NV = 0x853B, + GL_SIGNED_IDENTITY_NV = 0x853C, + GL_SIGNED_NEGATE_NV = 0x853D, + GL_SCALE_BY_TWO_NV = 0x853E, + GL_SCALE_BY_FOUR_NV = 0x853F, + GL_SCALE_BY_ONE_HALF_NV = 0x8540, + GL_BIAS_BY_NEGATIVE_ONE_HALF_NV = 0x8541, + GL_COMBINER_INPUT_NV = 0x8542, + GL_COMBINER_MAPPING_NV = 0x8543, + GL_COMBINER_COMPONENT_USAGE_NV = 0x8544, + GL_COMBINER_AB_DOT_PRODUCT_NV = 0x8545, + GL_COMBINER_CD_DOT_PRODUCT_NV = 0x8546, + GL_COMBINER_MUX_SUM_NV = 0x8547, + GL_COMBINER_SCALE_NV = 0x8548, + GL_COMBINER_BIAS_NV = 0x8549, + GL_COMBINER_AB_OUTPUT_NV = 0x854A, + GL_COMBINER_CD_OUTPUT_NV = 0x854B, + GL_COMBINER_SUM_OUTPUT_NV = 0x854C, + GL_MAX_GENERAL_COMBINERS_NV = 0x854D, + GL_NUM_GENERAL_COMBINERS_NV = 0x854E, + GL_COLOR_SUM_CLAMP_NV = 0x854F, + GL_COMBINER0_NV = 0x8550, + GL_COMBINER1_NV = 0x8551, + GL_COMBINER2_NV = 0x8552, + GL_COMBINER3_NV = 0x8553, + GL_COMBINER4_NV = 0x8554, + GL_COMBINER5_NV = 0x8555, + GL_COMBINER6_NV = 0x8556, + GL_COMBINER7_NV = 0x8557, + GL_PRIMITIVE_RESTART_NV = 0x8558, + GL_PRIMITIVE_RESTART_INDEX_NV = 0x8559, + GL_FOG_DISTANCE_MODE_NV = 0x855A, + GL_EYE_RADIAL_NV = 0x855B, + GL_EYE_PLANE_ABSOLUTE_NV = 0x855C, + GL_EMBOSS_LIGHT_NV = 0x855D, + GL_EMBOSS_CONSTANT_NV = 0x855E, + GL_EMBOSS_MAP_NV = 0x855F, + GL_RED_MIN_CLAMP_INGR = 0x8560, + GL_GREEN_MIN_CLAMP_INGR = 0x8561, + GL_BLUE_MIN_CLAMP_INGR = 0x8562, + GL_ALPHA_MIN_CLAMP_INGR = 0x8563, + GL_RED_MAX_CLAMP_INGR = 0x8564, + GL_GREEN_MAX_CLAMP_INGR = 0x8565, + GL_BLUE_MAX_CLAMP_INGR = 0x8566, + GL_ALPHA_MAX_CLAMP_INGR = 0x8567, + GL_INTERLACE_READ_INGR = 0x8568, + GL_PACK_SUBSAMPLE_RATE_SGIX = 0x85A0, + GL_UNPACK_SUBSAMPLE_RATE_SGIX = 0x85A1, + GL_PIXEL_SUBSAMPLE_4444_SGIX = 0x85A2, + GL_PIXEL_SUBSAMPLE_2424_SGIX = 0x85A3, + GL_PIXEL_SUBSAMPLE_4242_SGIX = 0x85A4, + GL_PERTURB_EXT = 0x85AE, + GL_TEXTURE_NORMAL_EXT = 0x85AF, + GL_LIGHT_MODEL_SPECULAR_VECTOR_APPLE = 0x85B0, + GL_TRANSFORM_HINT_APPLE = 0x85B1, + GL_UNPACK_CLIENT_STORAGE_APPLE = 0x85B2, + GL_BUFFER_OBJECT_APPLE = 0x85B3, + GL_STORAGE_CLIENT_APPLE = 0x85B4, + GL_VERTEX_ARRAY_BINDING = 0x85B5, + GL_VERTEX_ARRAY_BINDING_APPLE = 0x85B5, + GL_VERTEX_ARRAY_BINDING_OES = 0x85B5, + GL_TEXTURE_RANGE_LENGTH_APPLE = 0x85B7, + GL_TEXTURE_RANGE_POINTER_APPLE = 0x85B8, + GL_YCBCR_422_APPLE = 0x85B9, + GL_UNSIGNED_SHORT_8_8_APPLE = 0x85BA, + GL_UNSIGNED_SHORT_8_8_MESA = 0x85BA, + GL_UNSIGNED_SHORT_8_8_REV_APPLE = 0x85BB, + GL_UNSIGNED_SHORT_8_8_REV_MESA = 0x85BB, + GL_TEXTURE_STORAGE_HINT_APPLE = 0x85BC, + GL_STORAGE_PRIVATE_APPLE = 0x85BD, + GL_STORAGE_CACHED_APPLE = 0x85BE, + GL_STORAGE_SHARED_APPLE = 0x85BF, + GL_REPLACEMENT_CODE_ARRAY_SUN = 0x85C0, + GL_REPLACEMENT_CODE_ARRAY_TYPE_SUN = 0x85C1, + GL_REPLACEMENT_CODE_ARRAY_STRIDE_SUN = 0x85C2, + GL_REPLACEMENT_CODE_ARRAY_POINTER_SUN = 0x85C3, + GL_R1UI_V3F_SUN = 0x85C4, + GL_R1UI_C4UB_V3F_SUN = 0x85C5, + GL_R1UI_C3F_V3F_SUN = 0x85C6, + GL_R1UI_N3F_V3F_SUN = 0x85C7, + GL_R1UI_C4F_N3F_V3F_SUN = 0x85C8, + GL_R1UI_T2F_V3F_SUN = 0x85C9, + GL_R1UI_T2F_N3F_V3F_SUN = 0x85CA, + GL_R1UI_T2F_C4F_N3F_V3F_SUN = 0x85CB, + GL_SLICE_ACCUM_SUN = 0x85CC, + GL_QUAD_MESH_SUN = 0x8614, + GL_TRIANGLE_MESH_SUN = 0x8615, + GL_VERTEX_PROGRAM_ARB = 0x8620, + GL_VERTEX_PROGRAM_NV = 0x8620, + GL_VERTEX_STATE_PROGRAM_NV = 0x8621, + GL_VERTEX_ATTRIB_ARRAY_ENABLED = 0x8622, + GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB = 0x8622, + GL_ATTRIB_ARRAY_SIZE_NV = 0x8623, + GL_VERTEX_ATTRIB_ARRAY_SIZE = 0x8623, + GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB = 0x8623, + GL_ATTRIB_ARRAY_STRIDE_NV = 0x8624, + GL_VERTEX_ATTRIB_ARRAY_STRIDE = 0x8624, + GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB = 0x8624, + GL_ATTRIB_ARRAY_TYPE_NV = 0x8625, + GL_VERTEX_ATTRIB_ARRAY_TYPE = 0x8625, + GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB = 0x8625, + GL_CURRENT_ATTRIB_NV = 0x8626, + GL_CURRENT_VERTEX_ATTRIB = 0x8626, + GL_CURRENT_VERTEX_ATTRIB_ARB = 0x8626, + GL_PROGRAM_LENGTH_ARB = 0x8627, + GL_PROGRAM_LENGTH_NV = 0x8627, + GL_PROGRAM_STRING_ARB = 0x8628, + GL_PROGRAM_STRING_NV = 0x8628, + GL_MODELVIEW_PROJECTION_NV = 0x8629, + GL_IDENTITY_NV = 0x862A, + GL_INVERSE_NV = 0x862B, + GL_TRANSPOSE_NV = 0x862C, + GL_INVERSE_TRANSPOSE_NV = 0x862D, + GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB = 0x862E, + GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV = 0x862E, + GL_MAX_PROGRAM_MATRICES_ARB = 0x862F, + GL_MAX_TRACK_MATRICES_NV = 0x862F, + GL_MATRIX0_NV = 0x8630, + GL_MATRIX1_NV = 0x8631, + GL_MATRIX2_NV = 0x8632, + GL_MATRIX3_NV = 0x8633, + GL_MATRIX4_NV = 0x8634, + GL_MATRIX5_NV = 0x8635, + GL_MATRIX6_NV = 0x8636, + GL_MATRIX7_NV = 0x8637, + GL_CURRENT_MATRIX_STACK_DEPTH_ARB = 0x8640, + GL_CURRENT_MATRIX_STACK_DEPTH_NV = 0x8640, + GL_CURRENT_MATRIX_ARB = 0x8641, + GL_CURRENT_MATRIX_NV = 0x8641, + GL_VERTEX_PROGRAM_POINT_SIZE = 0x8642, + GL_VERTEX_PROGRAM_POINT_SIZE_ARB = 0x8642, + GL_VERTEX_PROGRAM_POINT_SIZE_NV = 0x8642, + GL_PROGRAM_POINT_SIZE = 0x8642, + GL_PROGRAM_POINT_SIZE_ARB = 0x8642, + GL_PROGRAM_POINT_SIZE_EXT = 0x8642, + GL_VERTEX_PROGRAM_TWO_SIDE = 0x8643, + GL_VERTEX_PROGRAM_TWO_SIDE_ARB = 0x8643, + GL_VERTEX_PROGRAM_TWO_SIDE_NV = 0x8643, + GL_PROGRAM_PARAMETER_NV = 0x8644, + GL_ATTRIB_ARRAY_POINTER_NV = 0x8645, + GL_VERTEX_ATTRIB_ARRAY_POINTER = 0x8645, + GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB = 0x8645, + GL_PROGRAM_TARGET_NV = 0x8646, + GL_PROGRAM_RESIDENT_NV = 0x8647, + GL_TRACK_MATRIX_NV = 0x8648, + GL_TRACK_MATRIX_TRANSFORM_NV = 0x8649, + GL_VERTEX_PROGRAM_BINDING_NV = 0x864A, + GL_PROGRAM_ERROR_POSITION_ARB = 0x864B, + GL_PROGRAM_ERROR_POSITION_NV = 0x864B, + GL_OFFSET_TEXTURE_RECTANGLE_NV = 0x864C, + GL_OFFSET_TEXTURE_RECTANGLE_SCALE_NV = 0x864D, + GL_DOT_PRODUCT_TEXTURE_RECTANGLE_NV = 0x864E, + GL_DEPTH_CLAMP = 0x864F, + GL_DEPTH_CLAMP_NV = 0x864F, + GL_DEPTH_CLAMP_EXT = 0x864F, + GL_VERTEX_ATTRIB_ARRAY0_NV = 0x8650, + GL_VERTEX_ATTRIB_ARRAY1_NV = 0x8651, + GL_VERTEX_ATTRIB_ARRAY2_NV = 0x8652, + GL_VERTEX_ATTRIB_ARRAY3_NV = 0x8653, + GL_VERTEX_ATTRIB_ARRAY4_NV = 0x8654, + GL_VERTEX_ATTRIB_ARRAY5_NV = 0x8655, + GL_VERTEX_ATTRIB_ARRAY6_NV = 0x8656, + GL_VERTEX_ATTRIB_ARRAY7_NV = 0x8657, + GL_VERTEX_ATTRIB_ARRAY8_NV = 0x8658, + GL_VERTEX_ATTRIB_ARRAY9_NV = 0x8659, + GL_VERTEX_ATTRIB_ARRAY10_NV = 0x865A, + GL_VERTEX_ATTRIB_ARRAY11_NV = 0x865B, + GL_VERTEX_ATTRIB_ARRAY12_NV = 0x865C, + GL_VERTEX_ATTRIB_ARRAY13_NV = 0x865D, + GL_VERTEX_ATTRIB_ARRAY14_NV = 0x865E, + GL_VERTEX_ATTRIB_ARRAY15_NV = 0x865F, + GL_MAP1_VERTEX_ATTRIB0_4_NV = 0x8660, + GL_MAP1_VERTEX_ATTRIB1_4_NV = 0x8661, + GL_MAP1_VERTEX_ATTRIB2_4_NV = 0x8662, + GL_MAP1_VERTEX_ATTRIB3_4_NV = 0x8663, + GL_MAP1_VERTEX_ATTRIB4_4_NV = 0x8664, + GL_MAP1_VERTEX_ATTRIB5_4_NV = 0x8665, + GL_MAP1_VERTEX_ATTRIB6_4_NV = 0x8666, + GL_MAP1_VERTEX_ATTRIB7_4_NV = 0x8667, + GL_MAP1_VERTEX_ATTRIB8_4_NV = 0x8668, + GL_MAP1_VERTEX_ATTRIB9_4_NV = 0x8669, + GL_MAP1_VERTEX_ATTRIB10_4_NV = 0x866A, + GL_MAP1_VERTEX_ATTRIB11_4_NV = 0x866B, + GL_MAP1_VERTEX_ATTRIB12_4_NV = 0x866C, + GL_MAP1_VERTEX_ATTRIB13_4_NV = 0x866D, + GL_MAP1_VERTEX_ATTRIB14_4_NV = 0x866E, + GL_MAP1_VERTEX_ATTRIB15_4_NV = 0x866F, + GL_MAP2_VERTEX_ATTRIB0_4_NV = 0x8670, + GL_MAP2_VERTEX_ATTRIB1_4_NV = 0x8671, + GL_MAP2_VERTEX_ATTRIB2_4_NV = 0x8672, + GL_MAP2_VERTEX_ATTRIB3_4_NV = 0x8673, + GL_MAP2_VERTEX_ATTRIB4_4_NV = 0x8674, + GL_MAP2_VERTEX_ATTRIB5_4_NV = 0x8675, + GL_MAP2_VERTEX_ATTRIB6_4_NV = 0x8676, + GL_MAP2_VERTEX_ATTRIB7_4_NV = 0x8677, + GL_PROGRAM_BINDING_ARB = 0x8677, + GL_MAP2_VERTEX_ATTRIB8_4_NV = 0x8678, + GL_MAP2_VERTEX_ATTRIB9_4_NV = 0x8679, + GL_MAP2_VERTEX_ATTRIB10_4_NV = 0x867A, + GL_MAP2_VERTEX_ATTRIB11_4_NV = 0x867B, + GL_MAP2_VERTEX_ATTRIB12_4_NV = 0x867C, + GL_MAP2_VERTEX_ATTRIB13_4_NV = 0x867D, + GL_MAP2_VERTEX_ATTRIB14_4_NV = 0x867E, + GL_MAP2_VERTEX_ATTRIB15_4_NV = 0x867F, + GL_TEXTURE_COMPRESSED_IMAGE_SIZE = 0x86A0, + GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB = 0x86A0, + GL_TEXTURE_COMPRESSED = 0x86A1, + GL_TEXTURE_COMPRESSED_ARB = 0x86A1, + GL_NUM_COMPRESSED_TEXTURE_FORMATS = 0x86A2, + GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB = 0x86A2, + GL_COMPRESSED_TEXTURE_FORMATS = 0x86A3, + GL_COMPRESSED_TEXTURE_FORMATS_ARB = 0x86A3, + GL_MAX_VERTEX_UNITS_ARB = 0x86A4, + GL_MAX_VERTEX_UNITS_OES = 0x86A4, + GL_ACTIVE_VERTEX_UNITS_ARB = 0x86A5, + GL_WEIGHT_SUM_UNITY_ARB = 0x86A6, + GL_VERTEX_BLEND_ARB = 0x86A7, + GL_CURRENT_WEIGHT_ARB = 0x86A8, + GL_WEIGHT_ARRAY_TYPE_ARB = 0x86A9, + GL_WEIGHT_ARRAY_TYPE_OES = 0x86A9, + GL_WEIGHT_ARRAY_STRIDE_ARB = 0x86AA, + GL_WEIGHT_ARRAY_STRIDE_OES = 0x86AA, + GL_WEIGHT_ARRAY_SIZE_ARB = 0x86AB, + GL_WEIGHT_ARRAY_SIZE_OES = 0x86AB, + GL_WEIGHT_ARRAY_POINTER_ARB = 0x86AC, + GL_WEIGHT_ARRAY_POINTER_OES = 0x86AC, + GL_WEIGHT_ARRAY_ARB = 0x86AD, + GL_WEIGHT_ARRAY_OES = 0x86AD, + GL_DOT3_RGB = 0x86AE, + GL_DOT3_RGB_ARB = 0x86AE, + GL_DOT3_RGBA = 0x86AF, + GL_DOT3_RGBA_ARB = 0x86AF, + GL_DOT3_RGBA_IMG = 0x86AF, + GL_COMPRESSED_RGB_FXT1_3DFX = 0x86B0, + GL_COMPRESSED_RGBA_FXT1_3DFX = 0x86B1, + GL_MULTISAMPLE_3DFX = 0x86B2, + GL_SAMPLE_BUFFERS_3DFX = 0x86B3, + GL_SAMPLES_3DFX = 0x86B4, + GL_EVAL_2D_NV = 0x86C0, + GL_EVAL_TRIANGULAR_2D_NV = 0x86C1, + GL_MAP_TESSELLATION_NV = 0x86C2, + GL_MAP_ATTRIB_U_ORDER_NV = 0x86C3, + GL_MAP_ATTRIB_V_ORDER_NV = 0x86C4, + GL_EVAL_FRACTIONAL_TESSELLATION_NV = 0x86C5, + GL_EVAL_VERTEX_ATTRIB0_NV = 0x86C6, + GL_EVAL_VERTEX_ATTRIB1_NV = 0x86C7, + GL_EVAL_VERTEX_ATTRIB2_NV = 0x86C8, + GL_EVAL_VERTEX_ATTRIB3_NV = 0x86C9, + GL_EVAL_VERTEX_ATTRIB4_NV = 0x86CA, + GL_EVAL_VERTEX_ATTRIB5_NV = 0x86CB, + GL_EVAL_VERTEX_ATTRIB6_NV = 0x86CC, + GL_EVAL_VERTEX_ATTRIB7_NV = 0x86CD, + GL_EVAL_VERTEX_ATTRIB8_NV = 0x86CE, + GL_EVAL_VERTEX_ATTRIB9_NV = 0x86CF, + GL_EVAL_VERTEX_ATTRIB10_NV = 0x86D0, + GL_EVAL_VERTEX_ATTRIB11_NV = 0x86D1, + GL_EVAL_VERTEX_ATTRIB12_NV = 0x86D2, + GL_EVAL_VERTEX_ATTRIB13_NV = 0x86D3, + GL_EVAL_VERTEX_ATTRIB14_NV = 0x86D4, + GL_EVAL_VERTEX_ATTRIB15_NV = 0x86D5, + GL_MAX_MAP_TESSELLATION_NV = 0x86D6, + GL_MAX_RATIONAL_EVAL_ORDER_NV = 0x86D7, + GL_MAX_PROGRAM_PATCH_ATTRIBS_NV = 0x86D8, + GL_RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV = 0x86D9, + GL_UNSIGNED_INT_S8_S8_8_8_NV = 0x86DA, + GL_UNSIGNED_INT_8_8_S8_S8_REV_NV = 0x86DB, + GL_DSDT_MAG_INTENSITY_NV = 0x86DC, + GL_SHADER_CONSISTENT_NV = 0x86DD, + GL_TEXTURE_SHADER_NV = 0x86DE, + GL_SHADER_OPERATION_NV = 0x86DF, + GL_CULL_MODES_NV = 0x86E0, + GL_OFFSET_TEXTURE_MATRIX_NV = 0x86E1, + GL_OFFSET_TEXTURE_2D_MATRIX_NV = 0x86E1, + GL_OFFSET_TEXTURE_SCALE_NV = 0x86E2, + GL_OFFSET_TEXTURE_2D_SCALE_NV = 0x86E2, + GL_OFFSET_TEXTURE_BIAS_NV = 0x86E3, + GL_OFFSET_TEXTURE_2D_BIAS_NV = 0x86E3, + GL_PREVIOUS_TEXTURE_INPUT_NV = 0x86E4, + GL_CONST_EYE_NV = 0x86E5, + GL_PASS_THROUGH_NV = 0x86E6, + GL_CULL_FRAGMENT_NV = 0x86E7, + GL_OFFSET_TEXTURE_2D_NV = 0x86E8, + GL_DEPENDENT_AR_TEXTURE_2D_NV = 0x86E9, + GL_DEPENDENT_GB_TEXTURE_2D_NV = 0x86EA, + GL_SURFACE_STATE_NV = 0x86EB, + GL_DOT_PRODUCT_NV = 0x86EC, + GL_DOT_PRODUCT_DEPTH_REPLACE_NV = 0x86ED, + GL_DOT_PRODUCT_TEXTURE_2D_NV = 0x86EE, + GL_DOT_PRODUCT_TEXTURE_3D_NV = 0x86EF, + GL_DOT_PRODUCT_TEXTURE_CUBE_MAP_NV = 0x86F0, + GL_DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV = 0x86F1, + GL_DOT_PRODUCT_REFLECT_CUBE_MAP_NV = 0x86F2, + GL_DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV = 0x86F3, + GL_HILO_NV = 0x86F4, + GL_DSDT_NV = 0x86F5, + GL_DSDT_MAG_NV = 0x86F6, + GL_DSDT_MAG_VIB_NV = 0x86F7, + GL_HILO16_NV = 0x86F8, + GL_SIGNED_HILO_NV = 0x86F9, + GL_SIGNED_HILO16_NV = 0x86FA, + GL_SIGNED_RGBA_NV = 0x86FB, + GL_SIGNED_RGBA8_NV = 0x86FC, + GL_SURFACE_REGISTERED_NV = 0x86FD, + GL_SIGNED_RGB_NV = 0x86FE, + GL_SIGNED_RGB8_NV = 0x86FF, + GL_SURFACE_MAPPED_NV = 0x8700, + GL_SIGNED_LUMINANCE_NV = 0x8701, + GL_SIGNED_LUMINANCE8_NV = 0x8702, + GL_SIGNED_LUMINANCE_ALPHA_NV = 0x8703, + GL_SIGNED_LUMINANCE8_ALPHA8_NV = 0x8704, + GL_SIGNED_ALPHA_NV = 0x8705, + GL_SIGNED_ALPHA8_NV = 0x8706, + GL_SIGNED_INTENSITY_NV = 0x8707, + GL_SIGNED_INTENSITY8_NV = 0x8708, + GL_DSDT8_NV = 0x8709, + GL_DSDT8_MAG8_NV = 0x870A, + GL_DSDT8_MAG8_INTENSITY8_NV = 0x870B, + GL_SIGNED_RGB_UNSIGNED_ALPHA_NV = 0x870C, + GL_SIGNED_RGB8_UNSIGNED_ALPHA8_NV = 0x870D, + GL_HI_SCALE_NV = 0x870E, + GL_LO_SCALE_NV = 0x870F, + GL_DS_SCALE_NV = 0x8710, + GL_DT_SCALE_NV = 0x8711, + GL_MAGNITUDE_SCALE_NV = 0x8712, + GL_VIBRANCE_SCALE_NV = 0x8713, + GL_HI_BIAS_NV = 0x8714, + GL_LO_BIAS_NV = 0x8715, + GL_DS_BIAS_NV = 0x8716, + GL_DT_BIAS_NV = 0x8717, + GL_MAGNITUDE_BIAS_NV = 0x8718, + GL_VIBRANCE_BIAS_NV = 0x8719, + GL_TEXTURE_BORDER_VALUES_NV = 0x871A, + GL_TEXTURE_HI_SIZE_NV = 0x871B, + GL_TEXTURE_LO_SIZE_NV = 0x871C, + GL_TEXTURE_DS_SIZE_NV = 0x871D, + GL_TEXTURE_DT_SIZE_NV = 0x871E, + GL_TEXTURE_MAG_SIZE_NV = 0x871F, + GL_MODELVIEW2_ARB = 0x8722, + GL_MODELVIEW3_ARB = 0x8723, + GL_MODELVIEW4_ARB = 0x8724, + GL_MODELVIEW5_ARB = 0x8725, + GL_MODELVIEW6_ARB = 0x8726, + GL_MODELVIEW7_ARB = 0x8727, + GL_MODELVIEW8_ARB = 0x8728, + GL_MODELVIEW9_ARB = 0x8729, + GL_MODELVIEW10_ARB = 0x872A, + GL_MODELVIEW11_ARB = 0x872B, + GL_MODELVIEW12_ARB = 0x872C, + GL_MODELVIEW13_ARB = 0x872D, + GL_MODELVIEW14_ARB = 0x872E, + GL_MODELVIEW15_ARB = 0x872F, + GL_MODELVIEW16_ARB = 0x8730, + GL_MODELVIEW17_ARB = 0x8731, + GL_MODELVIEW18_ARB = 0x8732, + GL_MODELVIEW19_ARB = 0x8733, + GL_MODELVIEW20_ARB = 0x8734, + GL_MODELVIEW21_ARB = 0x8735, + GL_MODELVIEW22_ARB = 0x8736, + GL_MODELVIEW23_ARB = 0x8737, + GL_MODELVIEW24_ARB = 0x8738, + GL_MODELVIEW25_ARB = 0x8739, + GL_MODELVIEW26_ARB = 0x873A, + GL_MODELVIEW27_ARB = 0x873B, + GL_MODELVIEW28_ARB = 0x873C, + GL_MODELVIEW29_ARB = 0x873D, + GL_MODELVIEW30_ARB = 0x873E, + GL_MODELVIEW31_ARB = 0x873F, + GL_DOT3_RGB_EXT = 0x8740, + GL_Z400_BINARY_AMD = 0x8740, + GL_DOT3_RGBA_EXT = 0x8741, + GL_PROGRAM_BINARY_LENGTH_OES = 0x8741, + GL_PROGRAM_BINARY_LENGTH = 0x8741, + GL_MIRROR_CLAMP_ATI = 0x8742, + GL_MIRROR_CLAMP_EXT = 0x8742, + GL_MIRROR_CLAMP_TO_EDGE = 0x8743, + GL_MIRROR_CLAMP_TO_EDGE_ATI = 0x8743, + GL_MIRROR_CLAMP_TO_EDGE_EXT = 0x8743, + GL_MODULATE_ADD_ATI = 0x8744, + GL_MODULATE_SIGNED_ADD_ATI = 0x8745, + GL_MODULATE_SUBTRACT_ATI = 0x8746, + GL_SET_AMD = 0x874A, + GL_REPLACE_VALUE_AMD = 0x874B, + GL_STENCIL_OP_VALUE_AMD = 0x874C, + GL_STENCIL_BACK_OP_VALUE_AMD = 0x874D, + GL_VERTEX_ATTRIB_ARRAY_LONG = 0x874E, + GL_OCCLUSION_QUERY_EVENT_MASK_AMD = 0x874F, + GL_DEPTH_STENCIL_MESA = 0x8750, + GL_UNSIGNED_INT_24_8_MESA = 0x8751, + GL_UNSIGNED_INT_8_24_REV_MESA = 0x8752, + GL_UNSIGNED_SHORT_15_1_MESA = 0x8753, + GL_UNSIGNED_SHORT_1_15_REV_MESA = 0x8754, + GL_TRACE_MASK_MESA = 0x8755, + GL_TRACE_NAME_MESA = 0x8756, + GL_YCBCR_MESA = 0x8757, + GL_PACK_INVERT_MESA = 0x8758, + GL_DEBUG_OBJECT_MESA = 0x8759, + GL_TEXTURE_1D_STACK_MESAX = 0x8759, + GL_DEBUG_PRINT_MESA = 0x875A, + GL_TEXTURE_2D_STACK_MESAX = 0x875A, + GL_DEBUG_ASSERT_MESA = 0x875B, + GL_PROXY_TEXTURE_1D_STACK_MESAX = 0x875B, + GL_PROXY_TEXTURE_2D_STACK_MESAX = 0x875C, + GL_TEXTURE_1D_STACK_BINDING_MESAX = 0x875D, + GL_TEXTURE_2D_STACK_BINDING_MESAX = 0x875E, + GL_PROGRAM_BINARY_FORMAT_MESA = 0x875F, + GL_STATIC_ATI = 0x8760, + GL_DYNAMIC_ATI = 0x8761, + GL_PRESERVE_ATI = 0x8762, + GL_DISCARD_ATI = 0x8763, + GL_BUFFER_SIZE = 0x8764, + GL_BUFFER_SIZE_ARB = 0x8764, + GL_OBJECT_BUFFER_SIZE_ATI = 0x8764, + GL_BUFFER_USAGE = 0x8765, + GL_BUFFER_USAGE_ARB = 0x8765, + GL_OBJECT_BUFFER_USAGE_ATI = 0x8765, + GL_ARRAY_OBJECT_BUFFER_ATI = 0x8766, + GL_ARRAY_OBJECT_OFFSET_ATI = 0x8767, + GL_ELEMENT_ARRAY_ATI = 0x8768, + GL_ELEMENT_ARRAY_TYPE_ATI = 0x8769, + GL_ELEMENT_ARRAY_POINTER_ATI = 0x876A, + GL_MAX_VERTEX_STREAMS_ATI = 0x876B, + GL_VERTEX_STREAM0_ATI = 0x876C, + GL_VERTEX_STREAM1_ATI = 0x876D, + GL_VERTEX_STREAM2_ATI = 0x876E, + GL_VERTEX_STREAM3_ATI = 0x876F, + GL_VERTEX_STREAM4_ATI = 0x8770, + GL_VERTEX_STREAM5_ATI = 0x8771, + GL_VERTEX_STREAM6_ATI = 0x8772, + GL_VERTEX_STREAM7_ATI = 0x8773, + GL_VERTEX_SOURCE_ATI = 0x8774, + GL_BUMP_ROT_MATRIX_ATI = 0x8775, + GL_BUMP_ROT_MATRIX_SIZE_ATI = 0x8776, + GL_BUMP_NUM_TEX_UNITS_ATI = 0x8777, + GL_BUMP_TEX_UNITS_ATI = 0x8778, + GL_DUDV_ATI = 0x8779, + GL_DU8DV8_ATI = 0x877A, + GL_BUMP_ENVMAP_ATI = 0x877B, + GL_BUMP_TARGET_ATI = 0x877C, + GL_VERTEX_SHADER_EXT = 0x8780, + GL_VERTEX_SHADER_BINDING_EXT = 0x8781, + GL_OP_INDEX_EXT = 0x8782, + GL_OP_NEGATE_EXT = 0x8783, + GL_OP_DOT3_EXT = 0x8784, + GL_OP_DOT4_EXT = 0x8785, + GL_OP_MUL_EXT = 0x8786, + GL_OP_ADD_EXT = 0x8787, + GL_OP_MADD_EXT = 0x8788, + GL_OP_FRAC_EXT = 0x8789, + GL_OP_MAX_EXT = 0x878A, + GL_OP_MIN_EXT = 0x878B, + GL_OP_SET_GE_EXT = 0x878C, + GL_OP_SET_LT_EXT = 0x878D, + GL_OP_CLAMP_EXT = 0x878E, + GL_OP_FLOOR_EXT = 0x878F, + GL_OP_ROUND_EXT = 0x8790, + GL_OP_EXP_BASE_2_EXT = 0x8791, + GL_OP_LOG_BASE_2_EXT = 0x8792, + GL_OP_POWER_EXT = 0x8793, + GL_OP_RECIP_EXT = 0x8794, + GL_OP_RECIP_SQRT_EXT = 0x8795, + GL_OP_SUB_EXT = 0x8796, + GL_OP_CROSS_PRODUCT_EXT = 0x8797, + GL_OP_MULTIPLY_MATRIX_EXT = 0x8798, + GL_OP_MOV_EXT = 0x8799, + GL_OUTPUT_VERTEX_EXT = 0x879A, + GL_OUTPUT_COLOR0_EXT = 0x879B, + GL_OUTPUT_COLOR1_EXT = 0x879C, + GL_OUTPUT_TEXTURE_COORD0_EXT = 0x879D, + GL_OUTPUT_TEXTURE_COORD1_EXT = 0x879E, + GL_OUTPUT_TEXTURE_COORD2_EXT = 0x879F, + GL_OUTPUT_TEXTURE_COORD3_EXT = 0x87A0, + GL_OUTPUT_TEXTURE_COORD4_EXT = 0x87A1, + GL_OUTPUT_TEXTURE_COORD5_EXT = 0x87A2, + GL_OUTPUT_TEXTURE_COORD6_EXT = 0x87A3, + GL_OUTPUT_TEXTURE_COORD7_EXT = 0x87A4, + GL_OUTPUT_TEXTURE_COORD8_EXT = 0x87A5, + GL_OUTPUT_TEXTURE_COORD9_EXT = 0x87A6, + GL_OUTPUT_TEXTURE_COORD10_EXT = 0x87A7, + GL_OUTPUT_TEXTURE_COORD11_EXT = 0x87A8, + GL_OUTPUT_TEXTURE_COORD12_EXT = 0x87A9, + GL_OUTPUT_TEXTURE_COORD13_EXT = 0x87AA, + GL_OUTPUT_TEXTURE_COORD14_EXT = 0x87AB, + GL_OUTPUT_TEXTURE_COORD15_EXT = 0x87AC, + GL_OUTPUT_TEXTURE_COORD16_EXT = 0x87AD, + GL_OUTPUT_TEXTURE_COORD17_EXT = 0x87AE, + GL_OUTPUT_TEXTURE_COORD18_EXT = 0x87AF, + GL_OUTPUT_TEXTURE_COORD19_EXT = 0x87B0, + GL_OUTPUT_TEXTURE_COORD20_EXT = 0x87B1, + GL_OUTPUT_TEXTURE_COORD21_EXT = 0x87B2, + GL_OUTPUT_TEXTURE_COORD22_EXT = 0x87B3, + GL_OUTPUT_TEXTURE_COORD23_EXT = 0x87B4, + GL_OUTPUT_TEXTURE_COORD24_EXT = 0x87B5, + GL_OUTPUT_TEXTURE_COORD25_EXT = 0x87B6, + GL_OUTPUT_TEXTURE_COORD26_EXT = 0x87B7, + GL_OUTPUT_TEXTURE_COORD27_EXT = 0x87B8, + GL_OUTPUT_TEXTURE_COORD28_EXT = 0x87B9, + GL_OUTPUT_TEXTURE_COORD29_EXT = 0x87BA, + GL_OUTPUT_TEXTURE_COORD30_EXT = 0x87BB, + GL_OUTPUT_TEXTURE_COORD31_EXT = 0x87BC, + GL_OUTPUT_FOG_EXT = 0x87BD, + GL_SCALAR_EXT = 0x87BE, + GL_VECTOR_EXT = 0x87BF, + GL_MATRIX_EXT = 0x87C0, + GL_VARIANT_EXT = 0x87C1, + GL_INVARIANT_EXT = 0x87C2, + GL_LOCAL_CONSTANT_EXT = 0x87C3, + GL_LOCAL_EXT = 0x87C4, + GL_MAX_VERTEX_SHADER_INSTRUCTIONS_EXT = 0x87C5, + GL_MAX_VERTEX_SHADER_VARIANTS_EXT = 0x87C6, + GL_MAX_VERTEX_SHADER_INVARIANTS_EXT = 0x87C7, + GL_MAX_VERTEX_SHADER_LOCAL_CONSTANTS_EXT = 0x87C8, + GL_MAX_VERTEX_SHADER_LOCALS_EXT = 0x87C9, + GL_MAX_OPTIMIZED_VERTEX_SHADER_INSTRUCTIONS_EXT = 0x87CA, + GL_MAX_OPTIMIZED_VERTEX_SHADER_VARIANTS_EXT = 0x87CB, + GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCAL_CONSTANTS_EXT = 0x87CC, + GL_MAX_OPTIMIZED_VERTEX_SHADER_INVARIANTS_EXT = 0x87CD, + GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCALS_EXT = 0x87CE, + GL_VERTEX_SHADER_INSTRUCTIONS_EXT = 0x87CF, + GL_VERTEX_SHADER_VARIANTS_EXT = 0x87D0, + GL_VERTEX_SHADER_INVARIANTS_EXT = 0x87D1, + GL_VERTEX_SHADER_LOCAL_CONSTANTS_EXT = 0x87D2, + GL_VERTEX_SHADER_LOCALS_EXT = 0x87D3, + GL_VERTEX_SHADER_OPTIMIZED_EXT = 0x87D4, + GL_X_EXT = 0x87D5, + GL_Y_EXT = 0x87D6, + GL_Z_EXT = 0x87D7, + GL_W_EXT = 0x87D8, + GL_NEGATIVE_X_EXT = 0x87D9, + GL_NEGATIVE_Y_EXT = 0x87DA, + GL_NEGATIVE_Z_EXT = 0x87DB, + GL_NEGATIVE_W_EXT = 0x87DC, + GL_ZERO_EXT = 0x87DD, + GL_ONE_EXT = 0x87DE, + GL_NEGATIVE_ONE_EXT = 0x87DF, + GL_NORMALIZED_RANGE_EXT = 0x87E0, + GL_FULL_RANGE_EXT = 0x87E1, + GL_CURRENT_VERTEX_EXT = 0x87E2, + GL_MVP_MATRIX_EXT = 0x87E3, + GL_VARIANT_VALUE_EXT = 0x87E4, + GL_VARIANT_DATATYPE_EXT = 0x87E5, + GL_VARIANT_ARRAY_STRIDE_EXT = 0x87E6, + GL_VARIANT_ARRAY_TYPE_EXT = 0x87E7, + GL_VARIANT_ARRAY_EXT = 0x87E8, + GL_VARIANT_ARRAY_POINTER_EXT = 0x87E9, + GL_INVARIANT_VALUE_EXT = 0x87EA, + GL_INVARIANT_DATATYPE_EXT = 0x87EB, + GL_LOCAL_CONSTANT_VALUE_EXT = 0x87EC, + GL_LOCAL_CONSTANT_DATATYPE_EXT = 0x87ED, + GL_ATC_RGBA_INTERPOLATED_ALPHA_AMD = 0x87EE, + GL_PN_TRIANGLES_ATI = 0x87F0, + GL_MAX_PN_TRIANGLES_TESSELATION_LEVEL_ATI = 0x87F1, + GL_PN_TRIANGLES_POINT_MODE_ATI = 0x87F2, + GL_PN_TRIANGLES_NORMAL_MODE_ATI = 0x87F3, + GL_PN_TRIANGLES_TESSELATION_LEVEL_ATI = 0x87F4, + GL_PN_TRIANGLES_POINT_MODE_LINEAR_ATI = 0x87F5, + GL_PN_TRIANGLES_POINT_MODE_CUBIC_ATI = 0x87F6, + GL_PN_TRIANGLES_NORMAL_MODE_LINEAR_ATI = 0x87F7, + GL_PN_TRIANGLES_NORMAL_MODE_QUADRATIC_ATI = 0x87F8, + GL_3DC_X_AMD = 0x87F9, + GL_3DC_XY_AMD = 0x87FA, + GL_VBO_FREE_MEMORY_ATI = 0x87FB, + GL_TEXTURE_FREE_MEMORY_ATI = 0x87FC, + GL_RENDERBUFFER_FREE_MEMORY_ATI = 0x87FD, + GL_NUM_PROGRAM_BINARY_FORMATS = 0x87FE, + GL_NUM_PROGRAM_BINARY_FORMATS_OES = 0x87FE, + GL_PROGRAM_BINARY_FORMATS = 0x87FF, + GL_PROGRAM_BINARY_FORMATS_OES = 0x87FF, + GL_STENCIL_BACK_FUNC = 0x8800, + GL_STENCIL_BACK_FUNC_ATI = 0x8800, + GL_STENCIL_BACK_FAIL = 0x8801, + GL_STENCIL_BACK_FAIL_ATI = 0x8801, + GL_STENCIL_BACK_PASS_DEPTH_FAIL = 0x8802, + GL_STENCIL_BACK_PASS_DEPTH_FAIL_ATI = 0x8802, + GL_STENCIL_BACK_PASS_DEPTH_PASS = 0x8803, + GL_STENCIL_BACK_PASS_DEPTH_PASS_ATI = 0x8803, + GL_FRAGMENT_PROGRAM_ARB = 0x8804, + GL_PROGRAM_ALU_INSTRUCTIONS_ARB = 0x8805, + GL_PROGRAM_TEX_INSTRUCTIONS_ARB = 0x8806, + GL_PROGRAM_TEX_INDIRECTIONS_ARB = 0x8807, + GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB = 0x8808, + GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB = 0x8809, + GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB = 0x880A, + GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB = 0x880B, + GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB = 0x880C, + GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB = 0x880D, + GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB = 0x880E, + GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB = 0x880F, + GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB = 0x8810, + GL_RGBA32F = 0x8814, + GL_RGBA32F_ARB = 0x8814, + GL_RGBA32F_EXT = 0x8814, + GL_RGBA_FLOAT32_APPLE = 0x8814, + GL_RGBA_FLOAT32_ATI = 0x8814, + GL_RGB32F = 0x8815, + GL_RGB32F_ARB = 0x8815, + GL_RGB32F_EXT = 0x8815, + GL_RGB_FLOAT32_APPLE = 0x8815, + GL_RGB_FLOAT32_ATI = 0x8815, + GL_ALPHA32F_ARB = 0x8816, + GL_ALPHA32F_EXT = 0x8816, + GL_ALPHA_FLOAT32_APPLE = 0x8816, + GL_ALPHA_FLOAT32_ATI = 0x8816, + GL_INTENSITY32F_ARB = 0x8817, + GL_INTENSITY_FLOAT32_APPLE = 0x8817, + GL_INTENSITY_FLOAT32_ATI = 0x8817, + GL_LUMINANCE32F_ARB = 0x8818, + GL_LUMINANCE32F_EXT = 0x8818, + GL_LUMINANCE_FLOAT32_APPLE = 0x8818, + GL_LUMINANCE_FLOAT32_ATI = 0x8818, + GL_LUMINANCE_ALPHA32F_ARB = 0x8819, + GL_LUMINANCE_ALPHA32F_EXT = 0x8819, + GL_LUMINANCE_ALPHA_FLOAT32_APPLE = 0x8819, + GL_LUMINANCE_ALPHA_FLOAT32_ATI = 0x8819, + GL_RGBA16F = 0x881A, + GL_RGBA16F_ARB = 0x881A, + GL_RGBA16F_EXT = 0x881A, + GL_RGBA_FLOAT16_APPLE = 0x881A, + GL_RGBA_FLOAT16_ATI = 0x881A, + GL_RGB16F = 0x881B, + GL_RGB16F_ARB = 0x881B, + GL_RGB16F_EXT = 0x881B, + GL_RGB_FLOAT16_APPLE = 0x881B, + GL_RGB_FLOAT16_ATI = 0x881B, + GL_ALPHA16F_ARB = 0x881C, + GL_ALPHA16F_EXT = 0x881C, + GL_ALPHA_FLOAT16_APPLE = 0x881C, + GL_ALPHA_FLOAT16_ATI = 0x881C, + GL_INTENSITY16F_ARB = 0x881D, + GL_INTENSITY_FLOAT16_APPLE = 0x881D, + GL_INTENSITY_FLOAT16_ATI = 0x881D, + GL_LUMINANCE16F_ARB = 0x881E, + GL_LUMINANCE16F_EXT = 0x881E, + GL_LUMINANCE_FLOAT16_APPLE = 0x881E, + GL_LUMINANCE_FLOAT16_ATI = 0x881E, + GL_LUMINANCE_ALPHA16F_ARB = 0x881F, + GL_LUMINANCE_ALPHA16F_EXT = 0x881F, + GL_LUMINANCE_ALPHA_FLOAT16_APPLE = 0x881F, + GL_LUMINANCE_ALPHA_FLOAT16_ATI = 0x881F, + GL_RGBA_FLOAT_MODE_ARB = 0x8820, + GL_RGBA_FLOAT_MODE_ATI = 0x8820, + GL_WRITEONLY_RENDERING_QCOM = 0x8823, + GL_MAX_DRAW_BUFFERS = 0x8824, + GL_MAX_DRAW_BUFFERS_ARB = 0x8824, + GL_MAX_DRAW_BUFFERS_ATI = 0x8824, + GL_MAX_DRAW_BUFFERS_EXT = 0x8824, + GL_MAX_DRAW_BUFFERS_NV = 0x8824, + GL_DRAW_BUFFER0 = 0x8825, + GL_DRAW_BUFFER0_ARB = 0x8825, + GL_DRAW_BUFFER0_ATI = 0x8825, + GL_DRAW_BUFFER0_EXT = 0x8825, + GL_DRAW_BUFFER0_NV = 0x8825, + GL_DRAW_BUFFER1 = 0x8826, + GL_DRAW_BUFFER1_ARB = 0x8826, + GL_DRAW_BUFFER1_ATI = 0x8826, + GL_DRAW_BUFFER1_EXT = 0x8826, + GL_DRAW_BUFFER1_NV = 0x8826, + GL_DRAW_BUFFER2 = 0x8827, + GL_DRAW_BUFFER2_ARB = 0x8827, + GL_DRAW_BUFFER2_ATI = 0x8827, + GL_DRAW_BUFFER2_EXT = 0x8827, + GL_DRAW_BUFFER2_NV = 0x8827, + GL_DRAW_BUFFER3 = 0x8828, + GL_DRAW_BUFFER3_ARB = 0x8828, + GL_DRAW_BUFFER3_ATI = 0x8828, + GL_DRAW_BUFFER3_EXT = 0x8828, + GL_DRAW_BUFFER3_NV = 0x8828, + GL_DRAW_BUFFER4 = 0x8829, + GL_DRAW_BUFFER4_ARB = 0x8829, + GL_DRAW_BUFFER4_ATI = 0x8829, + GL_DRAW_BUFFER4_EXT = 0x8829, + GL_DRAW_BUFFER4_NV = 0x8829, + GL_DRAW_BUFFER5 = 0x882A, + GL_DRAW_BUFFER5_ARB = 0x882A, + GL_DRAW_BUFFER5_ATI = 0x882A, + GL_DRAW_BUFFER5_EXT = 0x882A, + GL_DRAW_BUFFER5_NV = 0x882A, + GL_DRAW_BUFFER6 = 0x882B, + GL_DRAW_BUFFER6_ARB = 0x882B, + GL_DRAW_BUFFER6_ATI = 0x882B, + GL_DRAW_BUFFER6_EXT = 0x882B, + GL_DRAW_BUFFER6_NV = 0x882B, + GL_DRAW_BUFFER7 = 0x882C, + GL_DRAW_BUFFER7_ARB = 0x882C, + GL_DRAW_BUFFER7_ATI = 0x882C, + GL_DRAW_BUFFER7_EXT = 0x882C, + GL_DRAW_BUFFER7_NV = 0x882C, + GL_DRAW_BUFFER8 = 0x882D, + GL_DRAW_BUFFER8_ARB = 0x882D, + GL_DRAW_BUFFER8_ATI = 0x882D, + GL_DRAW_BUFFER8_EXT = 0x882D, + GL_DRAW_BUFFER8_NV = 0x882D, + GL_DRAW_BUFFER9 = 0x882E, + GL_DRAW_BUFFER9_ARB = 0x882E, + GL_DRAW_BUFFER9_ATI = 0x882E, + GL_DRAW_BUFFER9_EXT = 0x882E, + GL_DRAW_BUFFER9_NV = 0x882E, + GL_DRAW_BUFFER10 = 0x882F, + GL_DRAW_BUFFER10_ARB = 0x882F, + GL_DRAW_BUFFER10_ATI = 0x882F, + GL_DRAW_BUFFER10_EXT = 0x882F, + GL_DRAW_BUFFER10_NV = 0x882F, + GL_DRAW_BUFFER11 = 0x8830, + GL_DRAW_BUFFER11_ARB = 0x8830, + GL_DRAW_BUFFER11_ATI = 0x8830, + GL_DRAW_BUFFER11_EXT = 0x8830, + GL_DRAW_BUFFER11_NV = 0x8830, + GL_DRAW_BUFFER12 = 0x8831, + GL_DRAW_BUFFER12_ARB = 0x8831, + GL_DRAW_BUFFER12_ATI = 0x8831, + GL_DRAW_BUFFER12_EXT = 0x8831, + GL_DRAW_BUFFER12_NV = 0x8831, + GL_DRAW_BUFFER13 = 0x8832, + GL_DRAW_BUFFER13_ARB = 0x8832, + GL_DRAW_BUFFER13_ATI = 0x8832, + GL_DRAW_BUFFER13_EXT = 0x8832, + GL_DRAW_BUFFER13_NV = 0x8832, + GL_DRAW_BUFFER14 = 0x8833, + GL_DRAW_BUFFER14_ARB = 0x8833, + GL_DRAW_BUFFER14_ATI = 0x8833, + GL_DRAW_BUFFER14_EXT = 0x8833, + GL_DRAW_BUFFER14_NV = 0x8833, + GL_DRAW_BUFFER15 = 0x8834, + GL_DRAW_BUFFER15_ARB = 0x8834, + GL_DRAW_BUFFER15_ATI = 0x8834, + GL_DRAW_BUFFER15_EXT = 0x8834, + GL_DRAW_BUFFER15_NV = 0x8834, + GL_COLOR_CLEAR_UNCLAMPED_VALUE_ATI = 0x8835, + GL_COMPRESSED_LUMINANCE_ALPHA_3DC_ATI = 0x8837, + GL_BLEND_EQUATION_ALPHA = 0x883D, + GL_BLEND_EQUATION_ALPHA_EXT = 0x883D, + GL_BLEND_EQUATION_ALPHA_OES = 0x883D, + GL_SUBSAMPLE_DISTANCE_AMD = 0x883F, + GL_MATRIX_PALETTE_ARB = 0x8840, + GL_MATRIX_PALETTE_OES = 0x8840, + GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB = 0x8841, + GL_MAX_PALETTE_MATRICES_ARB = 0x8842, + GL_MAX_PALETTE_MATRICES_OES = 0x8842, + GL_CURRENT_PALETTE_MATRIX_ARB = 0x8843, + GL_CURRENT_PALETTE_MATRIX_OES = 0x8843, + GL_MATRIX_INDEX_ARRAY_ARB = 0x8844, + GL_MATRIX_INDEX_ARRAY_OES = 0x8844, + GL_CURRENT_MATRIX_INDEX_ARB = 0x8845, + GL_MATRIX_INDEX_ARRAY_SIZE_ARB = 0x8846, + GL_MATRIX_INDEX_ARRAY_SIZE_OES = 0x8846, + GL_MATRIX_INDEX_ARRAY_TYPE_ARB = 0x8847, + GL_MATRIX_INDEX_ARRAY_TYPE_OES = 0x8847, + GL_MATRIX_INDEX_ARRAY_STRIDE_ARB = 0x8848, + GL_MATRIX_INDEX_ARRAY_STRIDE_OES = 0x8848, + GL_MATRIX_INDEX_ARRAY_POINTER_ARB = 0x8849, + GL_MATRIX_INDEX_ARRAY_POINTER_OES = 0x8849, + GL_TEXTURE_DEPTH_SIZE = 0x884A, + GL_TEXTURE_DEPTH_SIZE_ARB = 0x884A, + GL_DEPTH_TEXTURE_MODE = 0x884B, + GL_DEPTH_TEXTURE_MODE_ARB = 0x884B, + GL_TEXTURE_COMPARE_MODE = 0x884C, + GL_TEXTURE_COMPARE_MODE_ARB = 0x884C, + GL_TEXTURE_COMPARE_MODE_EXT = 0x884C, + GL_TEXTURE_COMPARE_FUNC = 0x884D, + GL_TEXTURE_COMPARE_FUNC_ARB = 0x884D, + GL_TEXTURE_COMPARE_FUNC_EXT = 0x884D, + GL_COMPARE_R_TO_TEXTURE = 0x884E, + GL_COMPARE_R_TO_TEXTURE_ARB = 0x884E, + GL_COMPARE_REF_DEPTH_TO_TEXTURE_EXT = 0x884E, + GL_COMPARE_REF_TO_TEXTURE = 0x884E, + GL_COMPARE_REF_TO_TEXTURE_EXT = 0x884E, + GL_TEXTURE_CUBE_MAP_SEAMLESS = 0x884F, + GL_OFFSET_PROJECTIVE_TEXTURE_2D_NV = 0x8850, + GL_OFFSET_PROJECTIVE_TEXTURE_2D_SCALE_NV = 0x8851, + GL_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_NV = 0x8852, + GL_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_SCALE_NV = 0x8853, + GL_OFFSET_HILO_TEXTURE_2D_NV = 0x8854, + GL_OFFSET_HILO_TEXTURE_RECTANGLE_NV = 0x8855, + GL_OFFSET_HILO_PROJECTIVE_TEXTURE_2D_NV = 0x8856, + GL_OFFSET_HILO_PROJECTIVE_TEXTURE_RECTANGLE_NV = 0x8857, + GL_DEPENDENT_HILO_TEXTURE_2D_NV = 0x8858, + GL_DEPENDENT_RGB_TEXTURE_3D_NV = 0x8859, + GL_DEPENDENT_RGB_TEXTURE_CUBE_MAP_NV = 0x885A, + GL_DOT_PRODUCT_PASS_THROUGH_NV = 0x885B, + GL_DOT_PRODUCT_TEXTURE_1D_NV = 0x885C, + GL_DOT_PRODUCT_AFFINE_DEPTH_REPLACE_NV = 0x885D, + GL_HILO8_NV = 0x885E, + GL_SIGNED_HILO8_NV = 0x885F, + GL_FORCE_BLUE_TO_ONE_NV = 0x8860, + GL_POINT_SPRITE = 0x8861, + GL_POINT_SPRITE_ARB = 0x8861, + GL_POINT_SPRITE_NV = 0x8861, + GL_POINT_SPRITE_OES = 0x8861, + GL_COORD_REPLACE = 0x8862, + GL_COORD_REPLACE_ARB = 0x8862, + GL_COORD_REPLACE_NV = 0x8862, + GL_COORD_REPLACE_OES = 0x8862, + GL_POINT_SPRITE_R_MODE_NV = 0x8863, + GL_PIXEL_COUNTER_BITS_NV = 0x8864, + GL_QUERY_COUNTER_BITS = 0x8864, + GL_QUERY_COUNTER_BITS_ARB = 0x8864, + GL_QUERY_COUNTER_BITS_EXT = 0x8864, + GL_CURRENT_OCCLUSION_QUERY_ID_NV = 0x8865, + GL_CURRENT_QUERY = 0x8865, + GL_CURRENT_QUERY_ARB = 0x8865, + GL_CURRENT_QUERY_EXT = 0x8865, + GL_PIXEL_COUNT_NV = 0x8866, + GL_QUERY_RESULT = 0x8866, + GL_QUERY_RESULT_ARB = 0x8866, + GL_QUERY_RESULT_EXT = 0x8866, + GL_PIXEL_COUNT_AVAILABLE_NV = 0x8867, + GL_QUERY_RESULT_AVAILABLE = 0x8867, + GL_QUERY_RESULT_AVAILABLE_ARB = 0x8867, + GL_QUERY_RESULT_AVAILABLE_EXT = 0x8867, + GL_MAX_FRAGMENT_PROGRAM_LOCAL_PARAMETERS_NV = 0x8868, + GL_MAX_VERTEX_ATTRIBS = 0x8869, + GL_MAX_VERTEX_ATTRIBS_ARB = 0x8869, + GL_VERTEX_ATTRIB_ARRAY_NORMALIZED = 0x886A, + GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB = 0x886A, + GL_MAX_TESS_CONTROL_INPUT_COMPONENTS = 0x886C, + GL_MAX_TESS_CONTROL_INPUT_COMPONENTS_EXT = 0x886C, + GL_MAX_TESS_CONTROL_INPUT_COMPONENTS_OES = 0x886C, + GL_MAX_TESS_EVALUATION_INPUT_COMPONENTS = 0x886D, + GL_MAX_TESS_EVALUATION_INPUT_COMPONENTS_EXT = 0x886D, + GL_MAX_TESS_EVALUATION_INPUT_COMPONENTS_OES = 0x886D, + GL_DEPTH_STENCIL_TO_RGBA_NV = 0x886E, + GL_DEPTH_STENCIL_TO_BGRA_NV = 0x886F, + GL_FRAGMENT_PROGRAM_NV = 0x8870, + GL_MAX_TEXTURE_COORDS = 0x8871, + GL_MAX_TEXTURE_COORDS_ARB = 0x8871, + GL_MAX_TEXTURE_COORDS_NV = 0x8871, + GL_MAX_TEXTURE_IMAGE_UNITS = 0x8872, + GL_MAX_TEXTURE_IMAGE_UNITS_ARB = 0x8872, + GL_MAX_TEXTURE_IMAGE_UNITS_NV = 0x8872, + GL_FRAGMENT_PROGRAM_BINDING_NV = 0x8873, + GL_PROGRAM_ERROR_STRING_ARB = 0x8874, + GL_PROGRAM_ERROR_STRING_NV = 0x8874, + GL_PROGRAM_FORMAT_ASCII_ARB = 0x8875, + GL_PROGRAM_FORMAT_ARB = 0x8876, + GL_WRITE_PIXEL_DATA_RANGE_NV = 0x8878, + GL_READ_PIXEL_DATA_RANGE_NV = 0x8879, + GL_WRITE_PIXEL_DATA_RANGE_LENGTH_NV = 0x887A, + GL_READ_PIXEL_DATA_RANGE_LENGTH_NV = 0x887B, + GL_WRITE_PIXEL_DATA_RANGE_POINTER_NV = 0x887C, + GL_READ_PIXEL_DATA_RANGE_POINTER_NV = 0x887D, + GL_GEOMETRY_SHADER_INVOCATIONS = 0x887F, + GL_GEOMETRY_SHADER_INVOCATIONS_EXT = 0x887F, + GL_GEOMETRY_SHADER_INVOCATIONS_OES = 0x887F, + GL_FLOAT_R_NV = 0x8880, + GL_FLOAT_RG_NV = 0x8881, + GL_FLOAT_RGB_NV = 0x8882, + GL_FLOAT_RGBA_NV = 0x8883, + GL_FLOAT_R16_NV = 0x8884, + GL_FLOAT_R32_NV = 0x8885, + GL_FLOAT_RG16_NV = 0x8886, + GL_FLOAT_RG32_NV = 0x8887, + GL_FLOAT_RGB16_NV = 0x8888, + GL_FLOAT_RGB32_NV = 0x8889, + GL_FLOAT_RGBA16_NV = 0x888A, + GL_FLOAT_RGBA32_NV = 0x888B, + GL_TEXTURE_FLOAT_COMPONENTS_NV = 0x888C, + GL_FLOAT_CLEAR_COLOR_VALUE_NV = 0x888D, + GL_FLOAT_RGBA_MODE_NV = 0x888E, + GL_TEXTURE_UNSIGNED_REMAP_MODE_NV = 0x888F, + GL_DEPTH_BOUNDS_TEST_EXT = 0x8890, + GL_DEPTH_BOUNDS_EXT = 0x8891, + GL_ARRAY_BUFFER = 0x8892, + GL_ARRAY_BUFFER_ARB = 0x8892, + GL_ELEMENT_ARRAY_BUFFER = 0x8893, + GL_ELEMENT_ARRAY_BUFFER_ARB = 0x8893, + GL_ARRAY_BUFFER_BINDING = 0x8894, + GL_ARRAY_BUFFER_BINDING_ARB = 0x8894, + GL_ELEMENT_ARRAY_BUFFER_BINDING = 0x8895, + GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB = 0x8895, + GL_VERTEX_ARRAY_BUFFER_BINDING = 0x8896, + GL_VERTEX_ARRAY_BUFFER_BINDING_ARB = 0x8896, + GL_NORMAL_ARRAY_BUFFER_BINDING = 0x8897, + GL_NORMAL_ARRAY_BUFFER_BINDING_ARB = 0x8897, + GL_COLOR_ARRAY_BUFFER_BINDING = 0x8898, + GL_COLOR_ARRAY_BUFFER_BINDING_ARB = 0x8898, + GL_INDEX_ARRAY_BUFFER_BINDING = 0x8899, + GL_INDEX_ARRAY_BUFFER_BINDING_ARB = 0x8899, + GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING = 0x889A, + GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB = 0x889A, + GL_EDGE_FLAG_ARRAY_BUFFER_BINDING = 0x889B, + GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB = 0x889B, + GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING = 0x889C, + GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB = 0x889C, + GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB = 0x889D, + GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING = 0x889D, + GL_FOG_COORD_ARRAY_BUFFER_BINDING = 0x889D, + GL_WEIGHT_ARRAY_BUFFER_BINDING = 0x889E, + GL_WEIGHT_ARRAY_BUFFER_BINDING_ARB = 0x889E, + GL_WEIGHT_ARRAY_BUFFER_BINDING_OES = 0x889E, + GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING = 0x889F, + GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB = 0x889F, + GL_PROGRAM_INSTRUCTIONS_ARB = 0x88A0, + GL_MAX_PROGRAM_INSTRUCTIONS_ARB = 0x88A1, + GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB = 0x88A2, + GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB = 0x88A3, + GL_PROGRAM_TEMPORARIES_ARB = 0x88A4, + GL_MAX_PROGRAM_TEMPORARIES_ARB = 0x88A5, + GL_PROGRAM_NATIVE_TEMPORARIES_ARB = 0x88A6, + GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB = 0x88A7, + GL_PROGRAM_PARAMETERS_ARB = 0x88A8, + GL_MAX_PROGRAM_PARAMETERS_ARB = 0x88A9, + GL_PROGRAM_NATIVE_PARAMETERS_ARB = 0x88AA, + GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB = 0x88AB, + GL_PROGRAM_ATTRIBS_ARB = 0x88AC, + GL_MAX_PROGRAM_ATTRIBS_ARB = 0x88AD, + GL_PROGRAM_NATIVE_ATTRIBS_ARB = 0x88AE, + GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB = 0x88AF, + GL_PROGRAM_ADDRESS_REGISTERS_ARB = 0x88B0, + GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB = 0x88B1, + GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB = 0x88B2, + GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB = 0x88B3, + GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB = 0x88B4, + GL_MAX_PROGRAM_ENV_PARAMETERS_ARB = 0x88B5, + GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB = 0x88B6, + GL_TRANSPOSE_CURRENT_MATRIX_ARB = 0x88B7, + GL_READ_ONLY = 0x88B8, + GL_READ_ONLY_ARB = 0x88B8, + GL_WRITE_ONLY = 0x88B9, + GL_WRITE_ONLY_ARB = 0x88B9, + GL_WRITE_ONLY_OES = 0x88B9, + GL_READ_WRITE = 0x88BA, + GL_READ_WRITE_ARB = 0x88BA, + GL_BUFFER_ACCESS = 0x88BB, + GL_BUFFER_ACCESS_ARB = 0x88BB, + GL_BUFFER_ACCESS_OES = 0x88BB, + GL_BUFFER_MAPPED = 0x88BC, + GL_BUFFER_MAPPED_ARB = 0x88BC, + GL_BUFFER_MAPPED_OES = 0x88BC, + GL_BUFFER_MAP_POINTER = 0x88BD, + GL_BUFFER_MAP_POINTER_ARB = 0x88BD, + GL_BUFFER_MAP_POINTER_OES = 0x88BD, + GL_WRITE_DISCARD_NV = 0x88BE, + GL_TIME_ELAPSED = 0x88BF, + GL_TIME_ELAPSED_EXT = 0x88BF, + GL_MATRIX0_ARB = 0x88C0, + GL_MATRIX1_ARB = 0x88C1, + GL_MATRIX2_ARB = 0x88C2, + GL_MATRIX3_ARB = 0x88C3, + GL_MATRIX4_ARB = 0x88C4, + GL_MATRIX5_ARB = 0x88C5, + GL_MATRIX6_ARB = 0x88C6, + GL_MATRIX7_ARB = 0x88C7, + GL_MATRIX8_ARB = 0x88C8, + GL_MATRIX9_ARB = 0x88C9, + GL_MATRIX10_ARB = 0x88CA, + GL_MATRIX11_ARB = 0x88CB, + GL_MATRIX12_ARB = 0x88CC, + GL_MATRIX13_ARB = 0x88CD, + GL_MATRIX14_ARB = 0x88CE, + GL_MATRIX15_ARB = 0x88CF, + GL_MATRIX16_ARB = 0x88D0, + GL_MATRIX17_ARB = 0x88D1, + GL_MATRIX18_ARB = 0x88D2, + GL_MATRIX19_ARB = 0x88D3, + GL_MATRIX20_ARB = 0x88D4, + GL_MATRIX21_ARB = 0x88D5, + GL_MATRIX22_ARB = 0x88D6, + GL_MATRIX23_ARB = 0x88D7, + GL_MATRIX24_ARB = 0x88D8, + GL_MATRIX25_ARB = 0x88D9, + GL_MATRIX26_ARB = 0x88DA, + GL_MATRIX27_ARB = 0x88DB, + GL_MATRIX28_ARB = 0x88DC, + GL_MATRIX29_ARB = 0x88DD, + GL_MATRIX30_ARB = 0x88DE, + GL_MATRIX31_ARB = 0x88DF, + GL_STREAM_DRAW = 0x88E0, + GL_STREAM_DRAW_ARB = 0x88E0, + GL_STREAM_READ = 0x88E1, + GL_STREAM_READ_ARB = 0x88E1, + GL_STREAM_COPY = 0x88E2, + GL_STREAM_COPY_ARB = 0x88E2, + GL_STATIC_DRAW = 0x88E4, + GL_STATIC_DRAW_ARB = 0x88E4, + GL_STATIC_READ = 0x88E5, + GL_STATIC_READ_ARB = 0x88E5, + GL_STATIC_COPY = 0x88E6, + GL_STATIC_COPY_ARB = 0x88E6, + GL_DYNAMIC_DRAW = 0x88E8, + GL_DYNAMIC_DRAW_ARB = 0x88E8, + GL_DYNAMIC_READ = 0x88E9, + GL_DYNAMIC_READ_ARB = 0x88E9, + GL_DYNAMIC_COPY = 0x88EA, + GL_DYNAMIC_COPY_ARB = 0x88EA, + GL_PIXEL_PACK_BUFFER = 0x88EB, + GL_PIXEL_PACK_BUFFER_ARB = 0x88EB, + GL_PIXEL_PACK_BUFFER_EXT = 0x88EB, + GL_PIXEL_PACK_BUFFER_NV = 0x88EB, + GL_PIXEL_UNPACK_BUFFER = 0x88EC, + GL_PIXEL_UNPACK_BUFFER_ARB = 0x88EC, + GL_PIXEL_UNPACK_BUFFER_EXT = 0x88EC, + GL_PIXEL_UNPACK_BUFFER_NV = 0x88EC, + GL_PIXEL_PACK_BUFFER_BINDING = 0x88ED, + GL_PIXEL_PACK_BUFFER_BINDING_ARB = 0x88ED, + GL_PIXEL_PACK_BUFFER_BINDING_EXT = 0x88ED, + GL_PIXEL_PACK_BUFFER_BINDING_NV = 0x88ED, + GL_ETC1_SRGB8_NV = 0x88EE, + GL_PIXEL_UNPACK_BUFFER_BINDING = 0x88EF, + GL_PIXEL_UNPACK_BUFFER_BINDING_ARB = 0x88EF, + GL_PIXEL_UNPACK_BUFFER_BINDING_EXT = 0x88EF, + GL_PIXEL_UNPACK_BUFFER_BINDING_NV = 0x88EF, + GL_DEPTH24_STENCIL8 = 0x88F0, + GL_DEPTH24_STENCIL8_EXT = 0x88F0, + GL_DEPTH24_STENCIL8_OES = 0x88F0, + GL_TEXTURE_STENCIL_SIZE = 0x88F1, + GL_TEXTURE_STENCIL_SIZE_EXT = 0x88F1, + GL_STENCIL_TAG_BITS_EXT = 0x88F2, + GL_STENCIL_CLEAR_TAG_VALUE_EXT = 0x88F3, + GL_MAX_PROGRAM_EXEC_INSTRUCTIONS_NV = 0x88F4, + GL_MAX_PROGRAM_CALL_DEPTH_NV = 0x88F5, + GL_MAX_PROGRAM_IF_DEPTH_NV = 0x88F6, + GL_MAX_PROGRAM_LOOP_DEPTH_NV = 0x88F7, + GL_MAX_PROGRAM_LOOP_COUNT_NV = 0x88F8, + GL_SRC1_COLOR = 0x88F9, + GL_SRC1_COLOR_EXT = 0x88F9, + GL_ONE_MINUS_SRC1_COLOR = 0x88FA, + GL_ONE_MINUS_SRC1_COLOR_EXT = 0x88FA, + GL_ONE_MINUS_SRC1_ALPHA = 0x88FB, + GL_ONE_MINUS_SRC1_ALPHA_EXT = 0x88FB, + GL_MAX_DUAL_SOURCE_DRAW_BUFFERS = 0x88FC, + GL_MAX_DUAL_SOURCE_DRAW_BUFFERS_EXT = 0x88FC, + GL_VERTEX_ATTRIB_ARRAY_INTEGER = 0x88FD, + GL_VERTEX_ATTRIB_ARRAY_INTEGER_EXT = 0x88FD, + GL_VERTEX_ATTRIB_ARRAY_INTEGER_NV = 0x88FD, + GL_VERTEX_ATTRIB_ARRAY_DIVISOR = 0x88FE, + GL_VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE = 0x88FE, + GL_VERTEX_ATTRIB_ARRAY_DIVISOR_ARB = 0x88FE, + GL_VERTEX_ATTRIB_ARRAY_DIVISOR_EXT = 0x88FE, + GL_VERTEX_ATTRIB_ARRAY_DIVISOR_NV = 0x88FE, + GL_MAX_ARRAY_TEXTURE_LAYERS = 0x88FF, + GL_MAX_ARRAY_TEXTURE_LAYERS_EXT = 0x88FF, + GL_MIN_PROGRAM_TEXEL_OFFSET = 0x8904, + GL_MIN_PROGRAM_TEXEL_OFFSET_EXT = 0x8904, + GL_MIN_PROGRAM_TEXEL_OFFSET_NV = 0x8904, + GL_MAX_PROGRAM_TEXEL_OFFSET = 0x8905, + GL_MAX_PROGRAM_TEXEL_OFFSET_EXT = 0x8905, + GL_MAX_PROGRAM_TEXEL_OFFSET_NV = 0x8905, + GL_PROGRAM_ATTRIB_COMPONENTS_NV = 0x8906, + GL_PROGRAM_RESULT_COMPONENTS_NV = 0x8907, + GL_MAX_PROGRAM_ATTRIB_COMPONENTS_NV = 0x8908, + GL_MAX_PROGRAM_RESULT_COMPONENTS_NV = 0x8909, + GL_STENCIL_TEST_TWO_SIDE_EXT = 0x8910, + GL_ACTIVE_STENCIL_FACE_EXT = 0x8911, + GL_MIRROR_CLAMP_TO_BORDER_EXT = 0x8912, + GL_SAMPLES_PASSED = 0x8914, + GL_SAMPLES_PASSED_ARB = 0x8914, + GL_GEOMETRY_VERTICES_OUT = 0x8916, + GL_GEOMETRY_LINKED_VERTICES_OUT_EXT = 0x8916, + GL_GEOMETRY_LINKED_VERTICES_OUT_OES = 0x8916, + GL_GEOMETRY_INPUT_TYPE = 0x8917, + GL_GEOMETRY_LINKED_INPUT_TYPE_EXT = 0x8917, + GL_GEOMETRY_LINKED_INPUT_TYPE_OES = 0x8917, + GL_GEOMETRY_OUTPUT_TYPE = 0x8918, + GL_GEOMETRY_LINKED_OUTPUT_TYPE_EXT = 0x8918, + GL_GEOMETRY_LINKED_OUTPUT_TYPE_OES = 0x8918, + GL_SAMPLER_BINDING = 0x8919, + GL_CLAMP_VERTEX_COLOR = 0x891A, + GL_CLAMP_VERTEX_COLOR_ARB = 0x891A, + GL_CLAMP_FRAGMENT_COLOR = 0x891B, + GL_CLAMP_FRAGMENT_COLOR_ARB = 0x891B, + GL_CLAMP_READ_COLOR = 0x891C, + GL_CLAMP_READ_COLOR_ARB = 0x891C, + GL_FIXED_ONLY = 0x891D, + GL_FIXED_ONLY_ARB = 0x891D, + GL_TESS_CONTROL_PROGRAM_NV = 0x891E, + GL_TESS_EVALUATION_PROGRAM_NV = 0x891F, + GL_FRAGMENT_SHADER_ATI = 0x8920, + GL_REG_0_ATI = 0x8921, + GL_REG_1_ATI = 0x8922, + GL_REG_2_ATI = 0x8923, + GL_REG_3_ATI = 0x8924, + GL_REG_4_ATI = 0x8925, + GL_REG_5_ATI = 0x8926, + GL_REG_6_ATI = 0x8927, + GL_REG_7_ATI = 0x8928, + GL_REG_8_ATI = 0x8929, + GL_REG_9_ATI = 0x892A, + GL_REG_10_ATI = 0x892B, + GL_REG_11_ATI = 0x892C, + GL_REG_12_ATI = 0x892D, + GL_REG_13_ATI = 0x892E, + GL_REG_14_ATI = 0x892F, + GL_REG_15_ATI = 0x8930, + GL_REG_16_ATI = 0x8931, + GL_REG_17_ATI = 0x8932, + GL_REG_18_ATI = 0x8933, + GL_REG_19_ATI = 0x8934, + GL_REG_20_ATI = 0x8935, + GL_REG_21_ATI = 0x8936, + GL_REG_22_ATI = 0x8937, + GL_REG_23_ATI = 0x8938, + GL_REG_24_ATI = 0x8939, + GL_REG_25_ATI = 0x893A, + GL_REG_26_ATI = 0x893B, + GL_REG_27_ATI = 0x893C, + GL_REG_28_ATI = 0x893D, + GL_REG_29_ATI = 0x893E, + GL_REG_30_ATI = 0x893F, + GL_REG_31_ATI = 0x8940, + GL_CON_0_ATI = 0x8941, + GL_CON_1_ATI = 0x8942, + GL_CON_2_ATI = 0x8943, + GL_CON_3_ATI = 0x8944, + GL_CON_4_ATI = 0x8945, + GL_CON_5_ATI = 0x8946, + GL_CON_6_ATI = 0x8947, + GL_CON_7_ATI = 0x8948, + GL_CON_8_ATI = 0x8949, + GL_CON_9_ATI = 0x894A, + GL_CON_10_ATI = 0x894B, + GL_CON_11_ATI = 0x894C, + GL_CON_12_ATI = 0x894D, + GL_CON_13_ATI = 0x894E, + GL_CON_14_ATI = 0x894F, + GL_CON_15_ATI = 0x8950, + GL_CON_16_ATI = 0x8951, + GL_CON_17_ATI = 0x8952, + GL_CON_18_ATI = 0x8953, + GL_CON_19_ATI = 0x8954, + GL_CON_20_ATI = 0x8955, + GL_CON_21_ATI = 0x8956, + GL_CON_22_ATI = 0x8957, + GL_CON_23_ATI = 0x8958, + GL_CON_24_ATI = 0x8959, + GL_CON_25_ATI = 0x895A, + GL_CON_26_ATI = 0x895B, + GL_CON_27_ATI = 0x895C, + GL_CON_28_ATI = 0x895D, + GL_CON_29_ATI = 0x895E, + GL_CON_30_ATI = 0x895F, + GL_CON_31_ATI = 0x8960, + GL_MOV_ATI = 0x8961, + GL_ADD_ATI = 0x8963, + GL_MUL_ATI = 0x8964, + GL_SUB_ATI = 0x8965, + GL_DOT3_ATI = 0x8966, + GL_DOT4_ATI = 0x8967, + GL_MAD_ATI = 0x8968, + GL_LERP_ATI = 0x8969, + GL_CND_ATI = 0x896A, + GL_CND0_ATI = 0x896B, + GL_DOT2_ADD_ATI = 0x896C, + GL_SECONDARY_INTERPOLATOR_ATI = 0x896D, + GL_NUM_FRAGMENT_REGISTERS_ATI = 0x896E, + GL_NUM_FRAGMENT_CONSTANTS_ATI = 0x896F, + GL_NUM_PASSES_ATI = 0x8970, + GL_NUM_INSTRUCTIONS_PER_PASS_ATI = 0x8971, + GL_NUM_INSTRUCTIONS_TOTAL_ATI = 0x8972, + GL_NUM_INPUT_INTERPOLATOR_COMPONENTS_ATI = 0x8973, + GL_NUM_LOOPBACK_COMPONENTS_ATI = 0x8974, + GL_COLOR_ALPHA_PAIRING_ATI = 0x8975, + GL_SWIZZLE_STR_ATI = 0x8976, + GL_SWIZZLE_STQ_ATI = 0x8977, + GL_SWIZZLE_STR_DR_ATI = 0x8978, + GL_SWIZZLE_STQ_DQ_ATI = 0x8979, + GL_SWIZZLE_STRQ_ATI = 0x897A, + GL_SWIZZLE_STRQ_DQ_ATI = 0x897B, + GL_INTERLACE_OML = 0x8980, + GL_INTERLACE_READ_OML = 0x8981, + GL_FORMAT_SUBSAMPLE_24_24_OML = 0x8982, + GL_FORMAT_SUBSAMPLE_244_244_OML = 0x8983, + GL_PACK_RESAMPLE_OML = 0x8984, + GL_UNPACK_RESAMPLE_OML = 0x8985, + GL_RESAMPLE_REPLICATE_OML = 0x8986, + GL_RESAMPLE_ZERO_FILL_OML = 0x8987, + GL_RESAMPLE_AVERAGE_OML = 0x8988, + GL_RESAMPLE_DECIMATE_OML = 0x8989, + GL_POINT_SIZE_ARRAY_TYPE_OES = 0x898A, + GL_POINT_SIZE_ARRAY_STRIDE_OES = 0x898B, + GL_POINT_SIZE_ARRAY_POINTER_OES = 0x898C, + GL_MODELVIEW_MATRIX_FLOAT_AS_INT_BITS_OES = 0x898D, + GL_PROJECTION_MATRIX_FLOAT_AS_INT_BITS_OES = 0x898E, + GL_TEXTURE_MATRIX_FLOAT_AS_INT_BITS_OES = 0x898F, + GL_VERTEX_ATTRIB_MAP1_APPLE = 0x8A00, + GL_VERTEX_ATTRIB_MAP2_APPLE = 0x8A01, + GL_VERTEX_ATTRIB_MAP1_SIZE_APPLE = 0x8A02, + GL_VERTEX_ATTRIB_MAP1_COEFF_APPLE = 0x8A03, + GL_VERTEX_ATTRIB_MAP1_ORDER_APPLE = 0x8A04, + GL_VERTEX_ATTRIB_MAP1_DOMAIN_APPLE = 0x8A05, + GL_VERTEX_ATTRIB_MAP2_SIZE_APPLE = 0x8A06, + GL_VERTEX_ATTRIB_MAP2_COEFF_APPLE = 0x8A07, + GL_VERTEX_ATTRIB_MAP2_ORDER_APPLE = 0x8A08, + GL_VERTEX_ATTRIB_MAP2_DOMAIN_APPLE = 0x8A09, + GL_DRAW_PIXELS_APPLE = 0x8A0A, + GL_FENCE_APPLE = 0x8A0B, + GL_ELEMENT_ARRAY_APPLE = 0x8A0C, + GL_ELEMENT_ARRAY_TYPE_APPLE = 0x8A0D, + GL_ELEMENT_ARRAY_POINTER_APPLE = 0x8A0E, + GL_COLOR_FLOAT_APPLE = 0x8A0F, + GL_UNIFORM_BUFFER = 0x8A11, + GL_BUFFER_SERIALIZED_MODIFY_APPLE = 0x8A12, + GL_BUFFER_FLUSHING_UNMAP_APPLE = 0x8A13, + GL_AUX_DEPTH_STENCIL_APPLE = 0x8A14, + GL_PACK_ROW_BYTES_APPLE = 0x8A15, + GL_UNPACK_ROW_BYTES_APPLE = 0x8A16, + GL_RELEASED_APPLE = 0x8A19, + GL_VOLATILE_APPLE = 0x8A1A, + GL_RETAINED_APPLE = 0x8A1B, + GL_UNDEFINED_APPLE = 0x8A1C, + GL_PURGEABLE_APPLE = 0x8A1D, + GL_RGB_422_APPLE = 0x8A1F, + GL_UNIFORM_BUFFER_BINDING = 0x8A28, + GL_UNIFORM_BUFFER_START = 0x8A29, + GL_UNIFORM_BUFFER_SIZE = 0x8A2A, + GL_MAX_VERTEX_UNIFORM_BLOCKS = 0x8A2B, + GL_MAX_GEOMETRY_UNIFORM_BLOCKS = 0x8A2C, + GL_MAX_GEOMETRY_UNIFORM_BLOCKS_EXT = 0x8A2C, + GL_MAX_GEOMETRY_UNIFORM_BLOCKS_OES = 0x8A2C, + GL_MAX_FRAGMENT_UNIFORM_BLOCKS = 0x8A2D, + GL_MAX_COMBINED_UNIFORM_BLOCKS = 0x8A2E, + GL_MAX_UNIFORM_BUFFER_BINDINGS = 0x8A2F, + GL_MAX_UNIFORM_BLOCK_SIZE = 0x8A30, + GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS = 0x8A31, + GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS = 0x8A32, + GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS_EXT = 0x8A32, + GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS_OES = 0x8A32, + GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS = 0x8A33, + GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT = 0x8A34, + GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH = 0x8A35, + GL_ACTIVE_UNIFORM_BLOCKS = 0x8A36, + GL_UNIFORM_TYPE = 0x8A37, + GL_UNIFORM_SIZE = 0x8A38, + GL_UNIFORM_NAME_LENGTH = 0x8A39, + GL_UNIFORM_BLOCK_INDEX = 0x8A3A, + GL_UNIFORM_OFFSET = 0x8A3B, + GL_UNIFORM_ARRAY_STRIDE = 0x8A3C, + GL_UNIFORM_MATRIX_STRIDE = 0x8A3D, + GL_UNIFORM_IS_ROW_MAJOR = 0x8A3E, + GL_UNIFORM_BLOCK_BINDING = 0x8A3F, + GL_UNIFORM_BLOCK_DATA_SIZE = 0x8A40, + GL_UNIFORM_BLOCK_NAME_LENGTH = 0x8A41, + GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS = 0x8A42, + GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES = 0x8A43, + GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER = 0x8A44, + GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER = 0x8A45, + GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER = 0x8A46, + GL_TEXTURE_SRGB_DECODE_EXT = 0x8A48, + GL_DECODE_EXT = 0x8A49, + GL_SKIP_DECODE_EXT = 0x8A4A, + GL_PROGRAM_PIPELINE_OBJECT_EXT = 0x8A4F, + GL_RGB_RAW_422_APPLE = 0x8A51, + GL_FRAGMENT_SHADER_DISCARDS_SAMPLES_EXT = 0x8A52, + GL_SYNC_OBJECT_APPLE = 0x8A53, + GL_COMPRESSED_SRGB_PVRTC_2BPPV1_EXT = 0x8A54, + GL_COMPRESSED_SRGB_PVRTC_4BPPV1_EXT = 0x8A55, + GL_COMPRESSED_SRGB_ALPHA_PVRTC_2BPPV1_EXT = 0x8A56, + GL_COMPRESSED_SRGB_ALPHA_PVRTC_4BPPV1_EXT = 0x8A57, + GL_SHADER_OBJECT_ARB = 0x8B48, + GL_SHADER_OBJECT_EXT = 0x8B48, + GL_MAX_FRAGMENT_UNIFORM_COMPONENTS = 0x8B49, + GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB = 0x8B49, + GL_MAX_VERTEX_UNIFORM_COMPONENTS = 0x8B4A, + GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB = 0x8B4A, + GL_MAX_VARYING_FLOATS = 0x8B4B, + GL_MAX_VARYING_COMPONENTS = 0x8B4B, + GL_MAX_VARYING_COMPONENTS_EXT = 0x8B4B, + GL_MAX_VARYING_FLOATS_ARB = 0x8B4B, + GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS = 0x8B4C, + GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB = 0x8B4C, + GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS = 0x8B4D, + GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB = 0x8B4D, + GL_OBJECT_TYPE_ARB = 0x8B4E, + GL_SHADER_TYPE = 0x8B4F, + GL_OBJECT_SUBTYPE_ARB = 0x8B4F, + GL_DELETE_STATUS = 0x8B80, + GL_OBJECT_DELETE_STATUS_ARB = 0x8B80, + GL_COMPILE_STATUS = 0x8B81, + GL_OBJECT_COMPILE_STATUS_ARB = 0x8B81, + GL_LINK_STATUS = 0x8B82, + GL_OBJECT_LINK_STATUS_ARB = 0x8B82, + GL_VALIDATE_STATUS = 0x8B83, + GL_OBJECT_VALIDATE_STATUS_ARB = 0x8B83, + GL_INFO_LOG_LENGTH = 0x8B84, + GL_OBJECT_INFO_LOG_LENGTH_ARB = 0x8B84, + GL_ATTACHED_SHADERS = 0x8B85, + GL_OBJECT_ATTACHED_OBJECTS_ARB = 0x8B85, + GL_ACTIVE_UNIFORMS = 0x8B86, + GL_OBJECT_ACTIVE_UNIFORMS_ARB = 0x8B86, + GL_ACTIVE_UNIFORM_MAX_LENGTH = 0x8B87, + GL_OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB = 0x8B87, + GL_SHADER_SOURCE_LENGTH = 0x8B88, + GL_OBJECT_SHADER_SOURCE_LENGTH_ARB = 0x8B88, + GL_ACTIVE_ATTRIBUTES = 0x8B89, + GL_OBJECT_ACTIVE_ATTRIBUTES_ARB = 0x8B89, + GL_ACTIVE_ATTRIBUTE_MAX_LENGTH = 0x8B8A, + GL_OBJECT_ACTIVE_ATTRIBUTE_MAX_LENGTH_ARB = 0x8B8A, + GL_FRAGMENT_SHADER_DERIVATIVE_HINT = 0x8B8B, + GL_FRAGMENT_SHADER_DERIVATIVE_HINT_ARB = 0x8B8B, + GL_FRAGMENT_SHADER_DERIVATIVE_HINT_OES = 0x8B8B, + GL_SHADING_LANGUAGE_VERSION = 0x8B8C, + GL_SHADING_LANGUAGE_VERSION_ARB = 0x8B8C, + GL_CURRENT_PROGRAM = 0x8B8D, + GL_PALETTE4_RGB8_OES = 0x8B90, + GL_PALETTE4_RGBA8_OES = 0x8B91, + GL_PALETTE4_R5_G6_B5_OES = 0x8B92, + GL_PALETTE4_RGBA4_OES = 0x8B93, + GL_PALETTE4_RGB5_A1_OES = 0x8B94, + GL_PALETTE8_RGB8_OES = 0x8B95, + GL_PALETTE8_RGBA8_OES = 0x8B96, + GL_PALETTE8_R5_G6_B5_OES = 0x8B97, + GL_PALETTE8_RGBA4_OES = 0x8B98, + GL_PALETTE8_RGB5_A1_OES = 0x8B99, + GL_IMPLEMENTATION_COLOR_READ_TYPE = 0x8B9A, + GL_IMPLEMENTATION_COLOR_READ_TYPE_OES = 0x8B9A, + GL_IMPLEMENTATION_COLOR_READ_FORMAT = 0x8B9B, + GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES = 0x8B9B, + GL_POINT_SIZE_ARRAY_OES = 0x8B9C, + GL_TEXTURE_CROP_RECT_OES = 0x8B9D, + GL_MATRIX_INDEX_ARRAY_BUFFER_BINDING_OES = 0x8B9E, + GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES = 0x8B9F, + GL_FRAGMENT_PROGRAM_POSITION_MESA = 0x8BB0, + GL_FRAGMENT_PROGRAM_CALLBACK_MESA = 0x8BB1, + GL_FRAGMENT_PROGRAM_CALLBACK_FUNC_MESA = 0x8BB2, + GL_FRAGMENT_PROGRAM_CALLBACK_DATA_MESA = 0x8BB3, + GL_VERTEX_PROGRAM_POSITION_MESA = 0x8BB4, + GL_VERTEX_PROGRAM_CALLBACK_MESA = 0x8BB5, + GL_VERTEX_PROGRAM_CALLBACK_FUNC_MESA = 0x8BB6, + GL_VERTEX_PROGRAM_CALLBACK_DATA_MESA = 0x8BB7, + GL_TILE_RASTER_ORDER_FIXED_MESA = 0x8BB8, + GL_TILE_RASTER_ORDER_INCREASING_X_MESA = 0x8BB9, + GL_TILE_RASTER_ORDER_INCREASING_Y_MESA = 0x8BBA, + GL_FRAMEBUFFER_FLIP_Y_MESA = 0x8BBB, + GL_FRAMEBUFFER_FLIP_X_MESA = 0x8BBC, + GL_FRAMEBUFFER_SWAP_XY_MESA = 0x8BBD, + GL_COUNTER_TYPE_AMD = 0x8BC0, + GL_COUNTER_RANGE_AMD = 0x8BC1, + GL_UNSIGNED_INT64_AMD = 0x8BC2, + GL_PERCENTAGE_AMD = 0x8BC3, + GL_PERFMON_RESULT_AVAILABLE_AMD = 0x8BC4, + GL_PERFMON_RESULT_SIZE_AMD = 0x8BC5, + GL_PERFMON_RESULT_AMD = 0x8BC6, + GL_TEXTURE_WIDTH_QCOM = 0x8BD2, + GL_TEXTURE_HEIGHT_QCOM = 0x8BD3, + GL_TEXTURE_DEPTH_QCOM = 0x8BD4, + GL_TEXTURE_INTERNAL_FORMAT_QCOM = 0x8BD5, + GL_TEXTURE_FORMAT_QCOM = 0x8BD6, + GL_TEXTURE_TYPE_QCOM = 0x8BD7, + GL_TEXTURE_IMAGE_VALID_QCOM = 0x8BD8, + GL_TEXTURE_NUM_LEVELS_QCOM = 0x8BD9, + GL_TEXTURE_TARGET_QCOM = 0x8BDA, + GL_TEXTURE_OBJECT_VALID_QCOM = 0x8BDB, + GL_STATE_RESTORE = 0x8BDC, + GL_SAMPLER_EXTERNAL_2D_Y2Y_EXT = 0x8BE7, + GL_TEXTURE_PROTECTED_EXT = 0x8BFA, + GL_TEXTURE_FOVEATED_FEATURE_BITS_QCOM = 0x8BFB, + GL_TEXTURE_FOVEATED_MIN_PIXEL_DENSITY_QCOM = 0x8BFC, + GL_TEXTURE_FOVEATED_FEATURE_QUERY_QCOM = 0x8BFD, + GL_TEXTURE_FOVEATED_NUM_FOCAL_POINTS_QUERY_QCOM = 0x8BFE, + GL_FRAMEBUFFER_INCOMPLETE_FOVEATION_QCOM = 0x8BFF, + GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG = 0x8C00, + GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG = 0x8C01, + GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG = 0x8C02, + GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG = 0x8C03, + GL_MODULATE_COLOR_IMG = 0x8C04, + GL_RECIP_ADD_SIGNED_ALPHA_IMG = 0x8C05, + GL_TEXTURE_ALPHA_MODULATE_IMG = 0x8C06, + GL_FACTOR_ALPHA_MODULATE_IMG = 0x8C07, + GL_FRAGMENT_ALPHA_MODULATE_IMG = 0x8C08, + GL_ADD_BLEND_IMG = 0x8C09, + GL_SGX_BINARY_IMG = 0x8C0A, + GL_TEXTURE_RED_TYPE = 0x8C10, + GL_TEXTURE_RED_TYPE_ARB = 0x8C10, + GL_TEXTURE_GREEN_TYPE = 0x8C11, + GL_TEXTURE_GREEN_TYPE_ARB = 0x8C11, + GL_TEXTURE_BLUE_TYPE = 0x8C12, + GL_TEXTURE_BLUE_TYPE_ARB = 0x8C12, + GL_TEXTURE_ALPHA_TYPE = 0x8C13, + GL_TEXTURE_ALPHA_TYPE_ARB = 0x8C13, + GL_TEXTURE_LUMINANCE_TYPE = 0x8C14, + GL_TEXTURE_LUMINANCE_TYPE_ARB = 0x8C14, + GL_TEXTURE_INTENSITY_TYPE = 0x8C15, + GL_TEXTURE_INTENSITY_TYPE_ARB = 0x8C15, + GL_TEXTURE_DEPTH_TYPE = 0x8C16, + GL_TEXTURE_DEPTH_TYPE_ARB = 0x8C16, + GL_UNSIGNED_NORMALIZED = 0x8C17, + GL_UNSIGNED_NORMALIZED_ARB = 0x8C17, + GL_UNSIGNED_NORMALIZED_EXT = 0x8C17, + GL_TEXTURE_1D_ARRAY = 0x8C18, + GL_TEXTURE_1D_ARRAY_EXT = 0x8C18, + GL_PROXY_TEXTURE_1D_ARRAY = 0x8C19, + GL_PROXY_TEXTURE_1D_ARRAY_EXT = 0x8C19, + GL_TEXTURE_2D_ARRAY = 0x8C1A, + GL_TEXTURE_2D_ARRAY_EXT = 0x8C1A, + GL_PROXY_TEXTURE_2D_ARRAY = 0x8C1B, + GL_PROXY_TEXTURE_2D_ARRAY_EXT = 0x8C1B, + GL_TEXTURE_BINDING_1D_ARRAY = 0x8C1C, + GL_TEXTURE_BINDING_1D_ARRAY_EXT = 0x8C1C, + GL_TEXTURE_BINDING_2D_ARRAY = 0x8C1D, + GL_TEXTURE_BINDING_2D_ARRAY_EXT = 0x8C1D, + GL_GEOMETRY_PROGRAM_NV = 0x8C26, + GL_MAX_PROGRAM_OUTPUT_VERTICES_NV = 0x8C27, + GL_MAX_PROGRAM_TOTAL_OUTPUT_COMPONENTS_NV = 0x8C28, + GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS = 0x8C29, + GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_ARB = 0x8C29, + GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_EXT = 0x8C29, + GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_OES = 0x8C29, + GL_TEXTURE_BUFFER = 0x8C2A, + GL_TEXTURE_BUFFER_ARB = 0x8C2A, + GL_TEXTURE_BUFFER_EXT = 0x8C2A, + GL_TEXTURE_BUFFER_OES = 0x8C2A, + GL_TEXTURE_BUFFER_BINDING = 0x8C2A, + GL_TEXTURE_BUFFER_BINDING_EXT = 0x8C2A, + GL_TEXTURE_BUFFER_BINDING_OES = 0x8C2A, + GL_MAX_TEXTURE_BUFFER_SIZE = 0x8C2B, + GL_MAX_TEXTURE_BUFFER_SIZE_ARB = 0x8C2B, + GL_MAX_TEXTURE_BUFFER_SIZE_EXT = 0x8C2B, + GL_MAX_TEXTURE_BUFFER_SIZE_OES = 0x8C2B, + GL_TEXTURE_BINDING_BUFFER = 0x8C2C, + GL_TEXTURE_BINDING_BUFFER_ARB = 0x8C2C, + GL_TEXTURE_BINDING_BUFFER_EXT = 0x8C2C, + GL_TEXTURE_BINDING_BUFFER_OES = 0x8C2C, + GL_TEXTURE_BUFFER_DATA_STORE_BINDING = 0x8C2D, + GL_TEXTURE_BUFFER_DATA_STORE_BINDING_ARB = 0x8C2D, + GL_TEXTURE_BUFFER_DATA_STORE_BINDING_EXT = 0x8C2D, + GL_TEXTURE_BUFFER_DATA_STORE_BINDING_OES = 0x8C2D, + GL_TEXTURE_BUFFER_FORMAT_ARB = 0x8C2E, + GL_TEXTURE_BUFFER_FORMAT_EXT = 0x8C2E, + GL_ANY_SAMPLES_PASSED = 0x8C2F, + GL_ANY_SAMPLES_PASSED_EXT = 0x8C2F, + GL_SAMPLE_SHADING = 0x8C36, + GL_SAMPLE_SHADING_ARB = 0x8C36, + GL_SAMPLE_SHADING_OES = 0x8C36, + GL_MIN_SAMPLE_SHADING_VALUE = 0x8C37, + GL_MIN_SAMPLE_SHADING_VALUE_ARB = 0x8C37, + GL_MIN_SAMPLE_SHADING_VALUE_OES = 0x8C37, + GL_R11F_G11F_B10F = 0x8C3A, + GL_R11F_G11F_B10F_APPLE = 0x8C3A, + GL_R11F_G11F_B10F_EXT = 0x8C3A, + GL_UNSIGNED_INT_10F_11F_11F_REV = 0x8C3B, + GL_UNSIGNED_INT_10F_11F_11F_REV_APPLE = 0x8C3B, + GL_UNSIGNED_INT_10F_11F_11F_REV_EXT = 0x8C3B, + GL_RGBA_SIGNED_COMPONENTS_EXT = 0x8C3C, + GL_RGB9_E5 = 0x8C3D, + GL_RGB9_E5_APPLE = 0x8C3D, + GL_RGB9_E5_EXT = 0x8C3D, + GL_UNSIGNED_INT_5_9_9_9_REV = 0x8C3E, + GL_UNSIGNED_INT_5_9_9_9_REV_APPLE = 0x8C3E, + GL_UNSIGNED_INT_5_9_9_9_REV_EXT = 0x8C3E, + GL_TEXTURE_SHARED_SIZE = 0x8C3F, + GL_TEXTURE_SHARED_SIZE_EXT = 0x8C3F, + GL_SRGB = 0x8C40, + GL_SRGB_EXT = 0x8C40, + GL_SRGB8 = 0x8C41, + GL_SRGB8_EXT = 0x8C41, + GL_SRGB8_NV = 0x8C41, + GL_SRGB_ALPHA = 0x8C42, + GL_SRGB_ALPHA_EXT = 0x8C42, + GL_SRGB8_ALPHA8 = 0x8C43, + GL_SRGB8_ALPHA8_EXT = 0x8C43, + GL_SLUMINANCE_ALPHA = 0x8C44, + GL_SLUMINANCE_ALPHA_EXT = 0x8C44, + GL_SLUMINANCE_ALPHA_NV = 0x8C44, + GL_SLUMINANCE8_ALPHA8 = 0x8C45, + GL_SLUMINANCE8_ALPHA8_EXT = 0x8C45, + GL_SLUMINANCE8_ALPHA8_NV = 0x8C45, + GL_SLUMINANCE = 0x8C46, + GL_SLUMINANCE_EXT = 0x8C46, + GL_SLUMINANCE_NV = 0x8C46, + GL_SLUMINANCE8 = 0x8C47, + GL_SLUMINANCE8_EXT = 0x8C47, + GL_SLUMINANCE8_NV = 0x8C47, + GL_COMPRESSED_SRGB = 0x8C48, + GL_COMPRESSED_SRGB_EXT = 0x8C48, + GL_COMPRESSED_SRGB_ALPHA = 0x8C49, + GL_COMPRESSED_SRGB_ALPHA_EXT = 0x8C49, + GL_COMPRESSED_SLUMINANCE = 0x8C4A, + GL_COMPRESSED_SLUMINANCE_EXT = 0x8C4A, + GL_COMPRESSED_SLUMINANCE_ALPHA = 0x8C4B, + GL_COMPRESSED_SLUMINANCE_ALPHA_EXT = 0x8C4B, + GL_COMPRESSED_SRGB_S3TC_DXT1_EXT = 0x8C4C, + GL_COMPRESSED_SRGB_S3TC_DXT1_NV = 0x8C4C, + GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT = 0x8C4D, + GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_NV = 0x8C4D, + GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT = 0x8C4E, + GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_NV = 0x8C4E, + GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT = 0x8C4F, + GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_NV = 0x8C4F, + GL_COMPRESSED_LUMINANCE_LATC1_EXT = 0x8C70, + GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT = 0x8C71, + GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT = 0x8C72, + GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT = 0x8C73, + GL_TESS_CONTROL_PROGRAM_PARAMETER_BUFFER_NV = 0x8C74, + GL_TESS_EVALUATION_PROGRAM_PARAMETER_BUFFER_NV = 0x8C75, + GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH = 0x8C76, + GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH_EXT = 0x8C76, + GL_BACK_PRIMARY_COLOR_NV = 0x8C77, + GL_BACK_SECONDARY_COLOR_NV = 0x8C78, + GL_TEXTURE_COORD_NV = 0x8C79, + GL_CLIP_DISTANCE_NV = 0x8C7A, + GL_VERTEX_ID_NV = 0x8C7B, + GL_PRIMITIVE_ID_NV = 0x8C7C, + GL_GENERIC_ATTRIB_NV = 0x8C7D, + GL_TRANSFORM_FEEDBACK_ATTRIBS_NV = 0x8C7E, + GL_TRANSFORM_FEEDBACK_BUFFER_MODE = 0x8C7F, + GL_TRANSFORM_FEEDBACK_BUFFER_MODE_EXT = 0x8C7F, + GL_TRANSFORM_FEEDBACK_BUFFER_MODE_NV = 0x8C7F, + GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS = 0x8C80, + GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_EXT = 0x8C80, + GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_NV = 0x8C80, + GL_ACTIVE_VARYINGS_NV = 0x8C81, + GL_ACTIVE_VARYING_MAX_LENGTH_NV = 0x8C82, + GL_TRANSFORM_FEEDBACK_VARYINGS = 0x8C83, + GL_TRANSFORM_FEEDBACK_VARYINGS_EXT = 0x8C83, + GL_TRANSFORM_FEEDBACK_VARYINGS_NV = 0x8C83, + GL_TRANSFORM_FEEDBACK_BUFFER_START = 0x8C84, + GL_TRANSFORM_FEEDBACK_BUFFER_START_EXT = 0x8C84, + GL_TRANSFORM_FEEDBACK_BUFFER_START_NV = 0x8C84, + GL_TRANSFORM_FEEDBACK_BUFFER_SIZE = 0x8C85, + GL_TRANSFORM_FEEDBACK_BUFFER_SIZE_EXT = 0x8C85, + GL_TRANSFORM_FEEDBACK_BUFFER_SIZE_NV = 0x8C85, + GL_TRANSFORM_FEEDBACK_RECORD_NV = 0x8C86, + GL_PRIMITIVES_GENERATED = 0x8C87, + GL_PRIMITIVES_GENERATED_EXT = 0x8C87, + GL_PRIMITIVES_GENERATED_NV = 0x8C87, + GL_PRIMITIVES_GENERATED_OES = 0x8C87, + GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN = 0x8C88, + GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN_EXT = 0x8C88, + GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN_NV = 0x8C88, + GL_RASTERIZER_DISCARD = 0x8C89, + GL_RASTERIZER_DISCARD_EXT = 0x8C89, + GL_RASTERIZER_DISCARD_NV = 0x8C89, + GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS = 0x8C8A, + GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS_EXT = 0x8C8A, + GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS_NV = 0x8C8A, + GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS = 0x8C8B, + GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_EXT = 0x8C8B, + GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_NV = 0x8C8B, + GL_INTERLEAVED_ATTRIBS = 0x8C8C, + GL_INTERLEAVED_ATTRIBS_EXT = 0x8C8C, + GL_INTERLEAVED_ATTRIBS_NV = 0x8C8C, + GL_SEPARATE_ATTRIBS = 0x8C8D, + GL_SEPARATE_ATTRIBS_EXT = 0x8C8D, + GL_SEPARATE_ATTRIBS_NV = 0x8C8D, + GL_TRANSFORM_FEEDBACK_BUFFER = 0x8C8E, + GL_TRANSFORM_FEEDBACK_BUFFER_EXT = 0x8C8E, + GL_TRANSFORM_FEEDBACK_BUFFER_NV = 0x8C8E, + GL_TRANSFORM_FEEDBACK_BUFFER_BINDING = 0x8C8F, + GL_TRANSFORM_FEEDBACK_BUFFER_BINDING_EXT = 0x8C8F, + GL_TRANSFORM_FEEDBACK_BUFFER_BINDING_NV = 0x8C8F, + GL_MOTION_ESTIMATION_SEARCH_BLOCK_X_QCOM = 0x8C90, + GL_MOTION_ESTIMATION_SEARCH_BLOCK_Y_QCOM = 0x8C91, + GL_ATC_RGB_AMD = 0x8C92, + GL_ATC_RGBA_EXPLICIT_ALPHA_AMD = 0x8C93, + GL_POINT_SPRITE_COORD_ORIGIN = 0x8CA0, + GL_LOWER_LEFT = 0x8CA1, + GL_LOWER_LEFT_EXT = 0x8CA1, + GL_UPPER_LEFT = 0x8CA2, + GL_UPPER_LEFT_EXT = 0x8CA2, + GL_STENCIL_BACK_REF = 0x8CA3, + GL_STENCIL_BACK_VALUE_MASK = 0x8CA4, + GL_STENCIL_BACK_WRITEMASK = 0x8CA5, + GL_DRAW_FRAMEBUFFER_BINDING = 0x8CA6, + GL_DRAW_FRAMEBUFFER_BINDING_ANGLE = 0x8CA6, + GL_DRAW_FRAMEBUFFER_BINDING_APPLE = 0x8CA6, + GL_DRAW_FRAMEBUFFER_BINDING_EXT = 0x8CA6, + GL_DRAW_FRAMEBUFFER_BINDING_NV = 0x8CA6, + GL_FRAMEBUFFER_BINDING = 0x8CA6, + GL_FRAMEBUFFER_BINDING_ANGLE = 0x8CA6, + GL_FRAMEBUFFER_BINDING_EXT = 0x8CA6, + GL_FRAMEBUFFER_BINDING_OES = 0x8CA6, + GL_RENDERBUFFER_BINDING = 0x8CA7, + GL_RENDERBUFFER_BINDING_ANGLE = 0x8CA7, + GL_RENDERBUFFER_BINDING_EXT = 0x8CA7, + GL_RENDERBUFFER_BINDING_OES = 0x8CA7, + GL_READ_FRAMEBUFFER = 0x8CA8, + GL_READ_FRAMEBUFFER_ANGLE = 0x8CA8, + GL_READ_FRAMEBUFFER_APPLE = 0x8CA8, + GL_READ_FRAMEBUFFER_EXT = 0x8CA8, + GL_READ_FRAMEBUFFER_NV = 0x8CA8, + GL_DRAW_FRAMEBUFFER = 0x8CA9, + GL_DRAW_FRAMEBUFFER_ANGLE = 0x8CA9, + GL_DRAW_FRAMEBUFFER_APPLE = 0x8CA9, + GL_DRAW_FRAMEBUFFER_EXT = 0x8CA9, + GL_DRAW_FRAMEBUFFER_NV = 0x8CA9, + GL_READ_FRAMEBUFFER_BINDING = 0x8CAA, + GL_READ_FRAMEBUFFER_BINDING_ANGLE = 0x8CAA, + GL_READ_FRAMEBUFFER_BINDING_APPLE = 0x8CAA, + GL_READ_FRAMEBUFFER_BINDING_EXT = 0x8CAA, + GL_READ_FRAMEBUFFER_BINDING_NV = 0x8CAA, + GL_RENDERBUFFER_COVERAGE_SAMPLES_NV = 0x8CAB, + GL_RENDERBUFFER_SAMPLES = 0x8CAB, + GL_RENDERBUFFER_SAMPLES_ANGLE = 0x8CAB, + GL_RENDERBUFFER_SAMPLES_APPLE = 0x8CAB, + GL_RENDERBUFFER_SAMPLES_EXT = 0x8CAB, + GL_RENDERBUFFER_SAMPLES_NV = 0x8CAB, + GL_DEPTH_COMPONENT32F = 0x8CAC, + GL_DEPTH32F_STENCIL8 = 0x8CAD, + GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE = 0x8CD0, + GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT = 0x8CD0, + GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_OES = 0x8CD0, + GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME = 0x8CD1, + GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT = 0x8CD1, + GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_OES = 0x8CD1, + GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL = 0x8CD2, + GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT = 0x8CD2, + GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_OES = 0x8CD2, + GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE = 0x8CD3, + GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT = 0x8CD3, + GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_OES = 0x8CD3, + GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT = 0x8CD4, + GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_OES = 0x8CD4, + GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER = 0x8CD4, + GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT = 0x8CD4, + GL_FRAMEBUFFER_COMPLETE = 0x8CD5, + GL_FRAMEBUFFER_COMPLETE_EXT = 0x8CD5, + GL_FRAMEBUFFER_COMPLETE_OES = 0x8CD5, + GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT = 0x8CD6, + GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT = 0x8CD6, + GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_OES = 0x8CD6, + GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT = 0x8CD7, + GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT = 0x8CD7, + GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_OES = 0x8CD7, + GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS = 0x8CD9, + GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT = 0x8CD9, + GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_OES = 0x8CD9, + GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT = 0x8CDA, + GL_FRAMEBUFFER_INCOMPLETE_FORMATS_OES = 0x8CDA, + GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER = 0x8CDB, + GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT = 0x8CDB, + GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_OES = 0x8CDB, + GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER = 0x8CDC, + GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT = 0x8CDC, + GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_OES = 0x8CDC, + GL_FRAMEBUFFER_UNSUPPORTED = 0x8CDD, + GL_FRAMEBUFFER_UNSUPPORTED_EXT = 0x8CDD, + GL_FRAMEBUFFER_UNSUPPORTED_OES = 0x8CDD, + GL_MAX_COLOR_ATTACHMENTS = 0x8CDF, + GL_MAX_COLOR_ATTACHMENTS_EXT = 0x8CDF, + GL_MAX_COLOR_ATTACHMENTS_NV = 0x8CDF, + GL_COLOR_ATTACHMENT0 = 0x8CE0, + GL_COLOR_ATTACHMENT0_EXT = 0x8CE0, + GL_COLOR_ATTACHMENT0_NV = 0x8CE0, + GL_COLOR_ATTACHMENT0_OES = 0x8CE0, + GL_COLOR_ATTACHMENT1 = 0x8CE1, + GL_COLOR_ATTACHMENT1_EXT = 0x8CE1, + GL_COLOR_ATTACHMENT1_NV = 0x8CE1, + GL_COLOR_ATTACHMENT2 = 0x8CE2, + GL_COLOR_ATTACHMENT2_EXT = 0x8CE2, + GL_COLOR_ATTACHMENT2_NV = 0x8CE2, + GL_COLOR_ATTACHMENT3 = 0x8CE3, + GL_COLOR_ATTACHMENT3_EXT = 0x8CE3, + GL_COLOR_ATTACHMENT3_NV = 0x8CE3, + GL_COLOR_ATTACHMENT4 = 0x8CE4, + GL_COLOR_ATTACHMENT4_EXT = 0x8CE4, + GL_COLOR_ATTACHMENT4_NV = 0x8CE4, + GL_COLOR_ATTACHMENT5 = 0x8CE5, + GL_COLOR_ATTACHMENT5_EXT = 0x8CE5, + GL_COLOR_ATTACHMENT5_NV = 0x8CE5, + GL_COLOR_ATTACHMENT6 = 0x8CE6, + GL_COLOR_ATTACHMENT6_EXT = 0x8CE6, + GL_COLOR_ATTACHMENT6_NV = 0x8CE6, + GL_COLOR_ATTACHMENT7 = 0x8CE7, + GL_COLOR_ATTACHMENT7_EXT = 0x8CE7, + GL_COLOR_ATTACHMENT7_NV = 0x8CE7, + GL_COLOR_ATTACHMENT8 = 0x8CE8, + GL_COLOR_ATTACHMENT8_EXT = 0x8CE8, + GL_COLOR_ATTACHMENT8_NV = 0x8CE8, + GL_COLOR_ATTACHMENT9 = 0x8CE9, + GL_COLOR_ATTACHMENT9_EXT = 0x8CE9, + GL_COLOR_ATTACHMENT9_NV = 0x8CE9, + GL_COLOR_ATTACHMENT10 = 0x8CEA, + GL_COLOR_ATTACHMENT10_EXT = 0x8CEA, + GL_COLOR_ATTACHMENT10_NV = 0x8CEA, + GL_COLOR_ATTACHMENT11 = 0x8CEB, + GL_COLOR_ATTACHMENT11_EXT = 0x8CEB, + GL_COLOR_ATTACHMENT11_NV = 0x8CEB, + GL_COLOR_ATTACHMENT12 = 0x8CEC, + GL_COLOR_ATTACHMENT12_EXT = 0x8CEC, + GL_COLOR_ATTACHMENT12_NV = 0x8CEC, + GL_COLOR_ATTACHMENT13 = 0x8CED, + GL_COLOR_ATTACHMENT13_EXT = 0x8CED, + GL_COLOR_ATTACHMENT13_NV = 0x8CED, + GL_COLOR_ATTACHMENT14 = 0x8CEE, + GL_COLOR_ATTACHMENT14_EXT = 0x8CEE, + GL_COLOR_ATTACHMENT14_NV = 0x8CEE, + GL_COLOR_ATTACHMENT15 = 0x8CEF, + GL_COLOR_ATTACHMENT15_EXT = 0x8CEF, + GL_COLOR_ATTACHMENT15_NV = 0x8CEF, + GL_COLOR_ATTACHMENT16 = 0x8CF0, + GL_COLOR_ATTACHMENT17 = 0x8CF1, + GL_COLOR_ATTACHMENT18 = 0x8CF2, + GL_COLOR_ATTACHMENT19 = 0x8CF3, + GL_COLOR_ATTACHMENT20 = 0x8CF4, + GL_COLOR_ATTACHMENT21 = 0x8CF5, + GL_COLOR_ATTACHMENT22 = 0x8CF6, + GL_COLOR_ATTACHMENT23 = 0x8CF7, + GL_COLOR_ATTACHMENT24 = 0x8CF8, + GL_COLOR_ATTACHMENT25 = 0x8CF9, + GL_COLOR_ATTACHMENT26 = 0x8CFA, + GL_COLOR_ATTACHMENT27 = 0x8CFB, + GL_COLOR_ATTACHMENT28 = 0x8CFC, + GL_COLOR_ATTACHMENT29 = 0x8CFD, + GL_COLOR_ATTACHMENT30 = 0x8CFE, + GL_COLOR_ATTACHMENT31 = 0x8CFF, + GL_DEPTH_ATTACHMENT = 0x8D00, + GL_DEPTH_ATTACHMENT_EXT = 0x8D00, + GL_DEPTH_ATTACHMENT_OES = 0x8D00, + GL_STENCIL_ATTACHMENT = 0x8D20, + GL_STENCIL_ATTACHMENT_EXT = 0x8D20, + GL_STENCIL_ATTACHMENT_OES = 0x8D20, + GL_FRAMEBUFFER = 0x8D40, + GL_FRAMEBUFFER_EXT = 0x8D40, + GL_FRAMEBUFFER_OES = 0x8D40, + GL_RENDERBUFFER = 0x8D41, + GL_RENDERBUFFER_EXT = 0x8D41, + GL_RENDERBUFFER_OES = 0x8D41, + GL_RENDERBUFFER_WIDTH = 0x8D42, + GL_RENDERBUFFER_WIDTH_EXT = 0x8D42, + GL_RENDERBUFFER_WIDTH_OES = 0x8D42, + GL_RENDERBUFFER_HEIGHT = 0x8D43, + GL_RENDERBUFFER_HEIGHT_EXT = 0x8D43, + GL_RENDERBUFFER_HEIGHT_OES = 0x8D43, + GL_RENDERBUFFER_INTERNAL_FORMAT = 0x8D44, + GL_RENDERBUFFER_INTERNAL_FORMAT_EXT = 0x8D44, + GL_RENDERBUFFER_INTERNAL_FORMAT_OES = 0x8D44, + GL_STENCIL_INDEX1 = 0x8D46, + GL_STENCIL_INDEX1_EXT = 0x8D46, + GL_STENCIL_INDEX1_OES = 0x8D46, + GL_STENCIL_INDEX4 = 0x8D47, + GL_STENCIL_INDEX4_EXT = 0x8D47, + GL_STENCIL_INDEX4_OES = 0x8D47, + GL_STENCIL_INDEX8 = 0x8D48, + GL_STENCIL_INDEX8_EXT = 0x8D48, + GL_STENCIL_INDEX8_OES = 0x8D48, + GL_STENCIL_INDEX16 = 0x8D49, + GL_STENCIL_INDEX16_EXT = 0x8D49, + GL_RENDERBUFFER_RED_SIZE = 0x8D50, + GL_RENDERBUFFER_RED_SIZE_EXT = 0x8D50, + GL_RENDERBUFFER_RED_SIZE_OES = 0x8D50, + GL_RENDERBUFFER_GREEN_SIZE = 0x8D51, + GL_RENDERBUFFER_GREEN_SIZE_EXT = 0x8D51, + GL_RENDERBUFFER_GREEN_SIZE_OES = 0x8D51, + GL_RENDERBUFFER_BLUE_SIZE = 0x8D52, + GL_RENDERBUFFER_BLUE_SIZE_EXT = 0x8D52, + GL_RENDERBUFFER_BLUE_SIZE_OES = 0x8D52, + GL_RENDERBUFFER_ALPHA_SIZE = 0x8D53, + GL_RENDERBUFFER_ALPHA_SIZE_EXT = 0x8D53, + GL_RENDERBUFFER_ALPHA_SIZE_OES = 0x8D53, + GL_RENDERBUFFER_DEPTH_SIZE = 0x8D54, + GL_RENDERBUFFER_DEPTH_SIZE_EXT = 0x8D54, + GL_RENDERBUFFER_DEPTH_SIZE_OES = 0x8D54, + GL_RENDERBUFFER_STENCIL_SIZE = 0x8D55, + GL_RENDERBUFFER_STENCIL_SIZE_EXT = 0x8D55, + GL_RENDERBUFFER_STENCIL_SIZE_OES = 0x8D55, + GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE = 0x8D56, + GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_ANGLE = 0x8D56, + GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_APPLE = 0x8D56, + GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_EXT = 0x8D56, + GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_NV = 0x8D56, + GL_MAX_SAMPLES = 0x8D57, + GL_MAX_SAMPLES_ANGLE = 0x8D57, + GL_MAX_SAMPLES_APPLE = 0x8D57, + GL_MAX_SAMPLES_EXT = 0x8D57, + GL_MAX_SAMPLES_NV = 0x8D57, + GL_TEXTURE_GEN_STR_OES = 0x8D60, + GL_HALF_FLOAT_OES = 0x8D61, + GL_RGB565_OES = 0x8D62, + GL_RGB565 = 0x8D62, + GL_ETC1_RGB8_OES = 0x8D64, + GL_TEXTURE_EXTERNAL_OES = 0x8D65, + GL_SAMPLER_EXTERNAL_OES = 0x8D66, + GL_TEXTURE_BINDING_EXTERNAL_OES = 0x8D67, + GL_REQUIRED_TEXTURE_IMAGE_UNITS_OES = 0x8D68, + GL_PRIMITIVE_RESTART_FIXED_INDEX = 0x8D69, + GL_ANY_SAMPLES_PASSED_CONSERVATIVE = 0x8D6A, + GL_ANY_SAMPLES_PASSED_CONSERVATIVE_EXT = 0x8D6A, + GL_MAX_ELEMENT_INDEX = 0x8D6B, + GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_SAMPLES_EXT = 0x8D6C, + GL_RGBA32UI = 0x8D70, + GL_RGBA32UI_EXT = 0x8D70, + GL_RGB32UI = 0x8D71, + GL_RGB32UI_EXT = 0x8D71, + GL_ALPHA32UI_EXT = 0x8D72, + GL_INTENSITY32UI_EXT = 0x8D73, + GL_LUMINANCE32UI_EXT = 0x8D74, + GL_LUMINANCE_ALPHA32UI_EXT = 0x8D75, + GL_RGBA16UI = 0x8D76, + GL_RGBA16UI_EXT = 0x8D76, + GL_RGB16UI = 0x8D77, + GL_RGB16UI_EXT = 0x8D77, + GL_ALPHA16UI_EXT = 0x8D78, + GL_INTENSITY16UI_EXT = 0x8D79, + GL_LUMINANCE16UI_EXT = 0x8D7A, + GL_LUMINANCE_ALPHA16UI_EXT = 0x8D7B, + GL_RGBA8UI = 0x8D7C, + GL_RGBA8UI_EXT = 0x8D7C, + GL_RGB8UI = 0x8D7D, + GL_RGB8UI_EXT = 0x8D7D, + GL_ALPHA8UI_EXT = 0x8D7E, + GL_INTENSITY8UI_EXT = 0x8D7F, + GL_LUMINANCE8UI_EXT = 0x8D80, + GL_LUMINANCE_ALPHA8UI_EXT = 0x8D81, + GL_RGBA32I = 0x8D82, + GL_RGBA32I_EXT = 0x8D82, + GL_RGB32I = 0x8D83, + GL_RGB32I_EXT = 0x8D83, + GL_ALPHA32I_EXT = 0x8D84, + GL_INTENSITY32I_EXT = 0x8D85, + GL_LUMINANCE32I_EXT = 0x8D86, + GL_LUMINANCE_ALPHA32I_EXT = 0x8D87, + GL_RGBA16I = 0x8D88, + GL_RGBA16I_EXT = 0x8D88, + GL_RGB16I = 0x8D89, + GL_RGB16I_EXT = 0x8D89, + GL_ALPHA16I_EXT = 0x8D8A, + GL_INTENSITY16I_EXT = 0x8D8B, + GL_LUMINANCE16I_EXT = 0x8D8C, + GL_LUMINANCE_ALPHA16I_EXT = 0x8D8D, + GL_RGBA8I = 0x8D8E, + GL_RGBA8I_EXT = 0x8D8E, + GL_RGB8I = 0x8D8F, + GL_RGB8I_EXT = 0x8D8F, + GL_ALPHA8I_EXT = 0x8D90, + GL_INTENSITY8I_EXT = 0x8D91, + GL_LUMINANCE8I_EXT = 0x8D92, + GL_LUMINANCE_ALPHA8I_EXT = 0x8D93, + GL_RED_INTEGER = 0x8D94, + GL_RED_INTEGER_EXT = 0x8D94, + GL_GREEN_INTEGER = 0x8D95, + GL_GREEN_INTEGER_EXT = 0x8D95, + GL_BLUE_INTEGER = 0x8D96, + GL_BLUE_INTEGER_EXT = 0x8D96, + GL_ALPHA_INTEGER = 0x8D97, + GL_ALPHA_INTEGER_EXT = 0x8D97, + GL_RGB_INTEGER = 0x8D98, + GL_RGB_INTEGER_EXT = 0x8D98, + GL_RGBA_INTEGER = 0x8D99, + GL_RGBA_INTEGER_EXT = 0x8D99, + GL_BGR_INTEGER = 0x8D9A, + GL_BGR_INTEGER_EXT = 0x8D9A, + GL_BGRA_INTEGER = 0x8D9B, + GL_BGRA_INTEGER_EXT = 0x8D9B, + GL_LUMINANCE_INTEGER_EXT = 0x8D9C, + GL_LUMINANCE_ALPHA_INTEGER_EXT = 0x8D9D, + GL_RGBA_INTEGER_MODE_EXT = 0x8D9E, + GL_INT_2_10_10_10_REV = 0x8D9F, + GL_MAX_PROGRAM_PARAMETER_BUFFER_BINDINGS_NV = 0x8DA0, + GL_MAX_PROGRAM_PARAMETER_BUFFER_SIZE_NV = 0x8DA1, + GL_VERTEX_PROGRAM_PARAMETER_BUFFER_NV = 0x8DA2, + GL_GEOMETRY_PROGRAM_PARAMETER_BUFFER_NV = 0x8DA3, + GL_FRAGMENT_PROGRAM_PARAMETER_BUFFER_NV = 0x8DA4, + GL_MAX_PROGRAM_GENERIC_ATTRIBS_NV = 0x8DA5, + GL_MAX_PROGRAM_GENERIC_RESULTS_NV = 0x8DA6, + GL_FRAMEBUFFER_ATTACHMENT_LAYERED = 0x8DA7, + GL_FRAMEBUFFER_ATTACHMENT_LAYERED_ARB = 0x8DA7, + GL_FRAMEBUFFER_ATTACHMENT_LAYERED_EXT = 0x8DA7, + GL_FRAMEBUFFER_ATTACHMENT_LAYERED_OES = 0x8DA7, + GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS = 0x8DA8, + GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_ARB = 0x8DA8, + GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_EXT = 0x8DA8, + GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_OES = 0x8DA8, + GL_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_ARB = 0x8DA9, + GL_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_EXT = 0x8DA9, + GL_LAYER_NV = 0x8DAA, + GL_DEPTH_COMPONENT32F_NV = 0x8DAB, + GL_DEPTH32F_STENCIL8_NV = 0x8DAC, + GL_FLOAT_32_UNSIGNED_INT_24_8_REV = 0x8DAD, + GL_FLOAT_32_UNSIGNED_INT_24_8_REV_NV = 0x8DAD, + GL_SHADER_INCLUDE_ARB = 0x8DAE, + GL_DEPTH_BUFFER_FLOAT_MODE_NV = 0x8DAF, + GL_FRAMEBUFFER_SRGB = 0x8DB9, + GL_FRAMEBUFFER_SRGB_EXT = 0x8DB9, + GL_FRAMEBUFFER_SRGB_CAPABLE_EXT = 0x8DBA, + GL_COMPRESSED_RED_RGTC1 = 0x8DBB, + GL_COMPRESSED_RED_RGTC1_EXT = 0x8DBB, + GL_COMPRESSED_SIGNED_RED_RGTC1 = 0x8DBC, + GL_COMPRESSED_SIGNED_RED_RGTC1_EXT = 0x8DBC, + GL_COMPRESSED_RED_GREEN_RGTC2_EXT = 0x8DBD, + GL_COMPRESSED_RG_RGTC2 = 0x8DBD, + GL_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT = 0x8DBE, + GL_COMPRESSED_SIGNED_RG_RGTC2 = 0x8DBE, + GL_SAMPLER_1D_ARRAY = 0x8DC0, + GL_SAMPLER_1D_ARRAY_EXT = 0x8DC0, + GL_SAMPLER_2D_ARRAY = 0x8DC1, + GL_SAMPLER_2D_ARRAY_EXT = 0x8DC1, + GL_SAMPLER_BUFFER = 0x8DC2, + GL_SAMPLER_BUFFER_EXT = 0x8DC2, + GL_SAMPLER_BUFFER_OES = 0x8DC2, + GL_SAMPLER_1D_ARRAY_SHADOW = 0x8DC3, + GL_SAMPLER_1D_ARRAY_SHADOW_EXT = 0x8DC3, + GL_SAMPLER_2D_ARRAY_SHADOW = 0x8DC4, + GL_SAMPLER_2D_ARRAY_SHADOW_EXT = 0x8DC4, + GL_SAMPLER_2D_ARRAY_SHADOW_NV = 0x8DC4, + GL_SAMPLER_CUBE_SHADOW = 0x8DC5, + GL_SAMPLER_CUBE_SHADOW_EXT = 0x8DC5, + GL_SAMPLER_CUBE_SHADOW_NV = 0x8DC5, + GL_UNSIGNED_INT_VEC2 = 0x8DC6, + GL_UNSIGNED_INT_VEC2_EXT = 0x8DC6, + GL_UNSIGNED_INT_VEC3 = 0x8DC7, + GL_UNSIGNED_INT_VEC3_EXT = 0x8DC7, + GL_UNSIGNED_INT_VEC4 = 0x8DC8, + GL_UNSIGNED_INT_VEC4_EXT = 0x8DC8, + GL_INT_SAMPLER_1D = 0x8DC9, + GL_INT_SAMPLER_1D_EXT = 0x8DC9, + GL_INT_SAMPLER_2D = 0x8DCA, + GL_INT_SAMPLER_2D_EXT = 0x8DCA, + GL_INT_SAMPLER_3D = 0x8DCB, + GL_INT_SAMPLER_3D_EXT = 0x8DCB, + GL_INT_SAMPLER_CUBE = 0x8DCC, + GL_INT_SAMPLER_CUBE_EXT = 0x8DCC, + GL_INT_SAMPLER_2D_RECT = 0x8DCD, + GL_INT_SAMPLER_2D_RECT_EXT = 0x8DCD, + GL_INT_SAMPLER_1D_ARRAY = 0x8DCE, + GL_INT_SAMPLER_1D_ARRAY_EXT = 0x8DCE, + GL_INT_SAMPLER_2D_ARRAY = 0x8DCF, + GL_INT_SAMPLER_2D_ARRAY_EXT = 0x8DCF, + GL_INT_SAMPLER_BUFFER = 0x8DD0, + GL_INT_SAMPLER_BUFFER_EXT = 0x8DD0, + GL_INT_SAMPLER_BUFFER_OES = 0x8DD0, + GL_UNSIGNED_INT_SAMPLER_1D = 0x8DD1, + GL_UNSIGNED_INT_SAMPLER_1D_EXT = 0x8DD1, + GL_UNSIGNED_INT_SAMPLER_2D = 0x8DD2, + GL_UNSIGNED_INT_SAMPLER_2D_EXT = 0x8DD2, + GL_UNSIGNED_INT_SAMPLER_3D = 0x8DD3, + GL_UNSIGNED_INT_SAMPLER_3D_EXT = 0x8DD3, + GL_UNSIGNED_INT_SAMPLER_CUBE = 0x8DD4, + GL_UNSIGNED_INT_SAMPLER_CUBE_EXT = 0x8DD4, + GL_UNSIGNED_INT_SAMPLER_2D_RECT = 0x8DD5, + GL_UNSIGNED_INT_SAMPLER_2D_RECT_EXT = 0x8DD5, + GL_UNSIGNED_INT_SAMPLER_1D_ARRAY = 0x8DD6, + GL_UNSIGNED_INT_SAMPLER_1D_ARRAY_EXT = 0x8DD6, + GL_UNSIGNED_INT_SAMPLER_2D_ARRAY = 0x8DD7, + GL_UNSIGNED_INT_SAMPLER_2D_ARRAY_EXT = 0x8DD7, + GL_UNSIGNED_INT_SAMPLER_BUFFER = 0x8DD8, + GL_UNSIGNED_INT_SAMPLER_BUFFER_EXT = 0x8DD8, + GL_UNSIGNED_INT_SAMPLER_BUFFER_OES = 0x8DD8, + GL_GEOMETRY_SHADER = 0x8DD9, + GL_GEOMETRY_SHADER_ARB = 0x8DD9, + GL_GEOMETRY_SHADER_EXT = 0x8DD9, + GL_GEOMETRY_SHADER_OES = 0x8DD9, + GL_GEOMETRY_VERTICES_OUT_ARB = 0x8DDA, + GL_GEOMETRY_VERTICES_OUT_EXT = 0x8DDA, + GL_GEOMETRY_INPUT_TYPE_ARB = 0x8DDB, + GL_GEOMETRY_INPUT_TYPE_EXT = 0x8DDB, + GL_GEOMETRY_OUTPUT_TYPE_ARB = 0x8DDC, + GL_GEOMETRY_OUTPUT_TYPE_EXT = 0x8DDC, + GL_MAX_GEOMETRY_VARYING_COMPONENTS_ARB = 0x8DDD, + GL_MAX_GEOMETRY_VARYING_COMPONENTS_EXT = 0x8DDD, + GL_MAX_VERTEX_VARYING_COMPONENTS_ARB = 0x8DDE, + GL_MAX_VERTEX_VARYING_COMPONENTS_EXT = 0x8DDE, + GL_MAX_GEOMETRY_UNIFORM_COMPONENTS = 0x8DDF, + GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_ARB = 0x8DDF, + GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_EXT = 0x8DDF, + GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_OES = 0x8DDF, + GL_MAX_GEOMETRY_OUTPUT_VERTICES = 0x8DE0, + GL_MAX_GEOMETRY_OUTPUT_VERTICES_ARB = 0x8DE0, + GL_MAX_GEOMETRY_OUTPUT_VERTICES_EXT = 0x8DE0, + GL_MAX_GEOMETRY_OUTPUT_VERTICES_OES = 0x8DE0, + GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS = 0x8DE1, + GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_ARB = 0x8DE1, + GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_EXT = 0x8DE1, + GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_OES = 0x8DE1, + GL_MAX_VERTEX_BINDABLE_UNIFORMS_EXT = 0x8DE2, + GL_MAX_FRAGMENT_BINDABLE_UNIFORMS_EXT = 0x8DE3, + GL_MAX_GEOMETRY_BINDABLE_UNIFORMS_EXT = 0x8DE4, + GL_ACTIVE_SUBROUTINES = 0x8DE5, + GL_ACTIVE_SUBROUTINE_UNIFORMS = 0x8DE6, + GL_MAX_SUBROUTINES = 0x8DE7, + GL_MAX_SUBROUTINE_UNIFORM_LOCATIONS = 0x8DE8, + GL_NAMED_STRING_LENGTH_ARB = 0x8DE9, + GL_NAMED_STRING_TYPE_ARB = 0x8DEA, + GL_MAX_BINDABLE_UNIFORM_SIZE_EXT = 0x8DED, + GL_UNIFORM_BUFFER_EXT = 0x8DEE, + GL_UNIFORM_BUFFER_BINDING_EXT = 0x8DEF, + GL_LOW_FLOAT = 0x8DF0, + GL_MEDIUM_FLOAT = 0x8DF1, + GL_HIGH_FLOAT = 0x8DF2, + GL_LOW_INT = 0x8DF3, + GL_MEDIUM_INT = 0x8DF4, + GL_HIGH_INT = 0x8DF5, + GL_UNSIGNED_INT_10_10_10_2_OES = 0x8DF6, + GL_INT_10_10_10_2_OES = 0x8DF7, + GL_SHADER_BINARY_FORMATS = 0x8DF8, + GL_NUM_SHADER_BINARY_FORMATS = 0x8DF9, + GL_SHADER_COMPILER = 0x8DFA, + GL_MAX_VERTEX_UNIFORM_VECTORS = 0x8DFB, + GL_MAX_VARYING_VECTORS = 0x8DFC, + GL_MAX_FRAGMENT_UNIFORM_VECTORS = 0x8DFD, + GL_RENDERBUFFER_COLOR_SAMPLES_NV = 0x8E10, + GL_MAX_MULTISAMPLE_COVERAGE_MODES_NV = 0x8E11, + GL_MULTISAMPLE_COVERAGE_MODES_NV = 0x8E12, + GL_QUERY_WAIT = 0x8E13, + GL_QUERY_WAIT_NV = 0x8E13, + GL_QUERY_NO_WAIT = 0x8E14, + GL_QUERY_NO_WAIT_NV = 0x8E14, + GL_QUERY_BY_REGION_WAIT = 0x8E15, + GL_QUERY_BY_REGION_WAIT_NV = 0x8E15, + GL_QUERY_BY_REGION_NO_WAIT = 0x8E16, + GL_QUERY_BY_REGION_NO_WAIT_NV = 0x8E16, + GL_QUERY_WAIT_INVERTED = 0x8E17, + GL_QUERY_NO_WAIT_INVERTED = 0x8E18, + GL_QUERY_BY_REGION_WAIT_INVERTED = 0x8E19, + GL_QUERY_BY_REGION_NO_WAIT_INVERTED = 0x8E1A, + GL_POLYGON_OFFSET_CLAMP = 0x8E1B, + GL_POLYGON_OFFSET_CLAMP_EXT = 0x8E1B, + GL_MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS = 0x8E1E, + GL_MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS_EXT = 0x8E1E, + GL_MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS_OES = 0x8E1E, + GL_MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS = 0x8E1F, + GL_MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS_EXT = 0x8E1F, + GL_MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS_OES = 0x8E1F, + GL_COLOR_SAMPLES_NV = 0x8E20, + GL_TRANSFORM_FEEDBACK = 0x8E22, + GL_TRANSFORM_FEEDBACK_NV = 0x8E22, + GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED = 0x8E23, + GL_TRANSFORM_FEEDBACK_PAUSED = 0x8E23, + GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED_NV = 0x8E23, + GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE = 0x8E24, + GL_TRANSFORM_FEEDBACK_ACTIVE = 0x8E24, + GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE_NV = 0x8E24, + GL_TRANSFORM_FEEDBACK_BINDING = 0x8E25, + GL_TRANSFORM_FEEDBACK_BINDING_NV = 0x8E25, + GL_FRAME_NV = 0x8E26, + GL_FIELDS_NV = 0x8E27, + GL_CURRENT_TIME_NV = 0x8E28, + GL_TIMESTAMP = 0x8E28, + GL_TIMESTAMP_EXT = 0x8E28, + GL_NUM_FILL_STREAMS_NV = 0x8E29, + GL_PRESENT_TIME_NV = 0x8E2A, + GL_PRESENT_DURATION_NV = 0x8E2B, + GL_DEPTH_COMPONENT16_NONLINEAR_NV = 0x8E2C, + GL_PROGRAM_MATRIX_EXT = 0x8E2D, + GL_TRANSPOSE_PROGRAM_MATRIX_EXT = 0x8E2E, + GL_PROGRAM_MATRIX_STACK_DEPTH_EXT = 0x8E2F, + GL_TEXTURE_SWIZZLE_R = 0x8E42, + GL_TEXTURE_SWIZZLE_R_EXT = 0x8E42, + GL_TEXTURE_SWIZZLE_G = 0x8E43, + GL_TEXTURE_SWIZZLE_G_EXT = 0x8E43, + GL_TEXTURE_SWIZZLE_B = 0x8E44, + GL_TEXTURE_SWIZZLE_B_EXT = 0x8E44, + GL_TEXTURE_SWIZZLE_A = 0x8E45, + GL_TEXTURE_SWIZZLE_A_EXT = 0x8E45, + GL_TEXTURE_SWIZZLE_RGBA = 0x8E46, + GL_TEXTURE_SWIZZLE_RGBA_EXT = 0x8E46, + GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS = 0x8E47, + GL_ACTIVE_SUBROUTINE_MAX_LENGTH = 0x8E48, + GL_ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH = 0x8E49, + GL_NUM_COMPATIBLE_SUBROUTINES = 0x8E4A, + GL_COMPATIBLE_SUBROUTINES = 0x8E4B, + GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION = 0x8E4C, + GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION_EXT = 0x8E4C, + GL_FIRST_VERTEX_CONVENTION = 0x8E4D, + GL_FIRST_VERTEX_CONVENTION_EXT = 0x8E4D, + GL_FIRST_VERTEX_CONVENTION_OES = 0x8E4D, + GL_LAST_VERTEX_CONVENTION = 0x8E4E, + GL_LAST_VERTEX_CONVENTION_EXT = 0x8E4E, + GL_LAST_VERTEX_CONVENTION_OES = 0x8E4E, + GL_PROVOKING_VERTEX = 0x8E4F, + GL_PROVOKING_VERTEX_EXT = 0x8E4F, + GL_SAMPLE_POSITION = 0x8E50, + GL_SAMPLE_POSITION_NV = 0x8E50, + GL_SAMPLE_LOCATION_ARB = 0x8E50, + GL_SAMPLE_LOCATION_NV = 0x8E50, + GL_SAMPLE_MASK = 0x8E51, + GL_SAMPLE_MASK_NV = 0x8E51, + GL_SAMPLE_MASK_VALUE = 0x8E52, + GL_SAMPLE_MASK_VALUE_NV = 0x8E52, + GL_TEXTURE_BINDING_RENDERBUFFER_NV = 0x8E53, + GL_TEXTURE_RENDERBUFFER_DATA_STORE_BINDING_NV = 0x8E54, + GL_TEXTURE_RENDERBUFFER_NV = 0x8E55, + GL_SAMPLER_RENDERBUFFER_NV = 0x8E56, + GL_INT_SAMPLER_RENDERBUFFER_NV = 0x8E57, + GL_UNSIGNED_INT_SAMPLER_RENDERBUFFER_NV = 0x8E58, + GL_MAX_SAMPLE_MASK_WORDS = 0x8E59, + GL_MAX_SAMPLE_MASK_WORDS_NV = 0x8E59, + GL_MAX_GEOMETRY_PROGRAM_INVOCATIONS_NV = 0x8E5A, + GL_MAX_GEOMETRY_SHADER_INVOCATIONS = 0x8E5A, + GL_MAX_GEOMETRY_SHADER_INVOCATIONS_EXT = 0x8E5A, + GL_MAX_GEOMETRY_SHADER_INVOCATIONS_OES = 0x8E5A, + GL_MIN_FRAGMENT_INTERPOLATION_OFFSET = 0x8E5B, + GL_MIN_FRAGMENT_INTERPOLATION_OFFSET_OES = 0x8E5B, + GL_MIN_FRAGMENT_INTERPOLATION_OFFSET_NV = 0x8E5B, + GL_MAX_FRAGMENT_INTERPOLATION_OFFSET = 0x8E5C, + GL_MAX_FRAGMENT_INTERPOLATION_OFFSET_OES = 0x8E5C, + GL_MAX_FRAGMENT_INTERPOLATION_OFFSET_NV = 0x8E5C, + GL_FRAGMENT_INTERPOLATION_OFFSET_BITS = 0x8E5D, + GL_FRAGMENT_INTERPOLATION_OFFSET_BITS_OES = 0x8E5D, + GL_FRAGMENT_PROGRAM_INTERPOLATION_OFFSET_BITS_NV = 0x8E5D, + GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET = 0x8E5E, + GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET_ARB = 0x8E5E, + GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET_NV = 0x8E5E, + GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET = 0x8E5F, + GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET_ARB = 0x8E5F, + GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET_NV = 0x8E5F, + GL_MAX_MESH_UNIFORM_BLOCKS_NV = 0x8E60, + GL_MAX_MESH_TEXTURE_IMAGE_UNITS_NV = 0x8E61, + GL_MAX_MESH_IMAGE_UNIFORMS_NV = 0x8E62, + GL_MAX_MESH_UNIFORM_COMPONENTS_NV = 0x8E63, + GL_MAX_MESH_ATOMIC_COUNTER_BUFFERS_NV = 0x8E64, + GL_MAX_MESH_ATOMIC_COUNTERS_NV = 0x8E65, + GL_MAX_MESH_SHADER_STORAGE_BLOCKS_NV = 0x8E66, + GL_MAX_COMBINED_MESH_UNIFORM_COMPONENTS_NV = 0x8E67, + GL_MAX_TASK_UNIFORM_BLOCKS_NV = 0x8E68, + GL_MAX_TASK_TEXTURE_IMAGE_UNITS_NV = 0x8E69, + GL_MAX_TASK_IMAGE_UNIFORMS_NV = 0x8E6A, + GL_MAX_TASK_UNIFORM_COMPONENTS_NV = 0x8E6B, + GL_MAX_TASK_ATOMIC_COUNTER_BUFFERS_NV = 0x8E6C, + GL_MAX_TASK_ATOMIC_COUNTERS_NV = 0x8E6D, + GL_MAX_TASK_SHADER_STORAGE_BLOCKS_NV = 0x8E6E, + GL_MAX_COMBINED_TASK_UNIFORM_COMPONENTS_NV = 0x8E6F, + GL_MAX_TRANSFORM_FEEDBACK_BUFFERS = 0x8E70, + GL_MAX_VERTEX_STREAMS = 0x8E71, + GL_PATCH_VERTICES = 0x8E72, + GL_PATCH_VERTICES_EXT = 0x8E72, + GL_PATCH_VERTICES_OES = 0x8E72, + GL_PATCH_DEFAULT_INNER_LEVEL = 0x8E73, + GL_PATCH_DEFAULT_INNER_LEVEL_EXT = 0x8E73, + GL_PATCH_DEFAULT_OUTER_LEVEL = 0x8E74, + GL_PATCH_DEFAULT_OUTER_LEVEL_EXT = 0x8E74, + GL_TESS_CONTROL_OUTPUT_VERTICES = 0x8E75, + GL_TESS_CONTROL_OUTPUT_VERTICES_EXT = 0x8E75, + GL_TESS_CONTROL_OUTPUT_VERTICES_OES = 0x8E75, + GL_TESS_GEN_MODE = 0x8E76, + GL_TESS_GEN_MODE_EXT = 0x8E76, + GL_TESS_GEN_MODE_OES = 0x8E76, + GL_TESS_GEN_SPACING = 0x8E77, + GL_TESS_GEN_SPACING_EXT = 0x8E77, + GL_TESS_GEN_SPACING_OES = 0x8E77, + GL_TESS_GEN_VERTEX_ORDER = 0x8E78, + GL_TESS_GEN_VERTEX_ORDER_EXT = 0x8E78, + GL_TESS_GEN_VERTEX_ORDER_OES = 0x8E78, + GL_TESS_GEN_POINT_MODE = 0x8E79, + GL_TESS_GEN_POINT_MODE_EXT = 0x8E79, + GL_TESS_GEN_POINT_MODE_OES = 0x8E79, + GL_ISOLINES = 0x8E7A, + GL_ISOLINES_EXT = 0x8E7A, + GL_ISOLINES_OES = 0x8E7A, + GL_FRACTIONAL_ODD = 0x8E7B, + GL_FRACTIONAL_ODD_EXT = 0x8E7B, + GL_FRACTIONAL_ODD_OES = 0x8E7B, + GL_FRACTIONAL_EVEN = 0x8E7C, + GL_FRACTIONAL_EVEN_EXT = 0x8E7C, + GL_FRACTIONAL_EVEN_OES = 0x8E7C, + GL_MAX_PATCH_VERTICES = 0x8E7D, + GL_MAX_PATCH_VERTICES_EXT = 0x8E7D, + GL_MAX_PATCH_VERTICES_OES = 0x8E7D, + GL_MAX_TESS_GEN_LEVEL = 0x8E7E, + GL_MAX_TESS_GEN_LEVEL_EXT = 0x8E7E, + GL_MAX_TESS_GEN_LEVEL_OES = 0x8E7E, + GL_MAX_TESS_CONTROL_UNIFORM_COMPONENTS = 0x8E7F, + GL_MAX_TESS_CONTROL_UNIFORM_COMPONENTS_EXT = 0x8E7F, + GL_MAX_TESS_CONTROL_UNIFORM_COMPONENTS_OES = 0x8E7F, + GL_MAX_TESS_EVALUATION_UNIFORM_COMPONENTS = 0x8E80, + GL_MAX_TESS_EVALUATION_UNIFORM_COMPONENTS_EXT = 0x8E80, + GL_MAX_TESS_EVALUATION_UNIFORM_COMPONENTS_OES = 0x8E80, + GL_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS = 0x8E81, + GL_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS_EXT = 0x8E81, + GL_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS_OES = 0x8E81, + GL_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS = 0x8E82, + GL_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS_EXT = 0x8E82, + GL_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS_OES = 0x8E82, + GL_MAX_TESS_CONTROL_OUTPUT_COMPONENTS = 0x8E83, + GL_MAX_TESS_CONTROL_OUTPUT_COMPONENTS_EXT = 0x8E83, + GL_MAX_TESS_CONTROL_OUTPUT_COMPONENTS_OES = 0x8E83, + GL_MAX_TESS_PATCH_COMPONENTS = 0x8E84, + GL_MAX_TESS_PATCH_COMPONENTS_EXT = 0x8E84, + GL_MAX_TESS_PATCH_COMPONENTS_OES = 0x8E84, + GL_MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS = 0x8E85, + GL_MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS_EXT = 0x8E85, + GL_MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS_OES = 0x8E85, + GL_MAX_TESS_EVALUATION_OUTPUT_COMPONENTS = 0x8E86, + GL_MAX_TESS_EVALUATION_OUTPUT_COMPONENTS_EXT = 0x8E86, + GL_MAX_TESS_EVALUATION_OUTPUT_COMPONENTS_OES = 0x8E86, + GL_TESS_EVALUATION_SHADER = 0x8E87, + GL_TESS_EVALUATION_SHADER_EXT = 0x8E87, + GL_TESS_EVALUATION_SHADER_OES = 0x8E87, + GL_TESS_CONTROL_SHADER = 0x8E88, + GL_TESS_CONTROL_SHADER_EXT = 0x8E88, + GL_TESS_CONTROL_SHADER_OES = 0x8E88, + GL_MAX_TESS_CONTROL_UNIFORM_BLOCKS = 0x8E89, + GL_MAX_TESS_CONTROL_UNIFORM_BLOCKS_EXT = 0x8E89, + GL_MAX_TESS_CONTROL_UNIFORM_BLOCKS_OES = 0x8E89, + GL_MAX_TESS_EVALUATION_UNIFORM_BLOCKS = 0x8E8A, + GL_MAX_TESS_EVALUATION_UNIFORM_BLOCKS_EXT = 0x8E8A, + GL_MAX_TESS_EVALUATION_UNIFORM_BLOCKS_OES = 0x8E8A, + GL_COMPRESSED_RGBA_BPTC_UNORM = 0x8E8C, + GL_COMPRESSED_RGBA_BPTC_UNORM_ARB = 0x8E8C, + GL_COMPRESSED_RGBA_BPTC_UNORM_EXT = 0x8E8C, + GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM = 0x8E8D, + GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM_ARB = 0x8E8D, + GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM_EXT = 0x8E8D, + GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT = 0x8E8E, + GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_ARB = 0x8E8E, + GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_EXT = 0x8E8E, + GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT = 0x8E8F, + GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_ARB = 0x8E8F, + GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_EXT = 0x8E8F, + GL_COVERAGE_COMPONENT_NV = 0x8ED0, + GL_COVERAGE_COMPONENT4_NV = 0x8ED1, + GL_COVERAGE_ATTACHMENT_NV = 0x8ED2, + GL_COVERAGE_BUFFERS_NV = 0x8ED3, + GL_COVERAGE_SAMPLES_NV = 0x8ED4, + GL_COVERAGE_ALL_FRAGMENTS_NV = 0x8ED5, + GL_COVERAGE_EDGE_FRAGMENTS_NV = 0x8ED6, + GL_COVERAGE_AUTOMATIC_NV = 0x8ED7, + GL_INCLUSIVE_EXT = 0x8F10, + GL_EXCLUSIVE_EXT = 0x8F11, + GL_WINDOW_RECTANGLE_EXT = 0x8F12, + GL_WINDOW_RECTANGLE_MODE_EXT = 0x8F13, + GL_MAX_WINDOW_RECTANGLES_EXT = 0x8F14, + GL_NUM_WINDOW_RECTANGLES_EXT = 0x8F15, + GL_BUFFER_GPU_ADDRESS_NV = 0x8F1D, + GL_VERTEX_ATTRIB_ARRAY_UNIFIED_NV = 0x8F1E, + GL_ELEMENT_ARRAY_UNIFIED_NV = 0x8F1F, + GL_VERTEX_ATTRIB_ARRAY_ADDRESS_NV = 0x8F20, + GL_VERTEX_ARRAY_ADDRESS_NV = 0x8F21, + GL_NORMAL_ARRAY_ADDRESS_NV = 0x8F22, + GL_COLOR_ARRAY_ADDRESS_NV = 0x8F23, + GL_INDEX_ARRAY_ADDRESS_NV = 0x8F24, + GL_TEXTURE_COORD_ARRAY_ADDRESS_NV = 0x8F25, + GL_EDGE_FLAG_ARRAY_ADDRESS_NV = 0x8F26, + GL_SECONDARY_COLOR_ARRAY_ADDRESS_NV = 0x8F27, + GL_FOG_COORD_ARRAY_ADDRESS_NV = 0x8F28, + GL_ELEMENT_ARRAY_ADDRESS_NV = 0x8F29, + GL_VERTEX_ATTRIB_ARRAY_LENGTH_NV = 0x8F2A, + GL_VERTEX_ARRAY_LENGTH_NV = 0x8F2B, + GL_NORMAL_ARRAY_LENGTH_NV = 0x8F2C, + GL_COLOR_ARRAY_LENGTH_NV = 0x8F2D, + GL_INDEX_ARRAY_LENGTH_NV = 0x8F2E, + GL_TEXTURE_COORD_ARRAY_LENGTH_NV = 0x8F2F, + GL_EDGE_FLAG_ARRAY_LENGTH_NV = 0x8F30, + GL_SECONDARY_COLOR_ARRAY_LENGTH_NV = 0x8F31, + GL_FOG_COORD_ARRAY_LENGTH_NV = 0x8F32, + GL_ELEMENT_ARRAY_LENGTH_NV = 0x8F33, + GL_GPU_ADDRESS_NV = 0x8F34, + GL_MAX_SHADER_BUFFER_ADDRESS_NV = 0x8F35, + GL_COPY_READ_BUFFER = 0x8F36, + GL_COPY_READ_BUFFER_NV = 0x8F36, + GL_COPY_READ_BUFFER_BINDING = 0x8F36, + GL_COPY_WRITE_BUFFER = 0x8F37, + GL_COPY_WRITE_BUFFER_NV = 0x8F37, + GL_COPY_WRITE_BUFFER_BINDING = 0x8F37, + GL_MAX_IMAGE_UNITS = 0x8F38, + GL_MAX_IMAGE_UNITS_EXT = 0x8F38, + GL_MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS = 0x8F39, + GL_MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS_EXT = 0x8F39, + GL_MAX_COMBINED_SHADER_OUTPUT_RESOURCES = 0x8F39, + GL_IMAGE_BINDING_NAME = 0x8F3A, + GL_IMAGE_BINDING_NAME_EXT = 0x8F3A, + GL_IMAGE_BINDING_LEVEL = 0x8F3B, + GL_IMAGE_BINDING_LEVEL_EXT = 0x8F3B, + GL_IMAGE_BINDING_LAYERED = 0x8F3C, + GL_IMAGE_BINDING_LAYERED_EXT = 0x8F3C, + GL_IMAGE_BINDING_LAYER = 0x8F3D, + GL_IMAGE_BINDING_LAYER_EXT = 0x8F3D, + GL_IMAGE_BINDING_ACCESS = 0x8F3E, + GL_IMAGE_BINDING_ACCESS_EXT = 0x8F3E, + GL_DRAW_INDIRECT_BUFFER = 0x8F3F, + GL_DRAW_INDIRECT_UNIFIED_NV = 0x8F40, + GL_DRAW_INDIRECT_ADDRESS_NV = 0x8F41, + GL_DRAW_INDIRECT_LENGTH_NV = 0x8F42, + GL_DRAW_INDIRECT_BUFFER_BINDING = 0x8F43, + GL_MAX_PROGRAM_SUBROUTINE_PARAMETERS_NV = 0x8F44, + GL_MAX_PROGRAM_SUBROUTINE_NUM_NV = 0x8F45, + GL_DOUBLE_MAT2 = 0x8F46, + GL_DOUBLE_MAT2_EXT = 0x8F46, + GL_DOUBLE_MAT3 = 0x8F47, + GL_DOUBLE_MAT3_EXT = 0x8F47, + GL_DOUBLE_MAT4 = 0x8F48, + GL_DOUBLE_MAT4_EXT = 0x8F48, + GL_DOUBLE_MAT2x3 = 0x8F49, + GL_DOUBLE_MAT2x3_EXT = 0x8F49, + GL_DOUBLE_MAT2x4 = 0x8F4A, + GL_DOUBLE_MAT2x4_EXT = 0x8F4A, + GL_DOUBLE_MAT3x2 = 0x8F4B, + GL_DOUBLE_MAT3x2_EXT = 0x8F4B, + GL_DOUBLE_MAT3x4 = 0x8F4C, + GL_DOUBLE_MAT3x4_EXT = 0x8F4C, + GL_DOUBLE_MAT4x2 = 0x8F4D, + GL_DOUBLE_MAT4x2_EXT = 0x8F4D, + GL_DOUBLE_MAT4x3 = 0x8F4E, + GL_DOUBLE_MAT4x3_EXT = 0x8F4E, + GL_VERTEX_BINDING_BUFFER = 0x8F4F, + GL_MALI_SHADER_BINARY_ARM = 0x8F60, + GL_MALI_PROGRAM_BINARY_ARM = 0x8F61, + GL_MAX_SHADER_PIXEL_LOCAL_STORAGE_FAST_SIZE_EXT = 0x8F63, + GL_SHADER_PIXEL_LOCAL_STORAGE_EXT = 0x8F64, + GL_FETCH_PER_SAMPLE_ARM = 0x8F65, + GL_FRAGMENT_SHADER_FRAMEBUFFER_FETCH_MRT_ARM = 0x8F66, + GL_MAX_SHADER_PIXEL_LOCAL_STORAGE_SIZE_EXT = 0x8F67, + GL_TEXTURE_ASTC_DECODE_PRECISION_EXT = 0x8F69, + GL_TEXTURE_UNNORMALIZED_COORDINATES_ARM = 0x8F6A, + GL_RED_SNORM = 0x8F90, + GL_RG_SNORM = 0x8F91, + GL_RGB_SNORM = 0x8F92, + GL_RGBA_SNORM = 0x8F93, + GL_R8_SNORM = 0x8F94, + GL_RG8_SNORM = 0x8F95, + GL_RGB8_SNORM = 0x8F96, + GL_RGBA8_SNORM = 0x8F97, + GL_R16_SNORM = 0x8F98, + GL_R16_SNORM_EXT = 0x8F98, + GL_RG16_SNORM = 0x8F99, + GL_RG16_SNORM_EXT = 0x8F99, + GL_RGB16_SNORM = 0x8F9A, + GL_RGB16_SNORM_EXT = 0x8F9A, + GL_RGBA16_SNORM = 0x8F9B, + GL_RGBA16_SNORM_EXT = 0x8F9B, + GL_SIGNED_NORMALIZED = 0x8F9C, + GL_PRIMITIVE_RESTART = 0x8F9D, + GL_PRIMITIVE_RESTART_INDEX = 0x8F9E, + GL_MAX_PROGRAM_TEXTURE_GATHER_COMPONENTS_ARB = 0x8F9F, + GL_PERFMON_GLOBAL_MODE_QCOM = 0x8FA0, + GL_MAX_SHADER_SUBSAMPLED_IMAGE_UNITS_QCOM = 0x8FA1, + GL_BINNING_CONTROL_HINT_QCOM = 0x8FB0, + GL_CPU_OPTIMIZED_QCOM = 0x8FB1, + GL_GPU_OPTIMIZED_QCOM = 0x8FB2, + GL_RENDER_DIRECT_TO_FRAMEBUFFER_QCOM = 0x8FB3, + GL_GPU_DISJOINT_EXT = 0x8FBB, + GL_SR8_EXT = 0x8FBD, + GL_SRG8_EXT = 0x8FBE, + GL_TEXTURE_FORMAT_SRGB_OVERRIDE_EXT = 0x8FBF, + GL_SHADER_BINARY_VIV = 0x8FC4, + GL_INT8_NV = 0x8FE0, + GL_INT8_VEC2_NV = 0x8FE1, + GL_INT8_VEC3_NV = 0x8FE2, + GL_INT8_VEC4_NV = 0x8FE3, + GL_INT16_NV = 0x8FE4, + GL_INT16_VEC2_NV = 0x8FE5, + GL_INT16_VEC3_NV = 0x8FE6, + GL_INT16_VEC4_NV = 0x8FE7, + GL_INT64_VEC2_ARB = 0x8FE9, + GL_INT64_VEC2_NV = 0x8FE9, + GL_INT64_VEC3_ARB = 0x8FEA, + GL_INT64_VEC3_NV = 0x8FEA, + GL_INT64_VEC4_ARB = 0x8FEB, + GL_INT64_VEC4_NV = 0x8FEB, + GL_UNSIGNED_INT8_NV = 0x8FEC, + GL_UNSIGNED_INT8_VEC2_NV = 0x8FED, + GL_UNSIGNED_INT8_VEC3_NV = 0x8FEE, + GL_UNSIGNED_INT8_VEC4_NV = 0x8FEF, + GL_UNSIGNED_INT16_NV = 0x8FF0, + GL_UNSIGNED_INT16_VEC2_NV = 0x8FF1, + GL_UNSIGNED_INT16_VEC3_NV = 0x8FF2, + GL_UNSIGNED_INT16_VEC4_NV = 0x8FF3, + GL_UNSIGNED_INT64_VEC2_ARB = 0x8FF5, + GL_UNSIGNED_INT64_VEC2_NV = 0x8FF5, + GL_UNSIGNED_INT64_VEC3_ARB = 0x8FF6, + GL_UNSIGNED_INT64_VEC3_NV = 0x8FF6, + GL_UNSIGNED_INT64_VEC4_ARB = 0x8FF7, + GL_UNSIGNED_INT64_VEC4_NV = 0x8FF7, + GL_FLOAT16_NV = 0x8FF8, + GL_FLOAT16_VEC2_NV = 0x8FF9, + GL_FLOAT16_VEC3_NV = 0x8FFA, + GL_FLOAT16_VEC4_NV = 0x8FFB, + GL_DOUBLE_VEC2 = 0x8FFC, + GL_DOUBLE_VEC2_EXT = 0x8FFC, + GL_DOUBLE_VEC3 = 0x8FFD, + GL_DOUBLE_VEC3_EXT = 0x8FFD, + GL_DOUBLE_VEC4 = 0x8FFE, + GL_DOUBLE_VEC4_EXT = 0x8FFE, + GL_SAMPLER_BUFFER_AMD = 0x9001, + GL_INT_SAMPLER_BUFFER_AMD = 0x9002, + GL_UNSIGNED_INT_SAMPLER_BUFFER_AMD = 0x9003, + GL_TESSELLATION_MODE_AMD = 0x9004, + GL_TESSELLATION_FACTOR_AMD = 0x9005, + GL_DISCRETE_AMD = 0x9006, + GL_CONTINUOUS_AMD = 0x9007, + GL_TEXTURE_CUBE_MAP_ARRAY = 0x9009, + GL_TEXTURE_CUBE_MAP_ARRAY_ARB = 0x9009, + GL_TEXTURE_CUBE_MAP_ARRAY_EXT = 0x9009, + GL_TEXTURE_CUBE_MAP_ARRAY_OES = 0x9009, + GL_TEXTURE_BINDING_CUBE_MAP_ARRAY = 0x900A, + GL_TEXTURE_BINDING_CUBE_MAP_ARRAY_ARB = 0x900A, + GL_TEXTURE_BINDING_CUBE_MAP_ARRAY_EXT = 0x900A, + GL_TEXTURE_BINDING_CUBE_MAP_ARRAY_OES = 0x900A, + GL_PROXY_TEXTURE_CUBE_MAP_ARRAY = 0x900B, + GL_PROXY_TEXTURE_CUBE_MAP_ARRAY_ARB = 0x900B, + GL_SAMPLER_CUBE_MAP_ARRAY = 0x900C, + GL_SAMPLER_CUBE_MAP_ARRAY_ARB = 0x900C, + GL_SAMPLER_CUBE_MAP_ARRAY_EXT = 0x900C, + GL_SAMPLER_CUBE_MAP_ARRAY_OES = 0x900C, + GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW = 0x900D, + GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW_ARB = 0x900D, + GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW_EXT = 0x900D, + GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW_OES = 0x900D, + GL_INT_SAMPLER_CUBE_MAP_ARRAY = 0x900E, + GL_INT_SAMPLER_CUBE_MAP_ARRAY_ARB = 0x900E, + GL_INT_SAMPLER_CUBE_MAP_ARRAY_EXT = 0x900E, + GL_INT_SAMPLER_CUBE_MAP_ARRAY_OES = 0x900E, + GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY = 0x900F, + GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY_ARB = 0x900F, + GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY_EXT = 0x900F, + GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY_OES = 0x900F, + GL_ALPHA_SNORM = 0x9010, + GL_LUMINANCE_SNORM = 0x9011, + GL_LUMINANCE_ALPHA_SNORM = 0x9012, + GL_INTENSITY_SNORM = 0x9013, + GL_ALPHA8_SNORM = 0x9014, + GL_LUMINANCE8_SNORM = 0x9015, + GL_LUMINANCE8_ALPHA8_SNORM = 0x9016, + GL_INTENSITY8_SNORM = 0x9017, + GL_ALPHA16_SNORM = 0x9018, + GL_LUMINANCE16_SNORM = 0x9019, + GL_LUMINANCE16_ALPHA16_SNORM = 0x901A, + GL_INTENSITY16_SNORM = 0x901B, + GL_FACTOR_MIN_AMD = 0x901C, + GL_FACTOR_MAX_AMD = 0x901D, + GL_DEPTH_CLAMP_NEAR_AMD = 0x901E, + GL_DEPTH_CLAMP_FAR_AMD = 0x901F, + GL_VIDEO_BUFFER_NV = 0x9020, + GL_VIDEO_BUFFER_BINDING_NV = 0x9021, + GL_FIELD_UPPER_NV = 0x9022, + GL_FIELD_LOWER_NV = 0x9023, + GL_NUM_VIDEO_CAPTURE_STREAMS_NV = 0x9024, + GL_NEXT_VIDEO_CAPTURE_BUFFER_STATUS_NV = 0x9025, + GL_VIDEO_CAPTURE_TO_422_SUPPORTED_NV = 0x9026, + GL_LAST_VIDEO_CAPTURE_STATUS_NV = 0x9027, + GL_VIDEO_BUFFER_PITCH_NV = 0x9028, + GL_VIDEO_COLOR_CONVERSION_MATRIX_NV = 0x9029, + GL_VIDEO_COLOR_CONVERSION_MAX_NV = 0x902A, + GL_VIDEO_COLOR_CONVERSION_MIN_NV = 0x902B, + GL_VIDEO_COLOR_CONVERSION_OFFSET_NV = 0x902C, + GL_VIDEO_BUFFER_INTERNAL_FORMAT_NV = 0x902D, + GL_PARTIAL_SUCCESS_NV = 0x902E, + GL_SUCCESS_NV = 0x902F, + GL_FAILURE_NV = 0x9030, + GL_YCBYCR8_422_NV = 0x9031, + GL_YCBAYCR8A_4224_NV = 0x9032, + GL_Z6Y10Z6CB10Z6Y10Z6CR10_422_NV = 0x9033, + GL_Z6Y10Z6CB10Z6A10Z6Y10Z6CR10Z6A10_4224_NV = 0x9034, + GL_Z4Y12Z4CB12Z4Y12Z4CR12_422_NV = 0x9035, + GL_Z4Y12Z4CB12Z4A12Z4Y12Z4CR12Z4A12_4224_NV = 0x9036, + GL_Z4Y12Z4CB12Z4CR12_444_NV = 0x9037, + GL_VIDEO_CAPTURE_FRAME_WIDTH_NV = 0x9038, + GL_VIDEO_CAPTURE_FRAME_HEIGHT_NV = 0x9039, + GL_VIDEO_CAPTURE_FIELD_UPPER_HEIGHT_NV = 0x903A, + GL_VIDEO_CAPTURE_FIELD_LOWER_HEIGHT_NV = 0x903B, + GL_VIDEO_CAPTURE_SURFACE_ORIGIN_NV = 0x903C, + GL_TEXTURE_COVERAGE_SAMPLES_NV = 0x9045, + GL_TEXTURE_COLOR_SAMPLES_NV = 0x9046, + GL_GPU_MEMORY_INFO_DEDICATED_VIDMEM_NVX = 0x9047, + GL_GPU_MEMORY_INFO_TOTAL_AVAILABLE_MEMORY_NVX = 0x9048, + GL_GPU_MEMORY_INFO_CURRENT_AVAILABLE_VIDMEM_NVX = 0x9049, + GL_GPU_MEMORY_INFO_EVICTION_COUNT_NVX = 0x904A, + GL_GPU_MEMORY_INFO_EVICTED_MEMORY_NVX = 0x904B, + GL_IMAGE_1D = 0x904C, + GL_IMAGE_1D_EXT = 0x904C, + GL_IMAGE_2D = 0x904D, + GL_IMAGE_2D_EXT = 0x904D, + GL_IMAGE_3D = 0x904E, + GL_IMAGE_3D_EXT = 0x904E, + GL_IMAGE_2D_RECT = 0x904F, + GL_IMAGE_2D_RECT_EXT = 0x904F, + GL_IMAGE_CUBE = 0x9050, + GL_IMAGE_CUBE_EXT = 0x9050, + GL_IMAGE_BUFFER = 0x9051, + GL_IMAGE_BUFFER_EXT = 0x9051, + GL_IMAGE_BUFFER_OES = 0x9051, + GL_IMAGE_1D_ARRAY = 0x9052, + GL_IMAGE_1D_ARRAY_EXT = 0x9052, + GL_IMAGE_2D_ARRAY = 0x9053, + GL_IMAGE_2D_ARRAY_EXT = 0x9053, + GL_IMAGE_CUBE_MAP_ARRAY = 0x9054, + GL_IMAGE_CUBE_MAP_ARRAY_EXT = 0x9054, + GL_IMAGE_CUBE_MAP_ARRAY_OES = 0x9054, + GL_IMAGE_2D_MULTISAMPLE = 0x9055, + GL_IMAGE_2D_MULTISAMPLE_EXT = 0x9055, + GL_IMAGE_2D_MULTISAMPLE_ARRAY = 0x9056, + GL_IMAGE_2D_MULTISAMPLE_ARRAY_EXT = 0x9056, + GL_INT_IMAGE_1D = 0x9057, + GL_INT_IMAGE_1D_EXT = 0x9057, + GL_INT_IMAGE_2D = 0x9058, + GL_INT_IMAGE_2D_EXT = 0x9058, + GL_INT_IMAGE_3D = 0x9059, + GL_INT_IMAGE_3D_EXT = 0x9059, + GL_INT_IMAGE_2D_RECT = 0x905A, + GL_INT_IMAGE_2D_RECT_EXT = 0x905A, + GL_INT_IMAGE_CUBE = 0x905B, + GL_INT_IMAGE_CUBE_EXT = 0x905B, + GL_INT_IMAGE_BUFFER = 0x905C, + GL_INT_IMAGE_BUFFER_EXT = 0x905C, + GL_INT_IMAGE_BUFFER_OES = 0x905C, + GL_INT_IMAGE_1D_ARRAY = 0x905D, + GL_INT_IMAGE_1D_ARRAY_EXT = 0x905D, + GL_INT_IMAGE_2D_ARRAY = 0x905E, + GL_INT_IMAGE_2D_ARRAY_EXT = 0x905E, + GL_INT_IMAGE_CUBE_MAP_ARRAY = 0x905F, + GL_INT_IMAGE_CUBE_MAP_ARRAY_EXT = 0x905F, + GL_INT_IMAGE_CUBE_MAP_ARRAY_OES = 0x905F, + GL_INT_IMAGE_2D_MULTISAMPLE = 0x9060, + GL_INT_IMAGE_2D_MULTISAMPLE_EXT = 0x9060, + GL_INT_IMAGE_2D_MULTISAMPLE_ARRAY = 0x9061, + GL_INT_IMAGE_2D_MULTISAMPLE_ARRAY_EXT = 0x9061, + GL_UNSIGNED_INT_IMAGE_1D = 0x9062, + GL_UNSIGNED_INT_IMAGE_1D_EXT = 0x9062, + GL_UNSIGNED_INT_IMAGE_2D = 0x9063, + GL_UNSIGNED_INT_IMAGE_2D_EXT = 0x9063, + GL_UNSIGNED_INT_IMAGE_3D = 0x9064, + GL_UNSIGNED_INT_IMAGE_3D_EXT = 0x9064, + GL_UNSIGNED_INT_IMAGE_2D_RECT = 0x9065, + GL_UNSIGNED_INT_IMAGE_2D_RECT_EXT = 0x9065, + GL_UNSIGNED_INT_IMAGE_CUBE = 0x9066, + GL_UNSIGNED_INT_IMAGE_CUBE_EXT = 0x9066, + GL_UNSIGNED_INT_IMAGE_BUFFER = 0x9067, + GL_UNSIGNED_INT_IMAGE_BUFFER_EXT = 0x9067, + GL_UNSIGNED_INT_IMAGE_BUFFER_OES = 0x9067, + GL_UNSIGNED_INT_IMAGE_1D_ARRAY = 0x9068, + GL_UNSIGNED_INT_IMAGE_1D_ARRAY_EXT = 0x9068, + GL_UNSIGNED_INT_IMAGE_2D_ARRAY = 0x9069, + GL_UNSIGNED_INT_IMAGE_2D_ARRAY_EXT = 0x9069, + GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY = 0x906A, + GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY_EXT = 0x906A, + GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY_OES = 0x906A, + GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE = 0x906B, + GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_EXT = 0x906B, + GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY = 0x906C, + GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY_EXT = 0x906C, + GL_MAX_IMAGE_SAMPLES = 0x906D, + GL_MAX_IMAGE_SAMPLES_EXT = 0x906D, + GL_IMAGE_BINDING_FORMAT = 0x906E, + GL_IMAGE_BINDING_FORMAT_EXT = 0x906E, + GL_RGB10_A2UI = 0x906F, + GL_PATH_FORMAT_SVG_NV = 0x9070, + GL_PATH_FORMAT_PS_NV = 0x9071, + GL_STANDARD_FONT_NAME_NV = 0x9072, + GL_SYSTEM_FONT_NAME_NV = 0x9073, + GL_FILE_NAME_NV = 0x9074, + GL_PATH_STROKE_WIDTH_NV = 0x9075, + GL_PATH_END_CAPS_NV = 0x9076, + GL_PATH_INITIAL_END_CAP_NV = 0x9077, + GL_PATH_TERMINAL_END_CAP_NV = 0x9078, + GL_PATH_JOIN_STYLE_NV = 0x9079, + GL_PATH_MITER_LIMIT_NV = 0x907A, + GL_PATH_DASH_CAPS_NV = 0x907B, + GL_PATH_INITIAL_DASH_CAP_NV = 0x907C, + GL_PATH_TERMINAL_DASH_CAP_NV = 0x907D, + GL_PATH_DASH_OFFSET_NV = 0x907E, + GL_PATH_CLIENT_LENGTH_NV = 0x907F, + GL_PATH_FILL_MODE_NV = 0x9080, + GL_PATH_FILL_MASK_NV = 0x9081, + GL_PATH_FILL_COVER_MODE_NV = 0x9082, + GL_PATH_STROKE_COVER_MODE_NV = 0x9083, + GL_PATH_STROKE_MASK_NV = 0x9084, + GL_COUNT_UP_NV = 0x9088, + GL_COUNT_DOWN_NV = 0x9089, + GL_PATH_OBJECT_BOUNDING_BOX_NV = 0x908A, + GL_CONVEX_HULL_NV = 0x908B, + GL_BOUNDING_BOX_NV = 0x908D, + GL_TRANSLATE_X_NV = 0x908E, + GL_TRANSLATE_Y_NV = 0x908F, + GL_TRANSLATE_2D_NV = 0x9090, + GL_TRANSLATE_3D_NV = 0x9091, + GL_AFFINE_2D_NV = 0x9092, + GL_AFFINE_3D_NV = 0x9094, + GL_TRANSPOSE_AFFINE_2D_NV = 0x9096, + GL_TRANSPOSE_AFFINE_3D_NV = 0x9098, + GL_UTF8_NV = 0x909A, + GL_UTF16_NV = 0x909B, + GL_BOUNDING_BOX_OF_BOUNDING_BOXES_NV = 0x909C, + GL_PATH_COMMAND_COUNT_NV = 0x909D, + GL_PATH_COORD_COUNT_NV = 0x909E, + GL_PATH_DASH_ARRAY_COUNT_NV = 0x909F, + GL_PATH_COMPUTED_LENGTH_NV = 0x90A0, + GL_PATH_FILL_BOUNDING_BOX_NV = 0x90A1, + GL_PATH_STROKE_BOUNDING_BOX_NV = 0x90A2, + GL_SQUARE_NV = 0x90A3, + GL_ROUND_NV = 0x90A4, + GL_TRIANGULAR_NV = 0x90A5, + GL_BEVEL_NV = 0x90A6, + GL_MITER_REVERT_NV = 0x90A7, + GL_MITER_TRUNCATE_NV = 0x90A8, + GL_SKIP_MISSING_GLYPH_NV = 0x90A9, + GL_USE_MISSING_GLYPH_NV = 0x90AA, + GL_PATH_ERROR_POSITION_NV = 0x90AB, + GL_PATH_FOG_GEN_MODE_NV = 0x90AC, + GL_ACCUM_ADJACENT_PAIRS_NV = 0x90AD, + GL_ADJACENT_PAIRS_NV = 0x90AE, + GL_FIRST_TO_REST_NV = 0x90AF, + GL_PATH_GEN_MODE_NV = 0x90B0, + GL_PATH_GEN_COEFF_NV = 0x90B1, + GL_PATH_GEN_COLOR_FORMAT_NV = 0x90B2, + GL_PATH_GEN_COMPONENTS_NV = 0x90B3, + GL_PATH_DASH_OFFSET_RESET_NV = 0x90B4, + GL_MOVE_TO_RESETS_NV = 0x90B5, + GL_MOVE_TO_CONTINUES_NV = 0x90B6, + GL_PATH_STENCIL_FUNC_NV = 0x90B7, + GL_PATH_STENCIL_REF_NV = 0x90B8, + GL_PATH_STENCIL_VALUE_MASK_NV = 0x90B9, + GL_SCALED_RESOLVE_FASTEST_EXT = 0x90BA, + GL_SCALED_RESOLVE_NICEST_EXT = 0x90BB, + GL_MIN_MAP_BUFFER_ALIGNMENT = 0x90BC, + GL_PATH_STENCIL_DEPTH_OFFSET_FACTOR_NV = 0x90BD, + GL_PATH_STENCIL_DEPTH_OFFSET_UNITS_NV = 0x90BE, + GL_PATH_COVER_DEPTH_FUNC_NV = 0x90BF, + GL_IMAGE_FORMAT_COMPATIBILITY_TYPE = 0x90C7, + GL_IMAGE_FORMAT_COMPATIBILITY_BY_SIZE = 0x90C8, + GL_IMAGE_FORMAT_COMPATIBILITY_BY_CLASS = 0x90C9, + GL_MAX_VERTEX_IMAGE_UNIFORMS = 0x90CA, + GL_MAX_TESS_CONTROL_IMAGE_UNIFORMS = 0x90CB, + GL_MAX_TESS_CONTROL_IMAGE_UNIFORMS_EXT = 0x90CB, + GL_MAX_TESS_CONTROL_IMAGE_UNIFORMS_OES = 0x90CB, + GL_MAX_TESS_EVALUATION_IMAGE_UNIFORMS = 0x90CC, + GL_MAX_TESS_EVALUATION_IMAGE_UNIFORMS_EXT = 0x90CC, + GL_MAX_TESS_EVALUATION_IMAGE_UNIFORMS_OES = 0x90CC, + GL_MAX_GEOMETRY_IMAGE_UNIFORMS = 0x90CD, + GL_MAX_GEOMETRY_IMAGE_UNIFORMS_EXT = 0x90CD, + GL_MAX_GEOMETRY_IMAGE_UNIFORMS_OES = 0x90CD, + GL_MAX_FRAGMENT_IMAGE_UNIFORMS = 0x90CE, + GL_MAX_COMBINED_IMAGE_UNIFORMS = 0x90CF, + GL_MAX_DEEP_3D_TEXTURE_WIDTH_HEIGHT_NV = 0x90D0, + GL_MAX_DEEP_3D_TEXTURE_DEPTH_NV = 0x90D1, + GL_SHADER_STORAGE_BUFFER = 0x90D2, + GL_SHADER_STORAGE_BUFFER_BINDING = 0x90D3, + GL_SHADER_STORAGE_BUFFER_START = 0x90D4, + GL_SHADER_STORAGE_BUFFER_SIZE = 0x90D5, + GL_MAX_VERTEX_SHADER_STORAGE_BLOCKS = 0x90D6, + GL_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS = 0x90D7, + GL_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS_EXT = 0x90D7, + GL_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS_OES = 0x90D7, + GL_MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS = 0x90D8, + GL_MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS_EXT = 0x90D8, + GL_MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS_OES = 0x90D8, + GL_MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS = 0x90D9, + GL_MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS_EXT = 0x90D9, + GL_MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS_OES = 0x90D9, + GL_MAX_FRAGMENT_SHADER_STORAGE_BLOCKS = 0x90DA, + GL_MAX_COMPUTE_SHADER_STORAGE_BLOCKS = 0x90DB, + GL_MAX_COMBINED_SHADER_STORAGE_BLOCKS = 0x90DC, + GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS = 0x90DD, + GL_MAX_SHADER_STORAGE_BLOCK_SIZE = 0x90DE, + GL_SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT = 0x90DF, + GL_SYNC_X11_FENCE_EXT = 0x90E1, + GL_DEPTH_STENCIL_TEXTURE_MODE = 0x90EA, + GL_MAX_COMPUTE_WORK_GROUP_INVOCATIONS = 0x90EB, + GL_MAX_COMPUTE_FIXED_GROUP_INVOCATIONS_ARB = 0x90EB, + GL_UNIFORM_BLOCK_REFERENCED_BY_COMPUTE_SHADER = 0x90EC, + GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_COMPUTE_SHADER = 0x90ED, + GL_DISPATCH_INDIRECT_BUFFER = 0x90EE, + GL_DISPATCH_INDIRECT_BUFFER_BINDING = 0x90EF, + GL_COLOR_ATTACHMENT_EXT = 0x90F0, + GL_MULTIVIEW_EXT = 0x90F1, + GL_MAX_MULTIVIEW_BUFFERS_EXT = 0x90F2, + GL_CONTEXT_ROBUST_ACCESS = 0x90F3, + GL_CONTEXT_ROBUST_ACCESS_EXT = 0x90F3, + GL_CONTEXT_ROBUST_ACCESS_KHR = 0x90F3, + GL_COMPUTE_PROGRAM_NV = 0x90FB, + GL_COMPUTE_PROGRAM_PARAMETER_BUFFER_NV = 0x90FC, + GL_TEXTURE_2D_MULTISAMPLE = 0x9100, + GL_PROXY_TEXTURE_2D_MULTISAMPLE = 0x9101, + GL_TEXTURE_2D_MULTISAMPLE_ARRAY = 0x9102, + GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES = 0x9102, + GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY = 0x9103, + GL_TEXTURE_BINDING_2D_MULTISAMPLE = 0x9104, + GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY = 0x9105, + GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY_OES = 0x9105, + GL_TEXTURE_SAMPLES = 0x9106, + GL_TEXTURE_FIXED_SAMPLE_LOCATIONS = 0x9107, + GL_SAMPLER_2D_MULTISAMPLE = 0x9108, + GL_INT_SAMPLER_2D_MULTISAMPLE = 0x9109, + GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE = 0x910A, + GL_SAMPLER_2D_MULTISAMPLE_ARRAY = 0x910B, + GL_SAMPLER_2D_MULTISAMPLE_ARRAY_OES = 0x910B, + GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY = 0x910C, + GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY_OES = 0x910C, + GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY = 0x910D, + GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY_OES = 0x910D, + GL_MAX_COLOR_TEXTURE_SAMPLES = 0x910E, + GL_MAX_DEPTH_TEXTURE_SAMPLES = 0x910F, + GL_MAX_INTEGER_SAMPLES = 0x9110, + GL_MAX_SERVER_WAIT_TIMEOUT = 0x9111, + GL_MAX_SERVER_WAIT_TIMEOUT_APPLE = 0x9111, + GL_OBJECT_TYPE = 0x9112, + GL_OBJECT_TYPE_APPLE = 0x9112, + GL_SYNC_CONDITION = 0x9113, + GL_SYNC_CONDITION_APPLE = 0x9113, + GL_SYNC_STATUS = 0x9114, + GL_SYNC_STATUS_APPLE = 0x9114, + GL_SYNC_FLAGS = 0x9115, + GL_SYNC_FLAGS_APPLE = 0x9115, + GL_SYNC_FENCE = 0x9116, + GL_SYNC_FENCE_APPLE = 0x9116, + GL_SYNC_GPU_COMMANDS_COMPLETE = 0x9117, + GL_SYNC_GPU_COMMANDS_COMPLETE_APPLE = 0x9117, + GL_UNSIGNALED = 0x9118, + GL_UNSIGNALED_APPLE = 0x9118, + GL_SIGNALED = 0x9119, + GL_SIGNALED_APPLE = 0x9119, + GL_ALREADY_SIGNALED = 0x911A, + GL_ALREADY_SIGNALED_APPLE = 0x911A, + GL_TIMEOUT_EXPIRED = 0x911B, + GL_TIMEOUT_EXPIRED_APPLE = 0x911B, + GL_CONDITION_SATISFIED = 0x911C, + GL_CONDITION_SATISFIED_APPLE = 0x911C, + GL_WAIT_FAILED = 0x911D, + GL_WAIT_FAILED_APPLE = 0x911D, + GL_BUFFER_ACCESS_FLAGS = 0x911F, + GL_BUFFER_MAP_LENGTH = 0x9120, + GL_BUFFER_MAP_OFFSET = 0x9121, + GL_MAX_VERTEX_OUTPUT_COMPONENTS = 0x9122, + GL_MAX_GEOMETRY_INPUT_COMPONENTS = 0x9123, + GL_MAX_GEOMETRY_INPUT_COMPONENTS_EXT = 0x9123, + GL_MAX_GEOMETRY_INPUT_COMPONENTS_OES = 0x9123, + GL_MAX_GEOMETRY_OUTPUT_COMPONENTS = 0x9124, + GL_MAX_GEOMETRY_OUTPUT_COMPONENTS_EXT = 0x9124, + GL_MAX_GEOMETRY_OUTPUT_COMPONENTS_OES = 0x9124, + GL_MAX_FRAGMENT_INPUT_COMPONENTS = 0x9125, + GL_CONTEXT_PROFILE_MASK = 0x9126, + GL_UNPACK_COMPRESSED_BLOCK_WIDTH = 0x9127, + GL_UNPACK_COMPRESSED_BLOCK_HEIGHT = 0x9128, + GL_UNPACK_COMPRESSED_BLOCK_DEPTH = 0x9129, + GL_UNPACK_COMPRESSED_BLOCK_SIZE = 0x912A, + GL_PACK_COMPRESSED_BLOCK_WIDTH = 0x912B, + GL_PACK_COMPRESSED_BLOCK_HEIGHT = 0x912C, + GL_PACK_COMPRESSED_BLOCK_DEPTH = 0x912D, + GL_PACK_COMPRESSED_BLOCK_SIZE = 0x912E, + GL_TEXTURE_IMMUTABLE_FORMAT = 0x912F, + GL_TEXTURE_IMMUTABLE_FORMAT_EXT = 0x912F, + GL_SGX_PROGRAM_BINARY_IMG = 0x9130, + GL_RENDERBUFFER_SAMPLES_IMG = 0x9133, + GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_IMG = 0x9134, + GL_MAX_SAMPLES_IMG = 0x9135, + GL_TEXTURE_SAMPLES_IMG = 0x9136, + GL_COMPRESSED_RGBA_PVRTC_2BPPV2_IMG = 0x9137, + GL_COMPRESSED_RGBA_PVRTC_4BPPV2_IMG = 0x9138, + GL_CUBIC_IMG = 0x9139, + GL_CUBIC_MIPMAP_NEAREST_IMG = 0x913A, + GL_CUBIC_MIPMAP_LINEAR_IMG = 0x913B, + GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_AND_DOWNSAMPLE_IMG = 0x913C, + GL_NUM_DOWNSAMPLE_SCALES_IMG = 0x913D, + GL_DOWNSAMPLE_SCALES_IMG = 0x913E, + GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_SCALE_IMG = 0x913F, + GL_MAX_DEBUG_MESSAGE_LENGTH = 0x9143, + GL_MAX_DEBUG_MESSAGE_LENGTH_AMD = 0x9143, + GL_MAX_DEBUG_MESSAGE_LENGTH_ARB = 0x9143, + GL_MAX_DEBUG_MESSAGE_LENGTH_KHR = 0x9143, + GL_MAX_DEBUG_LOGGED_MESSAGES = 0x9144, + GL_MAX_DEBUG_LOGGED_MESSAGES_AMD = 0x9144, + GL_MAX_DEBUG_LOGGED_MESSAGES_ARB = 0x9144, + GL_MAX_DEBUG_LOGGED_MESSAGES_KHR = 0x9144, + GL_DEBUG_LOGGED_MESSAGES = 0x9145, + GL_DEBUG_LOGGED_MESSAGES_AMD = 0x9145, + GL_DEBUG_LOGGED_MESSAGES_ARB = 0x9145, + GL_DEBUG_LOGGED_MESSAGES_KHR = 0x9145, + GL_DEBUG_SEVERITY_HIGH = 0x9146, + GL_DEBUG_SEVERITY_HIGH_AMD = 0x9146, + GL_DEBUG_SEVERITY_HIGH_ARB = 0x9146, + GL_DEBUG_SEVERITY_HIGH_KHR = 0x9146, + GL_DEBUG_SEVERITY_MEDIUM = 0x9147, + GL_DEBUG_SEVERITY_MEDIUM_AMD = 0x9147, + GL_DEBUG_SEVERITY_MEDIUM_ARB = 0x9147, + GL_DEBUG_SEVERITY_MEDIUM_KHR = 0x9147, + GL_DEBUG_SEVERITY_LOW = 0x9148, + GL_DEBUG_SEVERITY_LOW_AMD = 0x9148, + GL_DEBUG_SEVERITY_LOW_ARB = 0x9148, + GL_DEBUG_SEVERITY_LOW_KHR = 0x9148, + GL_DEBUG_CATEGORY_API_ERROR_AMD = 0x9149, + GL_DEBUG_CATEGORY_WINDOW_SYSTEM_AMD = 0x914A, + GL_DEBUG_CATEGORY_DEPRECATION_AMD = 0x914B, + GL_DEBUG_CATEGORY_UNDEFINED_BEHAVIOR_AMD = 0x914C, + GL_DEBUG_CATEGORY_PERFORMANCE_AMD = 0x914D, + GL_DEBUG_CATEGORY_SHADER_COMPILER_AMD = 0x914E, + GL_DEBUG_CATEGORY_APPLICATION_AMD = 0x914F, + GL_DEBUG_CATEGORY_OTHER_AMD = 0x9150, + GL_BUFFER_OBJECT_EXT = 0x9151, + GL_DATA_BUFFER_AMD = 0x9151, + GL_PERFORMANCE_MONITOR_AMD = 0x9152, + GL_QUERY_OBJECT_AMD = 0x9153, + GL_QUERY_OBJECT_EXT = 0x9153, + GL_VERTEX_ARRAY_OBJECT_AMD = 0x9154, + GL_VERTEX_ARRAY_OBJECT_EXT = 0x9154, + GL_SAMPLER_OBJECT_AMD = 0x9155, + GL_EXTERNAL_VIRTUAL_MEMORY_BUFFER_AMD = 0x9160, + GL_QUERY_BUFFER = 0x9192, + GL_QUERY_BUFFER_AMD = 0x9192, + GL_QUERY_BUFFER_BINDING = 0x9193, + GL_QUERY_BUFFER_BINDING_AMD = 0x9193, + GL_QUERY_RESULT_NO_WAIT = 0x9194, + GL_QUERY_RESULT_NO_WAIT_AMD = 0x9194, + GL_VIRTUAL_PAGE_SIZE_X_ARB = 0x9195, + GL_VIRTUAL_PAGE_SIZE_X_EXT = 0x9195, + GL_VIRTUAL_PAGE_SIZE_X_AMD = 0x9195, + GL_VIRTUAL_PAGE_SIZE_Y_ARB = 0x9196, + GL_VIRTUAL_PAGE_SIZE_Y_EXT = 0x9196, + GL_VIRTUAL_PAGE_SIZE_Y_AMD = 0x9196, + GL_VIRTUAL_PAGE_SIZE_Z_ARB = 0x9197, + GL_VIRTUAL_PAGE_SIZE_Z_EXT = 0x9197, + GL_VIRTUAL_PAGE_SIZE_Z_AMD = 0x9197, + GL_MAX_SPARSE_TEXTURE_SIZE_ARB = 0x9198, + GL_MAX_SPARSE_TEXTURE_SIZE_EXT = 0x9198, + GL_MAX_SPARSE_TEXTURE_SIZE_AMD = 0x9198, + GL_MAX_SPARSE_3D_TEXTURE_SIZE_ARB = 0x9199, + GL_MAX_SPARSE_3D_TEXTURE_SIZE_EXT = 0x9199, + GL_MAX_SPARSE_3D_TEXTURE_SIZE_AMD = 0x9199, + GL_MAX_SPARSE_ARRAY_TEXTURE_LAYERS = 0x919A, + GL_MAX_SPARSE_ARRAY_TEXTURE_LAYERS_ARB = 0x919A, + GL_MAX_SPARSE_ARRAY_TEXTURE_LAYERS_EXT = 0x919A, + GL_MIN_SPARSE_LEVEL_AMD = 0x919B, + GL_MIN_LOD_WARNING_AMD = 0x919C, + GL_TEXTURE_BUFFER_OFFSET = 0x919D, + GL_TEXTURE_BUFFER_OFFSET_EXT = 0x919D, + GL_TEXTURE_BUFFER_OFFSET_OES = 0x919D, + GL_TEXTURE_BUFFER_SIZE = 0x919E, + GL_TEXTURE_BUFFER_SIZE_EXT = 0x919E, + GL_TEXTURE_BUFFER_SIZE_OES = 0x919E, + GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT = 0x919F, + GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT_EXT = 0x919F, + GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT_OES = 0x919F, + GL_STREAM_RASTERIZATION_AMD = 0x91A0, + GL_VERTEX_ELEMENT_SWIZZLE_AMD = 0x91A4, + GL_VERTEX_ID_SWIZZLE_AMD = 0x91A5, + GL_TEXTURE_SPARSE_ARB = 0x91A6, + GL_TEXTURE_SPARSE_EXT = 0x91A6, + GL_VIRTUAL_PAGE_SIZE_INDEX_ARB = 0x91A7, + GL_VIRTUAL_PAGE_SIZE_INDEX_EXT = 0x91A7, + GL_NUM_VIRTUAL_PAGE_SIZES_ARB = 0x91A8, + GL_NUM_VIRTUAL_PAGE_SIZES_EXT = 0x91A8, + GL_SPARSE_TEXTURE_FULL_ARRAY_CUBE_MIPMAPS_ARB = 0x91A9, + GL_SPARSE_TEXTURE_FULL_ARRAY_CUBE_MIPMAPS_EXT = 0x91A9, + GL_NUM_SPARSE_LEVELS_ARB = 0x91AA, + GL_NUM_SPARSE_LEVELS_EXT = 0x91AA, + GL_PIXELS_PER_SAMPLE_PATTERN_X_AMD = 0x91AE, + GL_PIXELS_PER_SAMPLE_PATTERN_Y_AMD = 0x91AF, + GL_MAX_SHADER_COMPILER_THREADS_KHR = 0x91B0, + GL_MAX_SHADER_COMPILER_THREADS_ARB = 0x91B0, + GL_COMPLETION_STATUS_KHR = 0x91B1, + GL_COMPLETION_STATUS_ARB = 0x91B1, + GL_RENDERBUFFER_STORAGE_SAMPLES_AMD = 0x91B2, + GL_MAX_COLOR_FRAMEBUFFER_SAMPLES_AMD = 0x91B3, + GL_MAX_COLOR_FRAMEBUFFER_STORAGE_SAMPLES_AMD = 0x91B4, + GL_MAX_DEPTH_STENCIL_FRAMEBUFFER_SAMPLES_AMD = 0x91B5, + GL_NUM_SUPPORTED_MULTISAMPLE_MODES_AMD = 0x91B6, + GL_SUPPORTED_MULTISAMPLE_MODES_AMD = 0x91B7, + GL_COMPUTE_SHADER = 0x91B9, + GL_MAX_COMPUTE_UNIFORM_BLOCKS = 0x91BB, + GL_MAX_COMPUTE_TEXTURE_IMAGE_UNITS = 0x91BC, + GL_MAX_COMPUTE_IMAGE_UNIFORMS = 0x91BD, + GL_MAX_COMPUTE_WORK_GROUP_COUNT = 0x91BE, + GL_MAX_COMPUTE_WORK_GROUP_SIZE = 0x91BF, + GL_MAX_COMPUTE_FIXED_GROUP_SIZE_ARB = 0x91BF, + GL_FLOAT16_MAT2_AMD = 0x91C5, + GL_FLOAT16_MAT3_AMD = 0x91C6, + GL_FLOAT16_MAT4_AMD = 0x91C7, + GL_FLOAT16_MAT2x3_AMD = 0x91C8, + GL_FLOAT16_MAT2x4_AMD = 0x91C9, + GL_FLOAT16_MAT3x2_AMD = 0x91CA, + GL_FLOAT16_MAT3x4_AMD = 0x91CB, + GL_FLOAT16_MAT4x2_AMD = 0x91CC, + GL_FLOAT16_MAT4x3_AMD = 0x91CD, + GL_UNPACK_FLIP_Y_WEBGL = 0x9240, + GL_UNPACK_PREMULTIPLY_ALPHA_WEBGL = 0x9241, + GL_CONTEXT_LOST_WEBGL = 0x9242, + GL_UNPACK_COLORSPACE_CONVERSION_WEBGL = 0x9243, + GL_BROWSER_DEFAULT_WEBGL = 0x9244, + GL_SHADER_BINARY_DMP = 0x9250, + GL_SMAPHS30_PROGRAM_BINARY_DMP = 0x9251, + GL_SMAPHS_PROGRAM_BINARY_DMP = 0x9252, + GL_DMP_PROGRAM_BINARY_DMP = 0x9253, + GL_GCCSO_SHADER_BINARY_FJ = 0x9260, + GL_COMPRESSED_R11_EAC = 0x9270, + GL_COMPRESSED_R11_EAC_OES = 0x9270, + GL_COMPRESSED_SIGNED_R11_EAC = 0x9271, + GL_COMPRESSED_SIGNED_R11_EAC_OES = 0x9271, + GL_COMPRESSED_RG11_EAC = 0x9272, + GL_COMPRESSED_RG11_EAC_OES = 0x9272, + GL_COMPRESSED_SIGNED_RG11_EAC = 0x9273, + GL_COMPRESSED_SIGNED_RG11_EAC_OES = 0x9273, + GL_COMPRESSED_RGB8_ETC2 = 0x9274, + GL_COMPRESSED_RGB8_ETC2_OES = 0x9274, + GL_COMPRESSED_SRGB8_ETC2 = 0x9275, + GL_COMPRESSED_SRGB8_ETC2_OES = 0x9275, + GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 = 0x9276, + GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2_OES = 0x9276, + GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 = 0x9277, + GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2_OES = 0x9277, + GL_COMPRESSED_RGBA8_ETC2_EAC = 0x9278, + GL_COMPRESSED_RGBA8_ETC2_EAC_OES = 0x9278, + GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC = 0x9279, + GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC_OES = 0x9279, + GL_BLEND_PREMULTIPLIED_SRC_NV = 0x9280, + GL_BLEND_OVERLAP_NV = 0x9281, + GL_UNCORRELATED_NV = 0x9282, + GL_DISJOINT_NV = 0x9283, + GL_CONJOINT_NV = 0x9284, + GL_BLEND_ADVANCED_COHERENT_KHR = 0x9285, + GL_BLEND_ADVANCED_COHERENT_NV = 0x9285, + GL_SRC_NV = 0x9286, + GL_DST_NV = 0x9287, + GL_SRC_OVER_NV = 0x9288, + GL_DST_OVER_NV = 0x9289, + GL_SRC_IN_NV = 0x928A, + GL_DST_IN_NV = 0x928B, + GL_SRC_OUT_NV = 0x928C, + GL_DST_OUT_NV = 0x928D, + GL_SRC_ATOP_NV = 0x928E, + GL_DST_ATOP_NV = 0x928F, + GL_PLUS_NV = 0x9291, + GL_PLUS_DARKER_NV = 0x9292, + GL_MULTIPLY = 0x9294, + GL_MULTIPLY_KHR = 0x9294, + GL_MULTIPLY_NV = 0x9294, + GL_SCREEN = 0x9295, + GL_SCREEN_KHR = 0x9295, + GL_SCREEN_NV = 0x9295, + GL_OVERLAY = 0x9296, + GL_OVERLAY_KHR = 0x9296, + GL_OVERLAY_NV = 0x9296, + GL_DARKEN = 0x9297, + GL_DARKEN_KHR = 0x9297, + GL_DARKEN_NV = 0x9297, + GL_LIGHTEN = 0x9298, + GL_LIGHTEN_KHR = 0x9298, + GL_LIGHTEN_NV = 0x9298, + GL_COLORDODGE = 0x9299, + GL_COLORDODGE_KHR = 0x9299, + GL_COLORDODGE_NV = 0x9299, + GL_COLORBURN = 0x929A, + GL_COLORBURN_KHR = 0x929A, + GL_COLORBURN_NV = 0x929A, + GL_HARDLIGHT = 0x929B, + GL_HARDLIGHT_KHR = 0x929B, + GL_HARDLIGHT_NV = 0x929B, + GL_SOFTLIGHT = 0x929C, + GL_SOFTLIGHT_KHR = 0x929C, + GL_SOFTLIGHT_NV = 0x929C, + GL_DIFFERENCE = 0x929E, + GL_DIFFERENCE_KHR = 0x929E, + GL_DIFFERENCE_NV = 0x929E, + GL_MINUS_NV = 0x929F, + GL_EXCLUSION = 0x92A0, + GL_EXCLUSION_KHR = 0x92A0, + GL_EXCLUSION_NV = 0x92A0, + GL_CONTRAST_NV = 0x92A1, + GL_INVERT_RGB_NV = 0x92A3, + GL_LINEARDODGE_NV = 0x92A4, + GL_LINEARBURN_NV = 0x92A5, + GL_VIVIDLIGHT_NV = 0x92A6, + GL_LINEARLIGHT_NV = 0x92A7, + GL_PINLIGHT_NV = 0x92A8, + GL_HARDMIX_NV = 0x92A9, + GL_HSL_HUE = 0x92AD, + GL_HSL_HUE_KHR = 0x92AD, + GL_HSL_HUE_NV = 0x92AD, + GL_HSL_SATURATION = 0x92AE, + GL_HSL_SATURATION_KHR = 0x92AE, + GL_HSL_SATURATION_NV = 0x92AE, + GL_HSL_COLOR = 0x92AF, + GL_HSL_COLOR_KHR = 0x92AF, + GL_HSL_COLOR_NV = 0x92AF, + GL_HSL_LUMINOSITY = 0x92B0, + GL_HSL_LUMINOSITY_KHR = 0x92B0, + GL_HSL_LUMINOSITY_NV = 0x92B0, + GL_PLUS_CLAMPED_NV = 0x92B1, + GL_PLUS_CLAMPED_ALPHA_NV = 0x92B2, + GL_MINUS_CLAMPED_NV = 0x92B3, + GL_INVERT_OVG_NV = 0x92B4, + GL_MAX_LGPU_GPUS_NVX = 0x92BA, + GL_MULTICAST_GPUS_NV = 0x92BA, + GL_PURGED_CONTEXT_RESET_NV = 0x92BB, + GL_PRIMITIVE_BOUNDING_BOX_ARB = 0x92BE, + GL_PRIMITIVE_BOUNDING_BOX = 0x92BE, + GL_PRIMITIVE_BOUNDING_BOX_EXT = 0x92BE, + GL_PRIMITIVE_BOUNDING_BOX_OES = 0x92BE, + GL_ALPHA_TO_COVERAGE_DITHER_MODE_NV = 0x92BF, + GL_ATOMIC_COUNTER_BUFFER = 0x92C0, + GL_ATOMIC_COUNTER_BUFFER_BINDING = 0x92C1, + GL_ATOMIC_COUNTER_BUFFER_START = 0x92C2, + GL_ATOMIC_COUNTER_BUFFER_SIZE = 0x92C3, + GL_ATOMIC_COUNTER_BUFFER_DATA_SIZE = 0x92C4, + GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS = 0x92C5, + GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTER_INDICES = 0x92C6, + GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_VERTEX_SHADER = 0x92C7, + GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_CONTROL_SHADER = 0x92C8, + GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_EVALUATION_SHADER = 0x92C9, + GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_GEOMETRY_SHADER = 0x92CA, + GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_FRAGMENT_SHADER = 0x92CB, + GL_MAX_VERTEX_ATOMIC_COUNTER_BUFFERS = 0x92CC, + GL_MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS = 0x92CD, + GL_MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS_EXT = 0x92CD, + GL_MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS_OES = 0x92CD, + GL_MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS = 0x92CE, + GL_MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS_EXT = 0x92CE, + GL_MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS_OES = 0x92CE, + GL_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS = 0x92CF, + GL_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS_EXT = 0x92CF, + GL_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS_OES = 0x92CF, + GL_MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS = 0x92D0, + GL_MAX_COMBINED_ATOMIC_COUNTER_BUFFERS = 0x92D1, + GL_MAX_VERTEX_ATOMIC_COUNTERS = 0x92D2, + GL_MAX_TESS_CONTROL_ATOMIC_COUNTERS = 0x92D3, + GL_MAX_TESS_CONTROL_ATOMIC_COUNTERS_EXT = 0x92D3, + GL_MAX_TESS_CONTROL_ATOMIC_COUNTERS_OES = 0x92D3, + GL_MAX_TESS_EVALUATION_ATOMIC_COUNTERS = 0x92D4, + GL_MAX_TESS_EVALUATION_ATOMIC_COUNTERS_EXT = 0x92D4, + GL_MAX_TESS_EVALUATION_ATOMIC_COUNTERS_OES = 0x92D4, + GL_MAX_GEOMETRY_ATOMIC_COUNTERS = 0x92D5, + GL_MAX_GEOMETRY_ATOMIC_COUNTERS_EXT = 0x92D5, + GL_MAX_GEOMETRY_ATOMIC_COUNTERS_OES = 0x92D5, + GL_MAX_FRAGMENT_ATOMIC_COUNTERS = 0x92D6, + GL_MAX_COMBINED_ATOMIC_COUNTERS = 0x92D7, + GL_MAX_ATOMIC_COUNTER_BUFFER_SIZE = 0x92D8, + GL_ACTIVE_ATOMIC_COUNTER_BUFFERS = 0x92D9, + GL_UNIFORM_ATOMIC_COUNTER_BUFFER_INDEX = 0x92DA, + GL_UNSIGNED_INT_ATOMIC_COUNTER = 0x92DB, + GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS = 0x92DC, + GL_FRAGMENT_COVERAGE_TO_COLOR_NV = 0x92DD, + GL_FRAGMENT_COVERAGE_COLOR_NV = 0x92DE, + GL_MESH_OUTPUT_PER_VERTEX_GRANULARITY_NV = 0x92DF, + GL_DEBUG_OUTPUT = 0x92E0, + GL_DEBUG_OUTPUT_KHR = 0x92E0, + GL_UNIFORM = 0x92E1, + GL_UNIFORM_BLOCK = 0x92E2, + GL_PROGRAM_INPUT = 0x92E3, + GL_PROGRAM_OUTPUT = 0x92E4, + GL_BUFFER_VARIABLE = 0x92E5, + GL_SHADER_STORAGE_BLOCK = 0x92E6, + GL_IS_PER_PATCH = 0x92E7, + GL_IS_PER_PATCH_EXT = 0x92E7, + GL_IS_PER_PATCH_OES = 0x92E7, + GL_VERTEX_SUBROUTINE = 0x92E8, + GL_TESS_CONTROL_SUBROUTINE = 0x92E9, + GL_TESS_EVALUATION_SUBROUTINE = 0x92EA, + GL_GEOMETRY_SUBROUTINE = 0x92EB, + GL_FRAGMENT_SUBROUTINE = 0x92EC, + GL_COMPUTE_SUBROUTINE = 0x92ED, + GL_VERTEX_SUBROUTINE_UNIFORM = 0x92EE, + GL_TESS_CONTROL_SUBROUTINE_UNIFORM = 0x92EF, + GL_TESS_EVALUATION_SUBROUTINE_UNIFORM = 0x92F0, + GL_GEOMETRY_SUBROUTINE_UNIFORM = 0x92F1, + GL_FRAGMENT_SUBROUTINE_UNIFORM = 0x92F2, + GL_COMPUTE_SUBROUTINE_UNIFORM = 0x92F3, + GL_TRANSFORM_FEEDBACK_VARYING = 0x92F4, + GL_ACTIVE_RESOURCES = 0x92F5, + GL_MAX_NAME_LENGTH = 0x92F6, + GL_MAX_NUM_ACTIVE_VARIABLES = 0x92F7, + GL_MAX_NUM_COMPATIBLE_SUBROUTINES = 0x92F8, + GL_NAME_LENGTH = 0x92F9, + GL_TYPE = 0x92FA, + GL_ARRAY_SIZE = 0x92FB, + GL_OFFSET = 0x92FC, + GL_BLOCK_INDEX = 0x92FD, + GL_ARRAY_STRIDE = 0x92FE, + GL_MATRIX_STRIDE = 0x92FF, + GL_IS_ROW_MAJOR = 0x9300, + GL_ATOMIC_COUNTER_BUFFER_INDEX = 0x9301, + GL_BUFFER_BINDING = 0x9302, + GL_BUFFER_DATA_SIZE = 0x9303, + GL_NUM_ACTIVE_VARIABLES = 0x9304, + GL_ACTIVE_VARIABLES = 0x9305, + GL_REFERENCED_BY_VERTEX_SHADER = 0x9306, + GL_REFERENCED_BY_TESS_CONTROL_SHADER = 0x9307, + GL_REFERENCED_BY_TESS_CONTROL_SHADER_EXT = 0x9307, + GL_REFERENCED_BY_TESS_CONTROL_SHADER_OES = 0x9307, + GL_REFERENCED_BY_TESS_EVALUATION_SHADER = 0x9308, + GL_REFERENCED_BY_TESS_EVALUATION_SHADER_EXT = 0x9308, + GL_REFERENCED_BY_TESS_EVALUATION_SHADER_OES = 0x9308, + GL_REFERENCED_BY_GEOMETRY_SHADER = 0x9309, + GL_REFERENCED_BY_GEOMETRY_SHADER_EXT = 0x9309, + GL_REFERENCED_BY_GEOMETRY_SHADER_OES = 0x9309, + GL_REFERENCED_BY_FRAGMENT_SHADER = 0x930A, + GL_REFERENCED_BY_COMPUTE_SHADER = 0x930B, + GL_TOP_LEVEL_ARRAY_SIZE = 0x930C, + GL_TOP_LEVEL_ARRAY_STRIDE = 0x930D, + GL_LOCATION = 0x930E, + GL_LOCATION_INDEX = 0x930F, + GL_LOCATION_INDEX_EXT = 0x930F, + GL_FRAMEBUFFER_DEFAULT_WIDTH = 0x9310, + GL_FRAMEBUFFER_DEFAULT_HEIGHT = 0x9311, + GL_FRAMEBUFFER_DEFAULT_LAYERS = 0x9312, + GL_FRAMEBUFFER_DEFAULT_LAYERS_EXT = 0x9312, + GL_FRAMEBUFFER_DEFAULT_LAYERS_OES = 0x9312, + GL_FRAMEBUFFER_DEFAULT_SAMPLES = 0x9313, + GL_FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS = 0x9314, + GL_MAX_FRAMEBUFFER_WIDTH = 0x9315, + GL_MAX_FRAMEBUFFER_HEIGHT = 0x9316, + GL_MAX_FRAMEBUFFER_LAYERS = 0x9317, + GL_MAX_FRAMEBUFFER_LAYERS_EXT = 0x9317, + GL_MAX_FRAMEBUFFER_LAYERS_OES = 0x9317, + GL_MAX_FRAMEBUFFER_SAMPLES = 0x9318, + GL_RASTER_MULTISAMPLE_EXT = 0x9327, + GL_RASTER_SAMPLES_EXT = 0x9328, + GL_MAX_RASTER_SAMPLES_EXT = 0x9329, + GL_RASTER_FIXED_SAMPLE_LOCATIONS_EXT = 0x932A, + GL_MULTISAMPLE_RASTERIZATION_ALLOWED_EXT = 0x932B, + GL_EFFECTIVE_RASTER_SAMPLES_EXT = 0x932C, + GL_DEPTH_SAMPLES_NV = 0x932D, + GL_STENCIL_SAMPLES_NV = 0x932E, + GL_MIXED_DEPTH_SAMPLES_SUPPORTED_NV = 0x932F, + GL_MIXED_STENCIL_SAMPLES_SUPPORTED_NV = 0x9330, + GL_COVERAGE_MODULATION_TABLE_NV = 0x9331, + GL_COVERAGE_MODULATION_NV = 0x9332, + GL_COVERAGE_MODULATION_TABLE_SIZE_NV = 0x9333, + GL_WARP_SIZE_NV = 0x9339, + GL_WARPS_PER_SM_NV = 0x933A, + GL_SM_COUNT_NV = 0x933B, + GL_FILL_RECTANGLE_NV = 0x933C, + GL_SAMPLE_LOCATION_SUBPIXEL_BITS_ARB = 0x933D, + GL_SAMPLE_LOCATION_SUBPIXEL_BITS_NV = 0x933D, + GL_SAMPLE_LOCATION_PIXEL_GRID_WIDTH_ARB = 0x933E, + GL_SAMPLE_LOCATION_PIXEL_GRID_WIDTH_NV = 0x933E, + GL_SAMPLE_LOCATION_PIXEL_GRID_HEIGHT_ARB = 0x933F, + GL_SAMPLE_LOCATION_PIXEL_GRID_HEIGHT_NV = 0x933F, + GL_PROGRAMMABLE_SAMPLE_LOCATION_TABLE_SIZE_ARB = 0x9340, + GL_PROGRAMMABLE_SAMPLE_LOCATION_TABLE_SIZE_NV = 0x9340, + GL_PROGRAMMABLE_SAMPLE_LOCATION_ARB = 0x9341, + GL_PROGRAMMABLE_SAMPLE_LOCATION_NV = 0x9341, + GL_FRAMEBUFFER_PROGRAMMABLE_SAMPLE_LOCATIONS_ARB = 0x9342, + GL_FRAMEBUFFER_PROGRAMMABLE_SAMPLE_LOCATIONS_NV = 0x9342, + GL_FRAMEBUFFER_SAMPLE_LOCATION_PIXEL_GRID_ARB = 0x9343, + GL_FRAMEBUFFER_SAMPLE_LOCATION_PIXEL_GRID_NV = 0x9343, + GL_MAX_COMPUTE_VARIABLE_GROUP_INVOCATIONS_ARB = 0x9344, + GL_MAX_COMPUTE_VARIABLE_GROUP_SIZE_ARB = 0x9345, + GL_CONSERVATIVE_RASTERIZATION_NV = 0x9346, + GL_SUBPIXEL_PRECISION_BIAS_X_BITS_NV = 0x9347, + GL_SUBPIXEL_PRECISION_BIAS_Y_BITS_NV = 0x9348, + GL_MAX_SUBPIXEL_PRECISION_BIAS_BITS_NV = 0x9349, + GL_LOCATION_COMPONENT = 0x934A, + GL_TRANSFORM_FEEDBACK_BUFFER_INDEX = 0x934B, + GL_TRANSFORM_FEEDBACK_BUFFER_STRIDE = 0x934C, + GL_ALPHA_TO_COVERAGE_DITHER_DEFAULT_NV = 0x934D, + GL_ALPHA_TO_COVERAGE_DITHER_ENABLE_NV = 0x934E, + GL_ALPHA_TO_COVERAGE_DITHER_DISABLE_NV = 0x934F, + GL_VIEWPORT_SWIZZLE_POSITIVE_X_NV = 0x9350, + GL_VIEWPORT_SWIZZLE_NEGATIVE_X_NV = 0x9351, + GL_VIEWPORT_SWIZZLE_POSITIVE_Y_NV = 0x9352, + GL_VIEWPORT_SWIZZLE_NEGATIVE_Y_NV = 0x9353, + GL_VIEWPORT_SWIZZLE_POSITIVE_Z_NV = 0x9354, + GL_VIEWPORT_SWIZZLE_NEGATIVE_Z_NV = 0x9355, + GL_VIEWPORT_SWIZZLE_POSITIVE_W_NV = 0x9356, + GL_VIEWPORT_SWIZZLE_NEGATIVE_W_NV = 0x9357, + GL_VIEWPORT_SWIZZLE_X_NV = 0x9358, + GL_VIEWPORT_SWIZZLE_Y_NV = 0x9359, + GL_VIEWPORT_SWIZZLE_Z_NV = 0x935A, + GL_VIEWPORT_SWIZZLE_W_NV = 0x935B, + GL_CLIP_ORIGIN = 0x935C, + GL_CLIP_ORIGIN_EXT = 0x935C, + GL_CLIP_DEPTH_MODE = 0x935D, + GL_CLIP_DEPTH_MODE_EXT = 0x935D, + GL_NEGATIVE_ONE_TO_ONE = 0x935E, + GL_NEGATIVE_ONE_TO_ONE_EXT = 0x935E, + GL_ZERO_TO_ONE = 0x935F, + GL_ZERO_TO_ONE_EXT = 0x935F, + GL_CLEAR_TEXTURE = 0x9365, + GL_TEXTURE_REDUCTION_MODE_ARB = 0x9366, + GL_TEXTURE_REDUCTION_MODE_EXT = 0x9366, + GL_WEIGHTED_AVERAGE_ARB = 0x9367, + GL_WEIGHTED_AVERAGE_EXT = 0x9367, + GL_FONT_GLYPHS_AVAILABLE_NV = 0x9368, + GL_FONT_TARGET_UNAVAILABLE_NV = 0x9369, + GL_FONT_UNAVAILABLE_NV = 0x936A, + GL_FONT_UNINTELLIGIBLE_NV = 0x936B, + GL_STANDARD_FONT_FORMAT_NV = 0x936C, + GL_FRAGMENT_INPUT_NV = 0x936D, + GL_UNIFORM_BUFFER_UNIFIED_NV = 0x936E, + GL_UNIFORM_BUFFER_ADDRESS_NV = 0x936F, + GL_UNIFORM_BUFFER_LENGTH_NV = 0x9370, + GL_MULTISAMPLES_NV = 0x9371, + GL_SUPERSAMPLE_SCALE_X_NV = 0x9372, + GL_SUPERSAMPLE_SCALE_Y_NV = 0x9373, + GL_CONFORMANT_NV = 0x9374, + GL_CONSERVATIVE_RASTER_DILATE_NV = 0x9379, + GL_CONSERVATIVE_RASTER_DILATE_RANGE_NV = 0x937A, + GL_CONSERVATIVE_RASTER_DILATE_GRANULARITY_NV = 0x937B, + GL_VIEWPORT_POSITION_W_SCALE_NV = 0x937C, + GL_VIEWPORT_POSITION_W_SCALE_X_COEFF_NV = 0x937D, + GL_VIEWPORT_POSITION_W_SCALE_Y_COEFF_NV = 0x937E, + GL_REPRESENTATIVE_FRAGMENT_TEST_NV = 0x937F, + GL_NUM_SAMPLE_COUNTS = 0x9380, + GL_MULTISAMPLE_LINE_WIDTH_RANGE_ARB = 0x9381, + GL_MULTISAMPLE_LINE_WIDTH_RANGE = 0x9381, + GL_MULTISAMPLE_LINE_WIDTH_GRANULARITY_ARB = 0x9382, + GL_MULTISAMPLE_LINE_WIDTH_GRANULARITY = 0x9382, + GL_VIEW_CLASS_EAC_R11 = 0x9383, + GL_VIEW_CLASS_EAC_RG11 = 0x9384, + GL_VIEW_CLASS_ETC2_RGB = 0x9385, + GL_VIEW_CLASS_ETC2_RGBA = 0x9386, + GL_VIEW_CLASS_ETC2_EAC_RGBA = 0x9387, + GL_VIEW_CLASS_ASTC_4x4_RGBA = 0x9388, + GL_VIEW_CLASS_ASTC_5x4_RGBA = 0x9389, + GL_VIEW_CLASS_ASTC_5x5_RGBA = 0x938A, + GL_VIEW_CLASS_ASTC_6x5_RGBA = 0x938B, + GL_VIEW_CLASS_ASTC_6x6_RGBA = 0x938C, + GL_VIEW_CLASS_ASTC_8x5_RGBA = 0x938D, + GL_VIEW_CLASS_ASTC_8x6_RGBA = 0x938E, + GL_VIEW_CLASS_ASTC_8x8_RGBA = 0x938F, + GL_VIEW_CLASS_ASTC_10x5_RGBA = 0x9390, + GL_VIEW_CLASS_ASTC_10x6_RGBA = 0x9391, + GL_VIEW_CLASS_ASTC_10x8_RGBA = 0x9392, + GL_VIEW_CLASS_ASTC_10x10_RGBA = 0x9393, + GL_VIEW_CLASS_ASTC_12x10_RGBA = 0x9394, + GL_VIEW_CLASS_ASTC_12x12_RGBA = 0x9395, + GL_TRANSLATED_SHADER_SOURCE_LENGTH_ANGLE = 0x93A0, + GL_BGRA8_EXT = 0x93A1, + GL_TEXTURE_USAGE_ANGLE = 0x93A2, + GL_FRAMEBUFFER_ATTACHMENT_ANGLE = 0x93A3, + GL_PACK_REVERSE_ROW_ORDER_ANGLE = 0x93A4, + GL_PROGRAM_BINARY_ANGLE = 0x93A6, + GL_COMPRESSED_RGBA_ASTC_4x4 = 0x93B0, + GL_COMPRESSED_RGBA_ASTC_4x4_KHR = 0x93B0, + GL_COMPRESSED_RGBA_ASTC_5x4 = 0x93B1, + GL_COMPRESSED_RGBA_ASTC_5x4_KHR = 0x93B1, + GL_COMPRESSED_RGBA_ASTC_5x5 = 0x93B2, + GL_COMPRESSED_RGBA_ASTC_5x5_KHR = 0x93B2, + GL_COMPRESSED_RGBA_ASTC_6x5 = 0x93B3, + GL_COMPRESSED_RGBA_ASTC_6x5_KHR = 0x93B3, + GL_COMPRESSED_RGBA_ASTC_6x6 = 0x93B4, + GL_COMPRESSED_RGBA_ASTC_6x6_KHR = 0x93B4, + GL_COMPRESSED_RGBA_ASTC_8x5 = 0x93B5, + GL_COMPRESSED_RGBA_ASTC_8x5_KHR = 0x93B5, + GL_COMPRESSED_RGBA_ASTC_8x6 = 0x93B6, + GL_COMPRESSED_RGBA_ASTC_8x6_KHR = 0x93B6, + GL_COMPRESSED_RGBA_ASTC_8x8 = 0x93B7, + GL_COMPRESSED_RGBA_ASTC_8x8_KHR = 0x93B7, + GL_COMPRESSED_RGBA_ASTC_10x5 = 0x93B8, + GL_COMPRESSED_RGBA_ASTC_10x5_KHR = 0x93B8, + GL_COMPRESSED_RGBA_ASTC_10x6 = 0x93B9, + GL_COMPRESSED_RGBA_ASTC_10x6_KHR = 0x93B9, + GL_COMPRESSED_RGBA_ASTC_10x8 = 0x93BA, + GL_COMPRESSED_RGBA_ASTC_10x8_KHR = 0x93BA, + GL_COMPRESSED_RGBA_ASTC_10x10 = 0x93BB, + GL_COMPRESSED_RGBA_ASTC_10x10_KHR = 0x93BB, + GL_COMPRESSED_RGBA_ASTC_12x10 = 0x93BC, + GL_COMPRESSED_RGBA_ASTC_12x10_KHR = 0x93BC, + GL_COMPRESSED_RGBA_ASTC_12x12 = 0x93BD, + GL_COMPRESSED_RGBA_ASTC_12x12_KHR = 0x93BD, + GL_COMPRESSED_RGBA_ASTC_3x3x3_OES = 0x93C0, + GL_COMPRESSED_RGBA_ASTC_4x3x3_OES = 0x93C1, + GL_COMPRESSED_RGBA_ASTC_4x4x3_OES = 0x93C2, + GL_COMPRESSED_RGBA_ASTC_4x4x4_OES = 0x93C3, + GL_COMPRESSED_RGBA_ASTC_5x4x4_OES = 0x93C4, + GL_COMPRESSED_RGBA_ASTC_5x5x4_OES = 0x93C5, + GL_COMPRESSED_RGBA_ASTC_5x5x5_OES = 0x93C6, + GL_COMPRESSED_RGBA_ASTC_6x5x5_OES = 0x93C7, + GL_COMPRESSED_RGBA_ASTC_6x6x5_OES = 0x93C8, + GL_COMPRESSED_RGBA_ASTC_6x6x6_OES = 0x93C9, + GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4 = 0x93D0, + GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR = 0x93D0, + GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4 = 0x93D1, + GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR = 0x93D1, + GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5 = 0x93D2, + GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR = 0x93D2, + GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5 = 0x93D3, + GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR = 0x93D3, + GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6 = 0x93D4, + GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR = 0x93D4, + GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5 = 0x93D5, + GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR = 0x93D5, + GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6 = 0x93D6, + GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR = 0x93D6, + GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8 = 0x93D7, + GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR = 0x93D7, + GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5 = 0x93D8, + GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR = 0x93D8, + GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6 = 0x93D9, + GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR = 0x93D9, + GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8 = 0x93DA, + GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR = 0x93DA, + GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10 = 0x93DB, + GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR = 0x93DB, + GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10 = 0x93DC, + GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR = 0x93DC, + GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12 = 0x93DD, + GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR = 0x93DD, + GL_COMPRESSED_SRGB8_ALPHA8_ASTC_3x3x3_OES = 0x93E0, + GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x3x3_OES = 0x93E1, + GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4x3_OES = 0x93E2, + GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4x4_OES = 0x93E3, + GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4x4_OES = 0x93E4, + GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5x4_OES = 0x93E5, + GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5x5_OES = 0x93E6, + GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5x5_OES = 0x93E7, + GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6x5_OES = 0x93E8, + GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6x6_OES = 0x93E9, + GL_COMPRESSED_SRGB_ALPHA_PVRTC_2BPPV2_IMG = 0x93F0, + GL_COMPRESSED_SRGB_ALPHA_PVRTC_4BPPV2_IMG = 0x93F1, + GL_PERFQUERY_COUNTER_EVENT_INTEL = 0x94F0, + GL_PERFQUERY_COUNTER_DURATION_NORM_INTEL = 0x94F1, + GL_PERFQUERY_COUNTER_DURATION_RAW_INTEL = 0x94F2, + GL_PERFQUERY_COUNTER_THROUGHPUT_INTEL = 0x94F3, + GL_PERFQUERY_COUNTER_RAW_INTEL = 0x94F4, + GL_PERFQUERY_COUNTER_TIMESTAMP_INTEL = 0x94F5, + GL_PERFQUERY_COUNTER_DATA_UINT32_INTEL = 0x94F8, + GL_PERFQUERY_COUNTER_DATA_UINT64_INTEL = 0x94F9, + GL_PERFQUERY_COUNTER_DATA_FLOAT_INTEL = 0x94FA, + GL_PERFQUERY_COUNTER_DATA_DOUBLE_INTEL = 0x94FB, + GL_PERFQUERY_COUNTER_DATA_BOOL32_INTEL = 0x94FC, + GL_PERFQUERY_QUERY_NAME_LENGTH_MAX_INTEL = 0x94FD, + GL_PERFQUERY_COUNTER_NAME_LENGTH_MAX_INTEL = 0x94FE, + GL_PERFQUERY_COUNTER_DESC_LENGTH_MAX_INTEL = 0x94FF, + GL_PERFQUERY_GPA_EXTENDED_COUNTERS_INTEL = 0x9500, + GL_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_EXT = 0x9530, + GL_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_EXT = 0x9531, + GL_SUBGROUP_SIZE_KHR = 0x9532, + GL_SUBGROUP_SUPPORTED_STAGES_KHR = 0x9533, + GL_SUBGROUP_SUPPORTED_FEATURES_KHR = 0x9534, + GL_SUBGROUP_QUAD_ALL_STAGES_KHR = 0x9535, + GL_MAX_MESH_TOTAL_MEMORY_SIZE_NV = 0x9536, + GL_MAX_TASK_TOTAL_MEMORY_SIZE_NV = 0x9537, + GL_MAX_MESH_OUTPUT_VERTICES_NV = 0x9538, + GL_MAX_MESH_OUTPUT_PRIMITIVES_NV = 0x9539, + GL_MAX_TASK_OUTPUT_COUNT_NV = 0x953A, + GL_MAX_MESH_WORK_GROUP_SIZE_NV = 0x953B, + GL_MAX_TASK_WORK_GROUP_SIZE_NV = 0x953C, + GL_MAX_DRAW_MESH_TASKS_COUNT_NV = 0x953D, + GL_MESH_WORK_GROUP_SIZE_NV = 0x953E, + GL_TASK_WORK_GROUP_SIZE_NV = 0x953F, + GL_QUERY_RESOURCE_TYPE_VIDMEM_ALLOC_NV = 0x9540, + GL_QUERY_RESOURCE_MEMTYPE_VIDMEM_NV = 0x9542, + GL_MESH_OUTPUT_PER_PRIMITIVE_GRANULARITY_NV = 0x9543, + GL_QUERY_RESOURCE_SYS_RESERVED_NV = 0x9544, + GL_QUERY_RESOURCE_TEXTURE_NV = 0x9545, + GL_QUERY_RESOURCE_RENDERBUFFER_NV = 0x9546, + GL_QUERY_RESOURCE_BUFFEROBJECT_NV = 0x9547, + GL_PER_GPU_STORAGE_NV = 0x9548, + GL_MULTICAST_PROGRAMMABLE_SAMPLE_LOCATION_NV = 0x9549, + GL_UPLOAD_GPU_MASK_NVX = 0x954A, + GL_CONSERVATIVE_RASTER_MODE_NV = 0x954D, + GL_CONSERVATIVE_RASTER_MODE_POST_SNAP_NV = 0x954E, + GL_CONSERVATIVE_RASTER_MODE_PRE_SNAP_TRIANGLES_NV = 0x954F, + GL_CONSERVATIVE_RASTER_MODE_PRE_SNAP_NV = 0x9550, + GL_SHADER_BINARY_FORMAT_SPIR_V = 0x9551, + GL_SHADER_BINARY_FORMAT_SPIR_V_ARB = 0x9551, + GL_SPIR_V_BINARY = 0x9552, + GL_SPIR_V_BINARY_ARB = 0x9552, + GL_SPIR_V_EXTENSIONS = 0x9553, + GL_NUM_SPIR_V_EXTENSIONS = 0x9554, + GL_SCISSOR_TEST_EXCLUSIVE_NV = 0x9555, + GL_SCISSOR_BOX_EXCLUSIVE_NV = 0x9556, + GL_MAX_MESH_VIEWS_NV = 0x9557, + GL_RENDER_GPU_MASK_NV = 0x9558, + GL_MESH_SHADER_NV = 0x9559, + GL_TASK_SHADER_NV = 0x955A, + GL_SHADING_RATE_IMAGE_BINDING_NV = 0x955B, + GL_SHADING_RATE_IMAGE_TEXEL_WIDTH_NV = 0x955C, + GL_SHADING_RATE_IMAGE_TEXEL_HEIGHT_NV = 0x955D, + GL_SHADING_RATE_IMAGE_PALETTE_SIZE_NV = 0x955E, + GL_MAX_COARSE_FRAGMENT_SAMPLES_NV = 0x955F, + GL_SHADING_RATE_IMAGE_NV = 0x9563, + GL_SHADING_RATE_NO_INVOCATIONS_NV = 0x9564, + GL_SHADING_RATE_1_INVOCATION_PER_PIXEL_NV = 0x9565, + GL_SHADING_RATE_1_INVOCATION_PER_1X2_PIXELS_NV = 0x9566, + GL_SHADING_RATE_1_INVOCATION_PER_2X1_PIXELS_NV = 0x9567, + GL_SHADING_RATE_1_INVOCATION_PER_2X2_PIXELS_NV = 0x9568, + GL_SHADING_RATE_1_INVOCATION_PER_2X4_PIXELS_NV = 0x9569, + GL_SHADING_RATE_1_INVOCATION_PER_4X2_PIXELS_NV = 0x956A, + GL_SHADING_RATE_1_INVOCATION_PER_4X4_PIXELS_NV = 0x956B, + GL_SHADING_RATE_2_INVOCATIONS_PER_PIXEL_NV = 0x956C, + GL_SHADING_RATE_4_INVOCATIONS_PER_PIXEL_NV = 0x956D, + GL_SHADING_RATE_8_INVOCATIONS_PER_PIXEL_NV = 0x956E, + GL_SHADING_RATE_16_INVOCATIONS_PER_PIXEL_NV = 0x956F, + GL_MESH_VERTICES_OUT_NV = 0x9579, + GL_MESH_PRIMITIVES_OUT_NV = 0x957A, + GL_MESH_OUTPUT_TYPE_NV = 0x957B, + GL_MESH_SUBROUTINE_NV = 0x957C, + GL_TASK_SUBROUTINE_NV = 0x957D, + GL_MESH_SUBROUTINE_UNIFORM_NV = 0x957E, + GL_TASK_SUBROUTINE_UNIFORM_NV = 0x957F, + GL_TEXTURE_TILING_EXT = 0x9580, + GL_DEDICATED_MEMORY_OBJECT_EXT = 0x9581, + GL_NUM_TILING_TYPES_EXT = 0x9582, + GL_TILING_TYPES_EXT = 0x9583, + GL_OPTIMAL_TILING_EXT = 0x9584, + GL_LINEAR_TILING_EXT = 0x9585, + GL_HANDLE_TYPE_OPAQUE_FD_EXT = 0x9586, + GL_HANDLE_TYPE_OPAQUE_WIN32_EXT = 0x9587, + GL_HANDLE_TYPE_OPAQUE_WIN32_KMT_EXT = 0x9588, + GL_HANDLE_TYPE_D3D12_TILEPOOL_EXT = 0x9589, + GL_HANDLE_TYPE_D3D12_RESOURCE_EXT = 0x958A, + GL_HANDLE_TYPE_D3D11_IMAGE_EXT = 0x958B, + GL_HANDLE_TYPE_D3D11_IMAGE_KMT_EXT = 0x958C, + GL_LAYOUT_GENERAL_EXT = 0x958D, + GL_LAYOUT_COLOR_ATTACHMENT_EXT = 0x958E, + GL_LAYOUT_DEPTH_STENCIL_ATTACHMENT_EXT = 0x958F, + GL_LAYOUT_DEPTH_STENCIL_READ_ONLY_EXT = 0x9590, + GL_LAYOUT_SHADER_READ_ONLY_EXT = 0x9591, + GL_LAYOUT_TRANSFER_SRC_EXT = 0x9592, + GL_LAYOUT_TRANSFER_DST_EXT = 0x9593, + GL_HANDLE_TYPE_D3D12_FENCE_EXT = 0x9594, + GL_D3D12_FENCE_VALUE_EXT = 0x9595, + GL_TIMELINE_SEMAPHORE_VALUE_NV = 0x9595, + GL_NUM_DEVICE_UUIDS_EXT = 0x9596, + GL_DEVICE_UUID_EXT = 0x9597, + GL_DRIVER_UUID_EXT = 0x9598, + GL_DEVICE_LUID_EXT = 0x9599, + GL_DEVICE_NODE_MASK_EXT = 0x959A, + GL_PROTECTED_MEMORY_OBJECT_EXT = 0x959B, + GL_UNIFORM_BLOCK_REFERENCED_BY_MESH_SHADER_NV = 0x959C, + GL_UNIFORM_BLOCK_REFERENCED_BY_TASK_SHADER_NV = 0x959D, + GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_MESH_SHADER_NV = 0x959E, + GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TASK_SHADER_NV = 0x959F, + GL_REFERENCED_BY_MESH_SHADER_NV = 0x95A0, + GL_REFERENCED_BY_TASK_SHADER_NV = 0x95A1, + GL_MAX_MESH_WORK_GROUP_INVOCATIONS_NV = 0x95A2, + GL_MAX_TASK_WORK_GROUP_INVOCATIONS_NV = 0x95A3, + GL_ATTACHED_MEMORY_OBJECT_NV = 0x95A4, + GL_ATTACHED_MEMORY_OFFSET_NV = 0x95A5, + GL_MEMORY_ATTACHABLE_ALIGNMENT_NV = 0x95A6, + GL_MEMORY_ATTACHABLE_SIZE_NV = 0x95A7, + GL_MEMORY_ATTACHABLE_NV = 0x95A8, + GL_DETACHED_MEMORY_INCARNATION_NV = 0x95A9, + GL_DETACHED_TEXTURES_NV = 0x95AA, + GL_DETACHED_BUFFERS_NV = 0x95AB, + GL_MAX_DETACHED_TEXTURES_NV = 0x95AC, + GL_MAX_DETACHED_BUFFERS_NV = 0x95AD, + GL_SHADING_RATE_SAMPLE_ORDER_DEFAULT_NV = 0x95AE, + GL_SHADING_RATE_SAMPLE_ORDER_PIXEL_MAJOR_NV = 0x95AF, + GL_SHADING_RATE_SAMPLE_ORDER_SAMPLE_MAJOR_NV = 0x95B0, + GL_SHADING_RATE_IMAGE_PER_PRIMITIVE_NV = 0x95B1, + GL_SHADING_RATE_IMAGE_PALETTE_COUNT_NV = 0x95B2, + GL_SEMAPHORE_TYPE_NV = 0x95B3, + GL_SEMAPHORE_TYPE_BINARY_NV = 0x95B4, + GL_SEMAPHORE_TYPE_TIMELINE_NV = 0x95B5, + GL_MAX_TIMELINE_SEMAPHORE_VALUE_DIFFERENCE_NV = 0x95B6, + GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_NUM_VIEWS_OVR = 0x9630, + GL_MAX_VIEWS_OVR = 0x9631, + GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_BASE_VIEW_INDEX_OVR = 0x9632, + GL_FRAMEBUFFER_INCOMPLETE_VIEW_TARGETS_OVR = 0x9633, + GL_GS_SHADER_BINARY_MTK = 0x9640, + GL_GS_PROGRAM_BINARY_MTK = 0x9641, + GL_MAX_SHADER_COMBINED_LOCAL_STORAGE_FAST_SIZE_EXT = 0x9650, + GL_MAX_SHADER_COMBINED_LOCAL_STORAGE_SIZE_EXT = 0x9651, + GL_FRAMEBUFFER_INCOMPLETE_INSUFFICIENT_SHADER_COMBINED_LOCAL_STORAGE_EXT = 0x9652, + GL_TEXTURE_FOVEATED_CUTOFF_DENSITY_QCOM = 0x96A0, + GL_FRAMEBUFFER_FETCH_NONCOHERENT_QCOM = 0x96A2, + GL_VALIDATE_SHADER_BINARY_QCOM = 0x96A3, + GL_SHADING_RATE_QCOM = 0x96A4, + GL_SHADING_RATE_PRESERVE_ASPECT_RATIO_QCOM = 0x96A5, + GL_SHADING_RATE_1X1_PIXELS_QCOM = 0x96A6, + GL_SHADING_RATE_1X2_PIXELS_QCOM = 0x96A7, + GL_SHADING_RATE_2X1_PIXELS_QCOM = 0x96A8, + GL_SHADING_RATE_2X2_PIXELS_QCOM = 0x96A9, + GL_SHADING_RATE_1X4_PIXELS_QCOM = 0x96AA, + GL_SHADING_RATE_4X1_PIXELS_QCOM = 0x96AB, + GL_SHADING_RATE_4X2_PIXELS_QCOM = 0x96AC, + GL_SHADING_RATE_2X4_PIXELS_QCOM = 0x96AD, + GL_SHADING_RATE_4X4_PIXELS_QCOM = 0x96AE, + GL_RASTER_POSITION_UNCLIPPED_IBM = 0x19262, + GL_CULL_VERTEX_IBM = 103050, + GL_ALL_STATIC_DATA_IBM = 103060, + GL_STATIC_VERTEX_ARRAY_IBM = 103061, + GL_VERTEX_ARRAY_LIST_IBM = 103070, + GL_NORMAL_ARRAY_LIST_IBM = 103071, + GL_COLOR_ARRAY_LIST_IBM = 103072, + GL_INDEX_ARRAY_LIST_IBM = 103073, + GL_TEXTURE_COORD_ARRAY_LIST_IBM = 103074, + GL_EDGE_FLAG_ARRAY_LIST_IBM = 103075, + GL_FOG_COORDINATE_ARRAY_LIST_IBM = 103076, + GL_SECONDARY_COLOR_ARRAY_LIST_IBM = 103077, + GL_VERTEX_ARRAY_LIST_STRIDE_IBM = 103080, + GL_NORMAL_ARRAY_LIST_STRIDE_IBM = 103081, + GL_COLOR_ARRAY_LIST_STRIDE_IBM = 103082, + GL_INDEX_ARRAY_LIST_STRIDE_IBM = 103083, + GL_TEXTURE_COORD_ARRAY_LIST_STRIDE_IBM = 103084, + GL_EDGE_FLAG_ARRAY_LIST_STRIDE_IBM = 103085, + GL_FOG_COORDINATE_ARRAY_LIST_STRIDE_IBM = 103086, + GL_SECONDARY_COLOR_ARRAY_LIST_STRIDE_IBM = 103087, + GL_PREFER_DOUBLEBUFFER_HINT_PGI = 0x1A1F8, + GL_CONSERVE_MEMORY_HINT_PGI = 0x1A1FD, + GL_RECLAIM_MEMORY_HINT_PGI = 0x1A1FE, + GL_NATIVE_GRAPHICS_HANDLE_PGI = 0x1A202, + GL_NATIVE_GRAPHICS_BEGIN_HINT_PGI = 0x1A203, + GL_NATIVE_GRAPHICS_END_HINT_PGI = 0x1A204, + GL_ALWAYS_FAST_HINT_PGI = 0x1A20C, + GL_ALWAYS_SOFT_HINT_PGI = 0x1A20D, + GL_ALLOW_DRAW_OBJ_HINT_PGI = 0x1A20E, + GL_ALLOW_DRAW_WIN_HINT_PGI = 0x1A20F, + GL_ALLOW_DRAW_FRG_HINT_PGI = 0x1A210, + GL_ALLOW_DRAW_MEM_HINT_PGI = 0x1A211, + GL_STRICT_DEPTHFUNC_HINT_PGI = 0x1A216, + GL_STRICT_LIGHTING_HINT_PGI = 0x1A217, + GL_STRICT_SCISSOR_HINT_PGI = 0x1A218, + GL_FULL_STIPPLE_HINT_PGI = 0x1A219, + GL_CLIP_NEAR_HINT_PGI = 0x1A220, + GL_CLIP_FAR_HINT_PGI = 0x1A221, + GL_WIDE_LINE_HINT_PGI = 0x1A222, + GL_BACK_NORMALS_HINT_PGI = 0x1A223, + GL_VERTEX_DATA_HINT_PGI = 0x1A22A, + GL_VERTEX_CONSISTENT_HINT_PGI = 0x1A22B, + GL_MATERIAL_SIDE_HINT_PGI = 0x1A22C, + GL_MAX_VERTEX_HINT_PGI = 0x1A22D, + WGL_LOSE_CONTEXT_ON_RESET_ARB = 0x8252, + WGL_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB = 0x8256, + WGL_NO_RESET_NOTIFICATION_ARB = 0x8261, + WGL_CONTEXT_PROFILE_MASK_ARB = 0x9126, +} GL; + +typedef enum RegisterCombinerPname { + GL_COMBINE = 0x8570, + GL_COMBINE_ARB = 0x8570, + GL_COMBINE_EXT = 0x8570, + GL_COMBINE_RGB = 0x8571, + GL_COMBINE_RGB_ARB = 0x8571, + GL_COMBINE_RGB_EXT = 0x8571, + GL_COMBINE_ALPHA = 0x8572, + GL_COMBINE_ALPHA_ARB = 0x8572, + GL_COMBINE_ALPHA_EXT = 0x8572, + GL_RGB_SCALE = 0x8573, + GL_RGB_SCALE_ARB = 0x8573, + GL_RGB_SCALE_EXT = 0x8573, + GL_ADD_SIGNED = 0x8574, + GL_ADD_SIGNED_ARB = 0x8574, + GL_ADD_SIGNED_EXT = 0x8574, + GL_INTERPOLATE = 0x8575, + GL_INTERPOLATE_ARB = 0x8575, + GL_INTERPOLATE_EXT = 0x8575, + GL_CONSTANT = 0x8576, + GL_CONSTANT_ARB = 0x8576, + GL_CONSTANT_EXT = 0x8576, + GL_CONSTANT_NV = 0x8576, + GL_PRIMARY_COLOR = 0x8577, + GL_PRIMARY_COLOR_ARB = 0x8577, + GL_PRIMARY_COLOR_EXT = 0x8577, + GL_PREVIOUS = 0x8578, + GL_PREVIOUS_ARB = 0x8578, + GL_PREVIOUS_EXT = 0x8578, + GL_SOURCE0_RGB = 0x8580, + GL_SOURCE0_RGB_ARB = 0x8580, + GL_SOURCE0_RGB_EXT = 0x8580, + GL_SRC0_RGB = 0x8580, + GL_SOURCE1_RGB = 0x8581, + GL_SOURCE1_RGB_ARB = 0x8581, + GL_SOURCE1_RGB_EXT = 0x8581, + GL_SRC1_RGB = 0x8581, + GL_SOURCE2_RGB = 0x8582, + GL_SOURCE2_RGB_ARB = 0x8582, + GL_SOURCE2_RGB_EXT = 0x8582, + GL_SRC2_RGB = 0x8582, + GL_SOURCE3_RGB_NV = 0x8583, + GL_SOURCE0_ALPHA = 0x8588, + GL_SOURCE0_ALPHA_ARB = 0x8588, + GL_SOURCE0_ALPHA_EXT = 0x8588, + GL_SRC0_ALPHA = 0x8588, + GL_SOURCE1_ALPHA = 0x8589, + GL_SOURCE1_ALPHA_ARB = 0x8589, + GL_SOURCE1_ALPHA_EXT = 0x8589, + GL_SRC1_ALPHA = 0x8589, + GL_SRC1_ALPHA_EXT = 0x8589, + GL_SOURCE2_ALPHA = 0x858A, + GL_SOURCE2_ALPHA_ARB = 0x858A, + GL_SOURCE2_ALPHA_EXT = 0x858A, + GL_SRC2_ALPHA = 0x858A, + GL_SOURCE3_ALPHA_NV = 0x858B, + GL_OPERAND0_RGB = 0x8590, + GL_OPERAND0_RGB_ARB = 0x8590, + GL_OPERAND0_RGB_EXT = 0x8590, + GL_OPERAND1_RGB = 0x8591, + GL_OPERAND1_RGB_ARB = 0x8591, + GL_OPERAND1_RGB_EXT = 0x8591, + GL_OPERAND2_RGB = 0x8592, + GL_OPERAND2_RGB_ARB = 0x8592, + GL_OPERAND2_RGB_EXT = 0x8592, + GL_OPERAND3_RGB_NV = 0x8593, + GL_OPERAND0_ALPHA = 0x8598, + GL_OPERAND0_ALPHA_ARB = 0x8598, + GL_OPERAND0_ALPHA_EXT = 0x8598, + GL_OPERAND1_ALPHA = 0x8599, + GL_OPERAND1_ALPHA_ARB = 0x8599, + GL_OPERAND1_ALPHA_EXT = 0x8599, + GL_OPERAND2_ALPHA = 0x859A, + GL_OPERAND2_ALPHA_ARB = 0x859A, + GL_OPERAND2_ALPHA_EXT = 0x859A, + GL_OPERAND3_ALPHA_NV = 0x859B, +} RegisterCombinerPname; + +typedef enum ShaderType { + GL_FRAGMENT_SHADER = 0x8B30, + GL_FRAGMENT_SHADER_ARB = 0x8B30, + GL_VERTEX_SHADER = 0x8B31, + GL_VERTEX_SHADER_ARB = 0x8B31, +} ShaderType; + +typedef enum ContainerType { + GL_PROGRAM_OBJECT_ARB = 0x8B40, + GL_PROGRAM_OBJECT_EXT = 0x8B40, +} ContainerType; + +typedef enum AttributeType { + GL_FLOAT_VEC2 = 0x8B50, + GL_FLOAT_VEC2_ARB = 0x8B50, + GL_FLOAT_VEC3 = 0x8B51, + GL_FLOAT_VEC3_ARB = 0x8B51, + GL_FLOAT_VEC4 = 0x8B52, + GL_FLOAT_VEC4_ARB = 0x8B52, + GL_INT_VEC2 = 0x8B53, + GL_INT_VEC2_ARB = 0x8B53, + GL_INT_VEC3 = 0x8B54, + GL_INT_VEC3_ARB = 0x8B54, + GL_INT_VEC4 = 0x8B55, + GL_INT_VEC4_ARB = 0x8B55, + GL_BOOL = 0x8B56, + GL_BOOL_ARB = 0x8B56, + GL_BOOL_VEC2 = 0x8B57, + GL_BOOL_VEC2_ARB = 0x8B57, + GL_BOOL_VEC3 = 0x8B58, + GL_BOOL_VEC3_ARB = 0x8B58, + GL_BOOL_VEC4 = 0x8B59, + GL_BOOL_VEC4_ARB = 0x8B59, + GL_FLOAT_MAT2 = 0x8B5A, + GL_FLOAT_MAT2_ARB = 0x8B5A, + GL_FLOAT_MAT3 = 0x8B5B, + GL_FLOAT_MAT3_ARB = 0x8B5B, + GL_FLOAT_MAT4 = 0x8B5C, + GL_FLOAT_MAT4_ARB = 0x8B5C, + GL_SAMPLER_1D = 0x8B5D, + GL_SAMPLER_1D_ARB = 0x8B5D, + GL_SAMPLER_2D = 0x8B5E, + GL_SAMPLER_2D_ARB = 0x8B5E, + GL_SAMPLER_3D = 0x8B5F, + GL_SAMPLER_3D_ARB = 0x8B5F, + GL_SAMPLER_3D_OES = 0x8B5F, + GL_SAMPLER_CUBE = 0x8B60, + GL_SAMPLER_CUBE_ARB = 0x8B60, + GL_SAMPLER_1D_SHADOW = 0x8B61, + GL_SAMPLER_1D_SHADOW_ARB = 0x8B61, + GL_SAMPLER_2D_SHADOW = 0x8B62, + GL_SAMPLER_2D_SHADOW_ARB = 0x8B62, + GL_SAMPLER_2D_SHADOW_EXT = 0x8B62, + GL_SAMPLER_2D_RECT = 0x8B63, + GL_SAMPLER_2D_RECT_ARB = 0x8B63, + GL_SAMPLER_2D_RECT_SHADOW = 0x8B64, + GL_SAMPLER_2D_RECT_SHADOW_ARB = 0x8B64, + GL_FLOAT_MAT2x3 = 0x8B65, + GL_FLOAT_MAT2x3_NV = 0x8B65, + GL_FLOAT_MAT2x4 = 0x8B66, + GL_FLOAT_MAT2x4_NV = 0x8B66, + GL_FLOAT_MAT3x2 = 0x8B67, + GL_FLOAT_MAT3x2_NV = 0x8B67, + GL_FLOAT_MAT3x4 = 0x8B68, + GL_FLOAT_MAT3x4_NV = 0x8B68, + GL_FLOAT_MAT4x2 = 0x8B69, + GL_FLOAT_MAT4x2_NV = 0x8B69, + GL_FLOAT_MAT4x3 = 0x8B6A, + GL_FLOAT_MAT4x3_NV = 0x8B6A, +} AttributeType; + +typedef enum WGLColorBufferMask { + WGL_FRONT_COLOR_BUFFER_BIT_ARB = 0x00000001, + WGL_BACK_COLOR_BUFFER_BIT_ARB = 0x00000002, + WGL_DEPTH_BUFFER_BIT_ARB = 0x00000004, + WGL_STENCIL_BUFFER_BIT_ARB = 0x00000008, +} WGLColorBufferMask; + +typedef enum WGLContextFlagsMask { + WGL_CONTEXT_DEBUG_BIT_ARB = 0x00000001, + WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB = 0x00000002, + WGL_CONTEXT_ROBUST_ACCESS_BIT_ARB = 0x00000004, + WGL_CONTEXT_RESET_ISOLATION_BIT_ARB = 0x00000008, +} WGLContextFlagsMask; + +typedef enum WGLContextProfileMask { + WGL_CONTEXT_CORE_PROFILE_BIT_ARB = 0x00000001, + WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB = 0x00000002, + WGL_CONTEXT_ES_PROFILE_BIT_EXT = 0x00000004, + WGL_CONTEXT_ES2_PROFILE_BIT_EXT = 0x00000004, +} WGLContextProfileMask; + +typedef enum WGLImageBufferMaskI3D { + WGL_IMAGE_BUFFER_MIN_ACCESS_I3D = 0x00000001, + WGL_IMAGE_BUFFER_LOCK_I3D = 0x00000002, +} WGLImageBufferMaskI3D; + +typedef enum WGLDXInteropMaskNV { + WGL_ACCESS_READ_ONLY_NV = 0x00000000, + WGL_ACCESS_READ_WRITE_NV = 0x00000001, + WGL_ACCESS_WRITE_DISCARD_NV = 0x00000002, +} WGLDXInteropMaskNV; + +typedef enum WGL { + WGL_GPU_VENDOR_AMD = 0x1F00, + WGL_GPU_RENDERER_STRING_AMD = 0x1F01, + WGL_GPU_OPENGL_VERSION_STRING_AMD = 0x1F02, + WGL_NUMBER_PIXEL_FORMATS_ARB = 0x2000, + WGL_NUMBER_PIXEL_FORMATS_EXT = 0x2000, + WGL_DRAW_TO_WINDOW_ARB = 0x2001, + WGL_DRAW_TO_WINDOW_EXT = 0x2001, + WGL_DRAW_TO_BITMAP_ARB = 0x2002, + WGL_DRAW_TO_BITMAP_EXT = 0x2002, + WGL_ACCELERATION_ARB = 0x2003, + WGL_ACCELERATION_EXT = 0x2003, + WGL_NEED_PALETTE_ARB = 0x2004, + WGL_NEED_PALETTE_EXT = 0x2004, + WGL_NEED_SYSTEM_PALETTE_ARB = 0x2005, + WGL_NEED_SYSTEM_PALETTE_EXT = 0x2005, + WGL_SWAP_LAYER_BUFFERS_ARB = 0x2006, + WGL_SWAP_LAYER_BUFFERS_EXT = 0x2006, + WGL_SWAP_METHOD_ARB = 0x2007, + WGL_SWAP_METHOD_EXT = 0x2007, + WGL_NUMBER_OVERLAYS_ARB = 0x2008, + WGL_NUMBER_OVERLAYS_EXT = 0x2008, + WGL_NUMBER_UNDERLAYS_ARB = 0x2009, + WGL_NUMBER_UNDERLAYS_EXT = 0x2009, + WGL_TRANSPARENT_ARB = 0x200A, + WGL_TRANSPARENT_EXT = 0x200A, + WGL_TRANSPARENT_VALUE_EXT = 0x200B, + WGL_SHARE_DEPTH_ARB = 0x200C, + WGL_SHARE_DEPTH_EXT = 0x200C, + WGL_SHARE_STENCIL_ARB = 0x200D, + WGL_SHARE_STENCIL_EXT = 0x200D, + WGL_SHARE_ACCUM_ARB = 0x200E, + WGL_SHARE_ACCUM_EXT = 0x200E, + WGL_SUPPORT_GDI_ARB = 0x200F, + WGL_SUPPORT_GDI_EXT = 0x200F, + WGL_SUPPORT_OPENGL_ARB = 0x2010, + WGL_SUPPORT_OPENGL_EXT = 0x2010, + WGL_DOUBLE_BUFFER_ARB = 0x2011, + WGL_DOUBLE_BUFFER_EXT = 0x2011, + WGL_STEREO_ARB = 0x2012, + WGL_STEREO_EXT = 0x2012, + WGL_PIXEL_TYPE_ARB = 0x2013, + WGL_PIXEL_TYPE_EXT = 0x2013, + WGL_COLOR_BITS_ARB = 0x2014, + WGL_COLOR_BITS_EXT = 0x2014, + WGL_RED_BITS_ARB = 0x2015, + WGL_RED_BITS_EXT = 0x2015, + WGL_RED_SHIFT_ARB = 0x2016, + WGL_RED_SHIFT_EXT = 0x2016, + WGL_GREEN_BITS_ARB = 0x2017, + WGL_GREEN_BITS_EXT = 0x2017, + WGL_GREEN_SHIFT_ARB = 0x2018, + WGL_GREEN_SHIFT_EXT = 0x2018, + WGL_BLUE_BITS_ARB = 0x2019, + WGL_BLUE_BITS_EXT = 0x2019, + WGL_BLUE_SHIFT_ARB = 0x201A, + WGL_BLUE_SHIFT_EXT = 0x201A, + WGL_ALPHA_BITS_ARB = 0x201B, + WGL_ALPHA_BITS_EXT = 0x201B, + WGL_ALPHA_SHIFT_ARB = 0x201C, + WGL_ALPHA_SHIFT_EXT = 0x201C, + WGL_ACCUM_BITS_ARB = 0x201D, + WGL_ACCUM_BITS_EXT = 0x201D, + WGL_ACCUM_RED_BITS_ARB = 0x201E, + WGL_ACCUM_RED_BITS_EXT = 0x201E, + WGL_ACCUM_GREEN_BITS_ARB = 0x201F, + WGL_ACCUM_GREEN_BITS_EXT = 0x201F, + WGL_ACCUM_BLUE_BITS_ARB = 0x2020, + WGL_ACCUM_BLUE_BITS_EXT = 0x2020, + WGL_ACCUM_ALPHA_BITS_ARB = 0x2021, + WGL_ACCUM_ALPHA_BITS_EXT = 0x2021, + WGL_DEPTH_BITS_ARB = 0x2022, + WGL_DEPTH_BITS_EXT = 0x2022, + WGL_STENCIL_BITS_ARB = 0x2023, + WGL_STENCIL_BITS_EXT = 0x2023, + WGL_AUX_BUFFERS_ARB = 0x2024, + WGL_AUX_BUFFERS_EXT = 0x2024, + WGL_NO_ACCELERATION_ARB = 0x2025, + WGL_NO_ACCELERATION_EXT = 0x2025, + WGL_GENERIC_ACCELERATION_ARB = 0x2026, + WGL_GENERIC_ACCELERATION_EXT = 0x2026, + WGL_FULL_ACCELERATION_ARB = 0x2027, + WGL_FULL_ACCELERATION_EXT = 0x2027, + WGL_SWAP_EXCHANGE_ARB = 0x2028, + WGL_SWAP_EXCHANGE_EXT = 0x2028, + WGL_SWAP_COPY_ARB = 0x2029, + WGL_SWAP_COPY_EXT = 0x2029, + WGL_SWAP_UNDEFINED_ARB = 0x202A, + WGL_SWAP_UNDEFINED_EXT = 0x202A, + WGL_TYPE_RGBA_ARB = 0x202B, + WGL_TYPE_RGBA_EXT = 0x202B, + WGL_TYPE_COLORINDEX_ARB = 0x202C, + WGL_TYPE_COLORINDEX_EXT = 0x202C, + WGL_DRAW_TO_PBUFFER_ARB = 0x202D, + WGL_DRAW_TO_PBUFFER_EXT = 0x202D, + WGL_MAX_PBUFFER_PIXELS_ARB = 0x202E, + WGL_MAX_PBUFFER_PIXELS_EXT = 0x202E, + WGL_MAX_PBUFFER_WIDTH_ARB = 0x202F, + WGL_MAX_PBUFFER_WIDTH_EXT = 0x202F, + WGL_MAX_PBUFFER_HEIGHT_ARB = 0x2030, + WGL_MAX_PBUFFER_HEIGHT_EXT = 0x2030, + WGL_OPTIMAL_PBUFFER_WIDTH_EXT = 0x2031, + WGL_OPTIMAL_PBUFFER_HEIGHT_EXT = 0x2032, + WGL_PBUFFER_LARGEST_ARB = 0x2033, + WGL_PBUFFER_LARGEST_EXT = 0x2033, + WGL_PBUFFER_WIDTH_ARB = 0x2034, + WGL_PBUFFER_WIDTH_EXT = 0x2034, + WGL_PBUFFER_HEIGHT_ARB = 0x2035, + WGL_PBUFFER_HEIGHT_EXT = 0x2035, + WGL_PBUFFER_LOST_ARB = 0x2036, + WGL_TRANSPARENT_RED_VALUE_ARB = 0x2037, + WGL_TRANSPARENT_GREEN_VALUE_ARB = 0x2038, + WGL_TRANSPARENT_BLUE_VALUE_ARB = 0x2039, + WGL_TRANSPARENT_ALPHA_VALUE_ARB = 0x203A, + WGL_TRANSPARENT_INDEX_VALUE_ARB = 0x203B, + WGL_DEPTH_FLOAT_EXT = 0x2040, + WGL_SAMPLE_BUFFERS_ARB = 0x2041, + WGL_SAMPLE_BUFFERS_EXT = 0x2041, + WGL_COVERAGE_SAMPLES_NV = 0x2042, + WGL_SAMPLES_ARB = 0x2042, + WGL_SAMPLES_EXT = 0x2042, + ERROR_INVALID_PIXEL_TYPE_ARB = 0x2043, + ERROR_INVALID_PIXEL_TYPE_EXT = 0x2043, + WGL_GENLOCK_SOURCE_MULTIVIEW_I3D = 0x2044, + WGL_GENLOCK_SOURCE_EXTERNAL_SYNC_I3D = 0x2045, + WGL_GENLOCK_SOURCE_EXTERNAL_FIELD_I3D = 0x2046, + WGL_GENLOCK_SOURCE_EXTERNAL_TTL_I3D = 0x2047, + WGL_GENLOCK_SOURCE_DIGITAL_SYNC_I3D = 0x2048, + WGL_GENLOCK_SOURCE_DIGITAL_FIELD_I3D = 0x2049, + WGL_GENLOCK_SOURCE_EDGE_FALLING_I3D = 0x204A, + WGL_GENLOCK_SOURCE_EDGE_RISING_I3D = 0x204B, + WGL_GENLOCK_SOURCE_EDGE_BOTH_I3D = 0x204C, + WGL_GAMMA_TABLE_SIZE_I3D = 0x204E, + WGL_GAMMA_EXCLUDE_DESKTOP_I3D = 0x204F, + WGL_DIGITAL_VIDEO_CURSOR_ALPHA_FRAMEBUFFER_I3D = 0x2050, + WGL_DIGITAL_VIDEO_CURSOR_ALPHA_VALUE_I3D = 0x2051, + WGL_DIGITAL_VIDEO_CURSOR_INCLUDED_I3D = 0x2052, + WGL_DIGITAL_VIDEO_GAMMA_CORRECTED_I3D = 0x2053, + ERROR_INCOMPATIBLE_DEVICE_CONTEXTS_ARB = 0x2054, + WGL_STEREO_EMITTER_ENABLE_3DL = 0x2055, + WGL_STEREO_EMITTER_DISABLE_3DL = 0x2056, + WGL_STEREO_POLARITY_NORMAL_3DL = 0x2057, + WGL_STEREO_POLARITY_INVERT_3DL = 0x2058, + WGL_SAMPLE_BUFFERS_3DFX = 0x2060, + WGL_SAMPLES_3DFX = 0x2061, + WGL_BIND_TO_TEXTURE_RGB_ARB = 0x2070, + WGL_BIND_TO_TEXTURE_RGBA_ARB = 0x2071, + WGL_TEXTURE_FORMAT_ARB = 0x2072, + WGL_TEXTURE_TARGET_ARB = 0x2073, + WGL_MIPMAP_TEXTURE_ARB = 0x2074, + WGL_TEXTURE_RGB_ARB = 0x2075, + WGL_TEXTURE_RGBA_ARB = 0x2076, + WGL_NO_TEXTURE_ARB = 0x2077, + WGL_TEXTURE_CUBE_MAP_ARB = 0x2078, + WGL_TEXTURE_1D_ARB = 0x2079, + WGL_TEXTURE_2D_ARB = 0x207A, + WGL_MIPMAP_LEVEL_ARB = 0x207B, + WGL_CUBE_MAP_FACE_ARB = 0x207C, + WGL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB = 0x207D, + WGL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB = 0x207E, + WGL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB = 0x207F, + WGL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB = 0x2080, + WGL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB = 0x2081, + WGL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB = 0x2082, + WGL_FRONT_LEFT_ARB = 0x2083, + WGL_FRONT_RIGHT_ARB = 0x2084, + WGL_BACK_LEFT_ARB = 0x2085, + WGL_BACK_RIGHT_ARB = 0x2086, + WGL_AUX0_ARB = 0x2087, + WGL_AUX1_ARB = 0x2088, + WGL_AUX2_ARB = 0x2089, + WGL_AUX3_ARB = 0x208A, + WGL_AUX4_ARB = 0x208B, + WGL_AUX5_ARB = 0x208C, + WGL_AUX6_ARB = 0x208D, + WGL_AUX7_ARB = 0x208E, + WGL_AUX8_ARB = 0x208F, + WGL_AUX9_ARB = 0x2090, + WGL_CONTEXT_MAJOR_VERSION_ARB = 0x2091, + WGL_CONTEXT_MINOR_VERSION_ARB = 0x2092, + WGL_CONTEXT_LAYER_PLANE_ARB = 0x2093, + WGL_CONTEXT_FLAGS_ARB = 0x2094, + ERROR_INVALID_VERSION_ARB = 0x2095, + ERROR_INVALID_PROFILE_ARB = 0x2096, + WGL_CONTEXT_RELEASE_BEHAVIOR_ARB = 0x2097, + WGL_CONTEXT_RELEASE_BEHAVIOR_FLUSH_ARB = 0x2098, + WGL_BIND_TO_TEXTURE_RECTANGLE_RGB_NV = 0x20A0, + WGL_BIND_TO_TEXTURE_RECTANGLE_RGBA_NV = 0x20A1, + WGL_TEXTURE_RECTANGLE_NV = 0x20A2, + WGL_BIND_TO_TEXTURE_DEPTH_NV = 0x20A3, + WGL_BIND_TO_TEXTURE_RECTANGLE_DEPTH_NV = 0x20A4, + WGL_DEPTH_TEXTURE_FORMAT_NV = 0x20A5, + WGL_TEXTURE_DEPTH_COMPONENT_NV = 0x20A6, + WGL_DEPTH_COMPONENT_NV = 0x20A7, + WGL_TYPE_RGBA_UNSIGNED_FLOAT_EXT = 0x20A8, + WGL_FRAMEBUFFER_SRGB_CAPABLE_ARB = 0x20A9, + WGL_FRAMEBUFFER_SRGB_CAPABLE_EXT = 0x20A9, + WGL_CONTEXT_MULTIGPU_ATTRIB_NV = 0x20AA, + WGL_CONTEXT_MULTIGPU_ATTRIB_SINGLE_NV = 0x20AB, + WGL_CONTEXT_MULTIGPU_ATTRIB_AFR_NV = 0x20AC, + WGL_CONTEXT_MULTIGPU_ATTRIB_MULTICAST_NV = 0x20AD, + WGL_CONTEXT_MULTIGPU_ATTRIB_MULTI_DISPLAY_MULTICAST_NV = 0x20AE, + WGL_FLOAT_COMPONENTS_NV = 0x20B0, + WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_R_NV = 0x20B1, + WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RG_NV = 0x20B2, + WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RGB_NV = 0x20B3, + WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RGBA_NV = 0x20B4, + WGL_TEXTURE_FLOAT_R_NV = 0x20B5, + WGL_TEXTURE_FLOAT_RG_NV = 0x20B6, + WGL_TEXTURE_FLOAT_RGB_NV = 0x20B7, + WGL_TEXTURE_FLOAT_RGBA_NV = 0x20B8, + WGL_COLOR_SAMPLES_NV = 0x20B9, + WGL_BIND_TO_VIDEO_RGB_NV = 0x20C0, + WGL_BIND_TO_VIDEO_RGBA_NV = 0x20C1, + WGL_BIND_TO_VIDEO_RGB_AND_DEPTH_NV = 0x20C2, + WGL_VIDEO_OUT_COLOR_NV = 0x20C3, + WGL_VIDEO_OUT_ALPHA_NV = 0x20C4, + WGL_VIDEO_OUT_DEPTH_NV = 0x20C5, + WGL_VIDEO_OUT_COLOR_AND_ALPHA_NV = 0x20C6, + WGL_VIDEO_OUT_COLOR_AND_DEPTH_NV = 0x20C7, + WGL_VIDEO_OUT_FRAME = 0x20C8, + WGL_VIDEO_OUT_FIELD_1 = 0x20C9, + WGL_VIDEO_OUT_FIELD_2 = 0x20CA, + WGL_VIDEO_OUT_STACKED_FIELDS_1_2 = 0x20CB, + WGL_VIDEO_OUT_STACKED_FIELDS_2_1 = 0x20CC, + WGL_UNIQUE_ID_NV = 0x20CE, + WGL_NUM_VIDEO_CAPTURE_SLOTS_NV = 0x20CF, + ERROR_INCOMPATIBLE_AFFINITY_MASKS_NV = 0x20D0, + ERROR_MISSING_AFFINITY_MASK_NV = 0x20D1, + WGL_NUM_VIDEO_SLOTS_NV = 0x20F0, + WGL_TYPE_RGBA_FLOAT_ARB = 0x21A0, + WGL_TYPE_RGBA_FLOAT_ATI = 0x21A0, + WGL_GPU_FASTEST_TARGET_GPUS_AMD = 0x21A2, + WGL_GPU_RAM_AMD = 0x21A3, + WGL_GPU_CLOCK_AMD = 0x21A4, + WGL_GPU_NUM_PIPES_AMD = 0x21A5, + WGL_TEXTURE_RECTANGLE_ATI = 0x21A5, + WGL_GPU_NUM_SIMD_AMD = 0x21A6, + WGL_GPU_NUM_RB_AMD = 0x21A7, + WGL_GPU_NUM_SPI_AMD = 0x21A8, + WGL_CONTEXT_OPENGL_NO_ERROR_ARB = 0x31B3, +} WGL; + +typedef enum EGL { + WGL_COLORSPACE_EXT = 0x309D, + WGL_COLORSPACE_SRGB_EXT = 0x3089, + WGL_COLORSPACE_LINEAR_EXT = 0x308A, +} EGL; diff --git a/src/DivaGL/gl_array_buffer.hpp b/src/DivaGL/gl_array_buffer.hpp new file mode 100644 index 0000000..9e0a57b --- /dev/null +++ b/src/DivaGL/gl_array_buffer.hpp @@ -0,0 +1,144 @@ +/* + by korenkonder + GitHub/GitLab: korenkonder +*/ + +#pragma once + +#include "wrap.hpp" +#include "gl_state.hpp" + +struct GLArrayBuffer { +private: + GLuint buffer; + +public: + inline GLArrayBuffer() : buffer() { + + } + + inline ~GLArrayBuffer() { + + } + + inline void Bind(bool force = false) { + gl_state_bind_array_buffer(buffer, force); + } + + inline void Create(size_t size) { + if (buffer) + return; + + if (GL_VERSION_4_5) { + glCreateBuffers(1, &buffer); + glNamedBufferStorage(buffer, (GLsizeiptr)size, 0, GL_DYNAMIC_STORAGE_BIT | GL_MAP_WRITE_BIT); + } + else { + glGenBuffers(1, &buffer); + gl_state_bind_array_buffer(buffer); + if (GL_VERSION_4_4) + glBufferStorage(GL_ARRAY_BUFFER, (GLsizeiptr)size, + 0, GL_DYNAMIC_STORAGE_BIT | GL_MAP_WRITE_BIT); + else + glBufferData(GL_ARRAY_BUFFER, (GLsizeiptr)size, 0, GL_DYNAMIC_DRAW); + } + + } + + inline void Create(size_t size, const void* data, bool dynamic = false) { + if (buffer) + return; + + if (GL_VERSION_4_5) { + glCreateBuffers(1, &buffer); + glNamedBufferStorage(buffer, (GLsizeiptr)size, data, + dynamic ? GL_DYNAMIC_STORAGE_BIT | GL_MAP_WRITE_BIT : 0); + } + else { + glGenBuffers(1, &buffer); + gl_state_bind_array_buffer(buffer); + if (GL_VERSION_4_4) + glBufferStorage(GL_ARRAY_BUFFER, (GLsizeiptr)size, data, + dynamic ? GL_DYNAMIC_STORAGE_BIT | GL_MAP_WRITE_BIT : 0); + else + glBufferData(GL_ARRAY_BUFFER, (GLsizeiptr)size, data, + dynamic ? GL_DYNAMIC_DRAW : GL_STATIC_DRAW); + } + } + + inline void Destroy() { + if (buffer) { + glDeleteBuffers(1, &buffer); + buffer = 0; + } + } + + inline bool IsNull() { + return !buffer; + } + + inline void* MapMemory() { + if (!buffer) + return 0; + + void* data; + if (GL_VERSION_4_5) + data = glMapNamedBuffer(buffer, GL_WRITE_ONLY); + else { + gl_state_bind_array_buffer(buffer); + data = glMapBuffer(GL_ARRAY_BUFFER, GL_WRITE_ONLY); + } + + if (data) + return data; + + if (GL_VERSION_4_5) + glUnmapNamedBuffer(buffer); + else { + glUnmapBuffer(GL_ARRAY_BUFFER); + gl_state_bind_array_buffer(0); + } + return 0; + } + + inline bool NotNull() { + return !!buffer; + } + + inline void UnmapMemory() { + if (!buffer) + return; + + if (GL_VERSION_4_5) + glUnmapNamedBuffer(buffer); + else { + glUnmapBuffer(GL_ARRAY_BUFFER); + gl_state_bind_array_buffer(0); + } + } + + inline void WriteMemory(size_t offset, size_t size, const void* data) { + if (!buffer) + return; + + if (GL_VERSION_4_5) + glNamedBufferSubData(buffer, (GLsizeiptr)offset, (GLsizeiptr)size, data); + else { + gl_state_bind_array_buffer(buffer); + glBufferSubData(GL_ARRAY_BUFFER, (GLsizeiptr)offset, (GLsizeiptr)size, data); + } + } + + template + inline void WriteMemory(T& data) { + if (!buffer) + return; + + if (GL_VERSION_4_5) + glNamedBufferSubData(buffer, 0, sizeof(T), &data); + else { + gl_state_bind_array_buffer(buffer); + glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(T), &data); + } + } +}; diff --git a/src/DivaGL/gl_element_array_buffer.hpp b/src/DivaGL/gl_element_array_buffer.hpp new file mode 100644 index 0000000..6c3b054 --- /dev/null +++ b/src/DivaGL/gl_element_array_buffer.hpp @@ -0,0 +1,144 @@ +/* + by korenkonder + GitHub/GitLab: korenkonder +*/ + +#pragma once + +#include "wrap.hpp" +#include "gl_state.hpp" + +struct GLElementArrayBuffer { +private: + GLuint buffer; + +public: + inline GLElementArrayBuffer() : buffer() { + + } + + inline ~GLElementArrayBuffer() { + + } + + inline void Bind(bool force = false) { + gl_state_bind_element_array_buffer(buffer, force); + } + + inline void Create(size_t size) { + if (buffer) + return; + + if (GL_VERSION_4_5) { + glCreateBuffers(1, &buffer); + glNamedBufferStorage(buffer, (GLsizeiptr)size, 0, GL_DYNAMIC_STORAGE_BIT | GL_MAP_WRITE_BIT); + } + else { + glGenBuffers(1, &buffer); + gl_state_bind_element_array_buffer(buffer); + if (GL_VERSION_4_4) + glBufferStorage(GL_ELEMENT_ARRAY_BUFFER, (GLsizeiptr)size, + 0, GL_DYNAMIC_STORAGE_BIT | GL_MAP_WRITE_BIT); + else + glBufferData(GL_ELEMENT_ARRAY_BUFFER, (GLsizeiptr)size, 0, GL_DYNAMIC_DRAW); + } + + } + + inline void Create(size_t size, const void* data, bool dynamic = false) { + if (buffer) + return; + + if (GL_VERSION_4_5) { + glCreateBuffers(1, &buffer); + glNamedBufferStorage(buffer, (GLsizeiptr)size, data, + dynamic ? GL_DYNAMIC_STORAGE_BIT | GL_MAP_WRITE_BIT : 0); + } + else { + glGenBuffers(1, &buffer); + gl_state_bind_element_array_buffer(buffer); + if (GL_VERSION_4_4) + glBufferStorage(GL_ELEMENT_ARRAY_BUFFER, (GLsizeiptr)size, data, + dynamic ? GL_DYNAMIC_STORAGE_BIT | GL_MAP_WRITE_BIT : 0); + else + glBufferData(GL_ELEMENT_ARRAY_BUFFER, (GLsizeiptr)size, data, + dynamic ? GL_DYNAMIC_DRAW : GL_STATIC_DRAW); + } + } + + inline void Destroy() { + if (buffer) { + glDeleteBuffers(1, &buffer); + buffer = 0; + } + } + + inline bool IsNull() { + return !buffer; + } + + inline void* MapMemory() { + if (!buffer) + return 0; + + void* data; + if (GL_VERSION_4_5) + data = glMapNamedBuffer(buffer, GL_WRITE_ONLY); + else { + gl_state_bind_element_array_buffer(buffer); + data = glMapBuffer(GL_ELEMENT_ARRAY_BUFFER, GL_WRITE_ONLY); + } + + if (data) + return data; + + if (GL_VERSION_4_5) + glUnmapNamedBuffer(buffer); + else { + glUnmapBuffer(GL_ELEMENT_ARRAY_BUFFER); + gl_state_bind_element_array_buffer(0); + } + return 0; + } + + inline bool NotNull() { + return !!buffer; + } + + inline void UnmapMemory() { + if (!buffer) + return; + + if (GL_VERSION_4_5) + glUnmapNamedBuffer(buffer); + else { + glUnmapBuffer(GL_ELEMENT_ARRAY_BUFFER); + gl_state_bind_element_array_buffer(0); + } + } + + inline void WriteMemory(size_t offset, size_t size, const void* data) { + if (!buffer) + return; + + if (GL_VERSION_4_5) + glNamedBufferSubData(buffer, (GLsizeiptr)offset, (GLsizeiptr)size, data); + else { + gl_state_bind_element_array_buffer(buffer); + glBufferSubData(GL_ELEMENT_ARRAY_BUFFER, (GLsizeiptr)offset, (GLsizeiptr)size, data); + } + } + + template + inline void WriteMemory(T& data) { + if (!buffer) + return; + + if (GL_VERSION_4_5) + glNamedBufferSubData(buffer, 0, sizeof(T), &data); + else { + gl_state_bind_element_array_buffer(buffer); + glBufferSubData(GL_ELEMENT_ARRAY_BUFFER, 0, sizeof(T), &data); + } + } +}; diff --git a/src/DivaGL/gl_shader_storage_buffer.hpp b/src/DivaGL/gl_shader_storage_buffer.hpp new file mode 100644 index 0000000..45de18f --- /dev/null +++ b/src/DivaGL/gl_shader_storage_buffer.hpp @@ -0,0 +1,144 @@ +/* + by korenkonder + GitHub/GitLab: korenkonder +*/ + +#pragma once + +#include "wrap.hpp" +#include "gl_state.hpp" + +struct GLShaderStorageBuffer { +private: + GLuint buffer; + +public: + inline GLShaderStorageBuffer() : buffer() { + + } + + inline ~GLShaderStorageBuffer() { + + } + + inline void Bind(int32_t index, bool force = false) { + gl_state_bind_shader_storage_buffer_base(index, buffer, force); + } + + inline void Create(size_t size) { + if (buffer) + return; + + if (GL_VERSION_4_5) { + glCreateBuffers(1, &buffer); + glNamedBufferStorage(buffer, (GLsizeiptr)size, 0, GL_DYNAMIC_STORAGE_BIT | GL_MAP_WRITE_BIT); + } + else { + glGenBuffers(1, &buffer); + gl_state_bind_shader_storage_buffer(buffer); + if (GL_VERSION_4_4) + glBufferStorage(GL_SHADER_STORAGE_BUFFER, (GLsizeiptr)size, + 0, GL_DYNAMIC_STORAGE_BIT | GL_MAP_WRITE_BIT); + else + glBufferData(GL_SHADER_STORAGE_BUFFER, (GLsizeiptr)size, 0, GL_DYNAMIC_DRAW); + } + + } + + inline void Create(size_t size, const void* data, bool dynamic = false) { + if (buffer) + return; + + if (GL_VERSION_4_5) { + glCreateBuffers(1, &buffer); + glNamedBufferStorage(buffer, (GLsizeiptr)size, data, + dynamic ? GL_DYNAMIC_STORAGE_BIT | GL_MAP_WRITE_BIT : 0); + } + else { + glGenBuffers(1, &buffer); + gl_state_bind_shader_storage_buffer(buffer); + if (GL_VERSION_4_4) + glBufferStorage(GL_SHADER_STORAGE_BUFFER, (GLsizeiptr)size, data, + dynamic ? GL_DYNAMIC_STORAGE_BIT | GL_MAP_WRITE_BIT : 0); + else + glBufferData(GL_SHADER_STORAGE_BUFFER, (GLsizeiptr)size, data, + dynamic ? GL_DYNAMIC_DRAW : GL_STATIC_DRAW); + } + } + + inline void Destroy() { + if (buffer) { + glDeleteBuffers(1, &buffer); + buffer = 0; + } + } + + inline bool IsNull() { + return !buffer; + } + + inline void* MapMemory() { + if (!buffer) + return 0; + + void* data; + if (GL_VERSION_4_5) + data = glMapNamedBuffer(buffer, GL_WRITE_ONLY); + else { + gl_state_bind_shader_storage_buffer(buffer); + data = glMapBuffer(GL_SHADER_STORAGE_BUFFER, GL_WRITE_ONLY); + } + + if (data) + return data; + + if (GL_VERSION_4_5) + glUnmapNamedBuffer(buffer); + else { + glUnmapBuffer(GL_SHADER_STORAGE_BUFFER); + gl_state_bind_shader_storage_buffer(0); + } + return 0; + } + + inline bool NotNull() { + return !!buffer; + } + + inline void UnmapMemory() { + if (!buffer) + return; + + if (GL_VERSION_4_5) + glUnmapNamedBuffer(buffer); + else { + glUnmapBuffer(GL_SHADER_STORAGE_BUFFER); + gl_state_bind_shader_storage_buffer(0); + } + } + + inline void WriteMemory(size_t offset, size_t size, const void* data) { + if (!buffer) + return; + + if (GL_VERSION_4_5) + glNamedBufferSubData(buffer, (GLsizeiptr)offset, (GLsizeiptr)size, data); + else { + gl_state_bind_shader_storage_buffer(buffer); + glBufferSubData(GL_SHADER_STORAGE_BUFFER, (GLsizeiptr)offset, (GLsizeiptr)size, data); + } + } + + template + inline void WriteMemory(T& data) { + if (!buffer) + return; + + if (GL_VERSION_4_5) + glNamedBufferSubData(buffer, 0, sizeof(T), &data); + else { + gl_state_bind_shader_storage_buffer(buffer); + glBufferSubData(GL_SHADER_STORAGE_BUFFER, 0, sizeof(T), &data); + } + } +}; diff --git a/src/DivaGL/gl_state.cpp b/src/DivaGL/gl_state.cpp new file mode 100644 index 0000000..a4b101c --- /dev/null +++ b/src/DivaGL/gl_state.cpp @@ -0,0 +1,489 @@ +/* + by korenkonder + GitHub/GitLab: korenkonder +*/ + +#include "gl_state.hpp" +#include "wrap.hpp" + +gl_state_struct gl_state; + +void gl_state_active_bind_texture_2d(int32_t index, GLuint texture, bool force) { + if (force || gl_state.texture_binding_2d[index] != texture) { + if (force || gl_state.active_texture_index != index) { + glActiveTexture((GLenum)(GL_TEXTURE0 + index)); + gl_state.active_texture = (GLenum)(GL_TEXTURE0 + index); + gl_state.active_texture_index = (GLuint)index; + } + glBindTextureDLL(GL_TEXTURE_2D, texture); + gl_state.texture_binding_2d[index] = texture; + } +} + +void gl_state_active_bind_texture_cube_map(int32_t index, GLuint texture, bool force) { + if (force || gl_state.texture_binding_cube_map[index] != texture) { + if (force || gl_state.active_texture_index != index) { + glActiveTexture((GLenum)(GL_TEXTURE0 + index)); + gl_state.active_texture = (GLenum)(GL_TEXTURE0 + index); + gl_state.active_texture_index = (GLuint)index; + } + glBindTextureDLL(GL_TEXTURE_CUBE_MAP, texture); + gl_state.texture_binding_cube_map[index] = texture; + } +} + +void gl_state_active_texture(size_t index, bool force) { + if (force || gl_state.active_texture_index != index) { + glActiveTexture((GLenum)(GL_TEXTURE0 + index)); + gl_state.active_texture = (GLenum)(GL_TEXTURE0 + index); + gl_state.active_texture_index = (GLuint)index; + } +} + +void gl_state_bind_framebuffer(GLuint framebuffer, bool force) { + if (force || gl_state.read_framebuffer_binding != framebuffer + || gl_state.draw_framebuffer_binding != framebuffer) { + glBindFramebuffer(GL_FRAMEBUFFER, framebuffer); + gl_state.read_framebuffer_binding = framebuffer; + gl_state.draw_framebuffer_binding = framebuffer; + } +} + +void gl_state_bind_read_framebuffer(GLuint framebuffer, bool force) { + if (force || gl_state.read_framebuffer_binding != framebuffer) { + glBindFramebuffer(GL_READ_FRAMEBUFFER, framebuffer); + gl_state.read_framebuffer_binding = framebuffer; + } +} + +void gl_state_bind_draw_framebuffer(GLuint framebuffer, bool force) { + if (force || gl_state.draw_framebuffer_binding != framebuffer) { + glBindFramebuffer(GL_DRAW_FRAMEBUFFER, framebuffer); + gl_state.draw_framebuffer_binding = framebuffer; + } +} + +void gl_state_bind_vertex_array(GLuint array, bool force) { + if (force || gl_state.vertex_array_binding != array) { + glBindVertexArray(array); + gl_state.vertex_array_binding = array; + } +} + +void gl_state_bind_array_buffer(GLuint buffer, bool force) { + if (force || gl_state.array_buffer_binding != buffer) { + glBindBuffer(GL_ARRAY_BUFFER, buffer); + gl_state.array_buffer_binding = buffer; + } +} + +void gl_state_bind_element_array_buffer(GLuint buffer, bool force) { + if (force || gl_state.element_array_buffer_binding != buffer) { + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffer); + gl_state.element_array_buffer_binding = buffer; + } +} + +void gl_state_bind_uniform_buffer(GLuint buffer, bool force) { + if (force || gl_state.uniform_buffer_binding != buffer) { + glBindBuffer(GL_UNIFORM_BUFFER, buffer); + gl_state.uniform_buffer_binding = buffer; + } +} + +void gl_state_bind_uniform_buffer_base(GLuint index, GLuint buffer, bool force) { + if (force || gl_state.uniform_buffer_bindings[index] != buffer) { + glBindBufferBase(GL_UNIFORM_BUFFER, index, buffer); + gl_state.uniform_buffer_bindings[index] = buffer; + gl_state.uniform_buffer_offsets[index] = 0; + gl_state.uniform_buffer_sizes[index] = -1; + } +} + +void gl_state_bind_uniform_buffer_range(GLuint index, + GLuint buffer, GLintptr offset, GLsizeiptr size, bool force) { + if (force || gl_state.uniform_buffer_bindings[index] != buffer + || gl_state.uniform_buffer_offsets[index] != offset + || gl_state.uniform_buffer_sizes[index] != size) { + glBindBufferRange(GL_UNIFORM_BUFFER, index, buffer, offset, size); + gl_state.uniform_buffer_bindings[index] = buffer; + gl_state.uniform_buffer_offsets[index] = offset; + gl_state.uniform_buffer_sizes[index] = size; + } +} + +void gl_state_bind_shader_storage_buffer(GLuint buffer, bool force) { + if (force || gl_state.shader_storage_buffer_binding != buffer) { + glBindBuffer(GL_SHADER_STORAGE_BUFFER, buffer); + gl_state.shader_storage_buffer_binding = buffer; + } +} + +void gl_state_bind_shader_storage_buffer_base(GLuint index, GLuint buffer, bool force) { + if (force || gl_state.shader_storage_buffer_bindings[index] != buffer) { + glBindBufferBase(GL_SHADER_STORAGE_BUFFER, index, buffer); + gl_state.shader_storage_buffer_bindings[index] = buffer; + gl_state.shader_storage_buffer_offsets[index] = 0; + gl_state.shader_storage_buffer_sizes[index] = -1; + } +} + +void gl_state_bind_shader_storage_buffer_range(GLuint index, + GLuint buffer, GLintptr offset, GLsizeiptr size, bool force) { + if (force || gl_state.shader_storage_buffer_bindings[index] != buffer + || gl_state.shader_storage_buffer_offsets[index] != offset + || gl_state.shader_storage_buffer_sizes[index] != size) { + glBindBufferRange(GL_SHADER_STORAGE_BUFFER, index, buffer, offset, size); + gl_state.shader_storage_buffer_bindings[index] = buffer; + gl_state.shader_storage_buffer_offsets[index] = offset; + gl_state.shader_storage_buffer_sizes[index] = size; + } +} + +void gl_state_bind_texture_2d(GLuint texture, bool force) { + if (gl_state.texture_binding_2d[gl_state.active_texture_index] != texture) { + glBindTextureDLL(GL_TEXTURE_2D, texture); + gl_state.texture_binding_2d[gl_state.active_texture_index] = texture; + } +} + +void gl_state_bind_texture_cube_map(GLuint texture, bool force) { + if (force || gl_state.texture_binding_cube_map[gl_state.active_texture_index] != texture) { + glBindTextureDLL(GL_TEXTURE_CUBE_MAP, texture); + gl_state.texture_binding_cube_map[gl_state.active_texture_index] = texture; + } +} + +void gl_state_bind_sampler(int32_t index, GLuint sampler, bool force) { + if (force || gl_state.sampler_binding[index] != sampler) { + glBindSampler(index, sampler); + gl_state.sampler_binding[index] = sampler; + } +} + +bool gl_state_check_uniform_buffer_binding() { + return gl_state.uniform_buffer_binding != 0; +} + +bool gl_state_check_uniform_buffer_binding_base(size_t index) { + return gl_state.uniform_buffer_bindings[index] != 0; +} + +bool gl_state_check_texture_binding_2d(size_t index) { + return gl_state.texture_binding_2d[index] != 0; +} + +bool gl_state_check_shader_storage_buffer_binding() { + return gl_state.shader_storage_buffer_binding != 0; +} + +bool gl_state_check_shader_storage_buffer_binding_base(size_t index) { + return gl_state.shader_storage_buffer_bindings[index] != 0; +} + +bool gl_state_check_texture_binding_cube_map(size_t index) { + return gl_state.texture_binding_cube_map[index] != 0; +} + +bool gl_state_check_sampler_binding(int32_t index, GLuint sampler) { + return gl_state.sampler_binding[index] != 0; +} + +void gl_state_disable_blend(bool force) { + if (force || gl_state.blend) { + glDisableDLL(GL_BLEND); + gl_state.blend = GL_FALSE; + } +} + +void gl_state_disable_cull_face(bool force) { + if (force || gl_state.cull_face) { + glDisableDLL(GL_CULL_FACE); + gl_state.cull_face = GL_FALSE; + } +} + +void gl_state_disable_depth_test(bool force) { + if (force || gl_state.depth_test) { + glDisableDLL(GL_DEPTH_TEST); + gl_state.depth_test = GL_FALSE; + } +} + +void gl_state_disable_multisample(bool force) { + if (force || gl_state.multisample) { + glDisableDLL(GL_MULTISAMPLE); + gl_state.multisample = GL_FALSE; + } +} + +void gl_state_disable_primitive_restart(bool force) { + if (force || gl_state.primitive_restart) { + glDisableDLL(GL_PRIMITIVE_RESTART); + gl_state.primitive_restart = GL_FALSE; + } +} + +void gl_state_disable_scissor_test(bool force) { + if (force || gl_state.scissor_test) { + glDisableDLL(GL_SCISSOR_TEST); + gl_state.scissor_test = GL_FALSE; + } +} + +void gl_state_disable_stencil_test(bool force) { + if (force || gl_state.stencil_test) { + glDisableDLL(GL_STENCIL_TEST); + gl_state.stencil_test = GL_FALSE; + } +} + +void gl_state_enable_blend(bool force) { + if (force || !gl_state.blend) { + glEnableDLL(GL_BLEND); + gl_state.blend = GL_TRUE; + } +} + +void gl_state_enable_cull_face(bool force) { + if (force || !gl_state.cull_face) { + glEnableDLL(GL_CULL_FACE); + gl_state.cull_face = GL_TRUE; + } +} + +void gl_state_enable_depth_test(bool force) { + if (force || !gl_state.depth_test) { + glEnableDLL(GL_DEPTH_TEST); + gl_state.depth_test = GL_TRUE; + } +} + +void gl_state_enable_multisample(bool force) { + if (force || !gl_state.multisample) { + glEnableDLL(GL_MULTISAMPLE); + gl_state.multisample = GL_TRUE; + } +} + +void gl_state_enable_primitive_restart(bool force) { + if (force || !gl_state.primitive_restart) { + glEnableDLL(GL_PRIMITIVE_RESTART); + gl_state.primitive_restart = GL_TRUE; + } +} + +void gl_state_enable_scissor_test(bool force) { + if (force || !gl_state.scissor_test) { + glEnableDLL(GL_SCISSOR_TEST); + gl_state.scissor_test = GL_TRUE; + } +} + +void gl_state_enable_stencil_test(bool force) { + if (force || !gl_state.stencil_test) { + glEnableDLL(GL_STENCIL_TEST); + gl_state.stencil_test = GL_TRUE; + } +} + +void gl_state_get() { + glGetIntegervDLL(GL_CURRENT_PROGRAM, &gl_state.program); + glGetIntegervDLL(GL_ACTIVE_TEXTURE, (GLint*)&gl_state.active_texture); + gl_state.active_texture_index = gl_state.active_texture - GL_TEXTURE0; + for (GLuint i = 0; i < 32; i++) { + glActiveTexture((GLenum)(GL_TEXTURE0 + i)); + glGetIntegervDLL(GL_TEXTURE_BINDING_2D, &gl_state.texture_binding_2d[i]); + glGetIntegervDLL(GL_TEXTURE_BINDING_CUBE_MAP, &gl_state.texture_binding_cube_map[i]); + glGetIntegeri_v(GL_SAMPLER_BINDING, i, &gl_state.sampler_binding[i]); + } + glActiveTexture(gl_state.active_texture); + + glGetBooleanvDLL(GL_BLEND, &gl_state.blend); + glGetIntegervDLL(GL_BLEND_SRC_RGB, (GLint*)&gl_state.blend_src_rgb); + glGetIntegervDLL(GL_BLEND_SRC_ALPHA, (GLint*)&gl_state.blend_src_alpha); + glGetIntegervDLL(GL_BLEND_DST_RGB, (GLint*)&gl_state.blend_dst_rgb); + glGetIntegervDLL(GL_BLEND_DST_ALPHA, (GLint*)&gl_state.blend_dst_alpha); + glGetIntegervDLL(GL_BLEND_EQUATION_RGB, (GLint*)&gl_state.blend_mode_rgb); + glGetIntegervDLL(GL_BLEND_EQUATION_ALPHA, (GLint*)&gl_state.blend_mode_alpha); + + glGetIntegervDLL(GL_READ_FRAMEBUFFER_BINDING, (GLint*)&gl_state.read_framebuffer_binding); + glGetIntegervDLL(GL_DRAW_FRAMEBUFFER_BINDING, (GLint*)&gl_state.draw_framebuffer_binding); + glGetIntegervDLL(GL_VERTEX_ARRAY_BINDING, (GLint*)&gl_state.vertex_array_binding); + glGetIntegervDLL(GL_ARRAY_BUFFER_BINDING, (GLint*)&gl_state.array_buffer_binding); + glGetIntegervDLL(GL_ELEMENT_ARRAY_BUFFER_BINDING, (GLint*)&gl_state.element_array_buffer_binding); + + glGetIntegervDLL(GL_UNIFORM_BUFFER_BINDING, (GLint*)&gl_state.uniform_buffer_binding); + for (GLuint i = 0; i < 14; i++) { + glGetIntegeri_v(GL_UNIFORM_BUFFER_BINDING, i, (GLint*)&gl_state.uniform_buffer_bindings[i]); + glGetIntegeri_v(GL_UNIFORM_BUFFER_START, i, (GLint*)&gl_state.uniform_buffer_offsets[i]); + glGetIntegeri_v(GL_UNIFORM_BUFFER_SIZE, i, (GLint*)&gl_state.uniform_buffer_sizes[i]); + } + + glGetIntegervDLL(GL_SHADER_STORAGE_BUFFER_BINDING, (GLint*)&gl_state.shader_storage_buffer_binding); + for (GLuint i = 0; i < 14; i++) { + glGetIntegeri_v(GL_SHADER_STORAGE_BUFFER_BINDING, i, (GLint*)&gl_state.shader_storage_buffer_bindings[i]); + glGetIntegeri_v(GL_SHADER_STORAGE_BUFFER_START, i, (GLint*)&gl_state.shader_storage_buffer_offsets[i]); + glGetIntegeri_v(GL_SHADER_STORAGE_BUFFER_SIZE, i, (GLint*)&gl_state.shader_storage_buffer_sizes[i]); + } + + glGetBooleanvDLL(GL_COLOR_WRITEMASK, gl_state.color_mask); + glGetBooleanvDLL(GL_CULL_FACE, &gl_state.cull_face); + glGetIntegervDLL(GL_CULL_FACE_MODE, (GLint*)&gl_state.cull_face_mode); + glGetBooleanvDLL(GL_DEPTH_TEST, &gl_state.depth_test); + glGetIntegervDLL(GL_DEPTH_FUNC, (GLint*)&gl_state.depth_func); + glGetBooleanvDLL(GL_DEPTH_WRITEMASK, &gl_state.depth_mask); + glGetBooleanvDLL(GL_MULTISAMPLE, &gl_state.multisample); + glGetBooleanvDLL(GL_PRIMITIVE_RESTART, &gl_state.primitive_restart); + glGetIntegervDLL(GL_PRIMITIVE_RESTART_INDEX, (GLint*)&gl_state.primitive_restart_index); + glGetBooleanvDLL(GL_SCISSOR_TEST, &gl_state.scissor_test); + glGetBooleanvDLL(GL_STENCIL_TEST, &gl_state.stencil_test); + glGetIntegervDLL(GL_STENCIL_WRITEMASK, (GLint*)&gl_state.stencil_mask); + + glPolygonModeDLL(GL_FRONT_AND_BACK, GL_FILL); + gl_state.polygon_front_face_mode = GL_FILL; + gl_state.polygon_back_face_mode = GL_FILL; +} + +void gl_state_get_all_gl_errors() { + GLenum error; + while (error = glGetErrorDLL()) + printf_debug("GL Error: 0x%04X\n", error); +} + +GLenum gl_state_get_error() { + GLenum error = glGetErrorDLL(); + if (error) + printf_debug("GL Error: 0x%04X\n", error); + return error; +} + +GLuint gl_state_get_program() { + return gl_state.program; +} + +void gl_state_set_blend_func(GLenum src, GLenum dst, bool force) { + if (force || gl_state.blend_src_rgb != src || gl_state.blend_dst_rgb != dst + || gl_state.blend_src_alpha != GL_ONE || gl_state.blend_dst_alpha != GL_ONE_MINUS_SRC_ALPHA) { + glBlendFuncSeparate(src, dst, GL_ONE, GL_ONE_MINUS_SRC_ALPHA); + gl_state.blend_src_rgb = src; + gl_state.blend_dst_rgb = dst; + gl_state.blend_src_alpha = GL_ONE; + gl_state.blend_dst_alpha = GL_ONE_MINUS_SRC_ALPHA; + } +} + +void gl_state_set_blend_func_separate(GLenum src_rgb, GLenum dst_rgb, + GLenum src_alpha, GLenum dst_alpha, bool force) { + if (force || gl_state.blend_src_rgb != src_rgb || gl_state.blend_dst_rgb != dst_rgb + || gl_state.blend_src_alpha != src_alpha || gl_state.blend_dst_alpha != dst_alpha) { + glBlendFuncSeparate(src_rgb, dst_rgb, src_alpha, dst_alpha); + gl_state.blend_src_rgb = src_rgb; + gl_state.blend_dst_rgb = dst_rgb; + gl_state.blend_src_alpha = src_alpha; + gl_state.blend_dst_alpha = dst_alpha; + } +} + +void gl_state_set_blend_equation(GLenum mode, bool force) { + if (force || gl_state.blend_mode_rgb != mode || gl_state.blend_mode_alpha != mode) { + glBlendEquationSeparate(mode, mode); + gl_state.blend_mode_rgb = mode; + gl_state.blend_mode_alpha = mode; + } +} + +void gl_state_set_blend_equation_separate(GLenum mode_rgb, GLenum mode_alpha, bool force) { + if (force || gl_state.blend_mode_rgb != mode_rgb || gl_state.blend_mode_alpha != mode_alpha) { + glBlendEquationSeparate(mode_rgb, mode_alpha); + gl_state.blend_mode_rgb = mode_rgb; + gl_state.blend_mode_alpha = mode_alpha; + } +} + +void gl_state_set_color_mask(GLboolean red, GLboolean green, + GLboolean blue, GLboolean alpha, bool force) { + if (force || gl_state.color_mask[0] != red || gl_state.color_mask[1] != green + || gl_state.color_mask[2] != blue || gl_state.color_mask[3] != alpha) { + glColorMaskDLL(red, green, blue, alpha); + gl_state.color_mask[0] = red; + gl_state.color_mask[1] = green; + gl_state.color_mask[2] = blue; + gl_state.color_mask[3] = alpha; + } +} + +void gl_state_set_cull_face_mode(GLenum mode, bool force) { + if (force || gl_state.cull_face_mode != mode) { + glCullFaceDLL(mode); + gl_state.cull_face_mode = mode; + } +} + +void gl_state_set_depth_func(GLenum func, bool force) { + if (force || gl_state.depth_func != func) { + glDepthFuncDLL(func); + gl_state.depth_func = func; + } +} + +void gl_state_set_depth_mask(GLboolean flag, bool force) { + if (force || gl_state.depth_mask != flag) { + glDepthMaskDLL(flag); + gl_state.depth_mask = flag; + } +} + +void gl_state_set_polygon_mode(GLenum face, GLenum mode, bool force) { + switch (face) { + case GL_FRONT: + if (force || gl_state.polygon_front_face_mode != mode) { + glPolygonModeDLL(GL_FRONT, mode); + gl_state.polygon_front_face_mode = mode; + } + break; + case GL_BACK: + if (force || gl_state.polygon_back_face_mode != mode) { + glPolygonModeDLL(GL_BACK, mode); + gl_state.polygon_back_face_mode = mode; + } + break; + case GL_FRONT_AND_BACK: + if (force || gl_state.polygon_front_face_mode != mode + && gl_state.polygon_back_face_mode != mode) { + glPolygonModeDLL(GL_FRONT_AND_BACK, mode); + gl_state.polygon_front_face_mode = mode; + gl_state.polygon_back_face_mode = mode; + } + else if (gl_state.polygon_front_face_mode != mode) { + glPolygonModeDLL(GL_FRONT, mode); + gl_state.polygon_front_face_mode = mode; + } + else if (gl_state.polygon_back_face_mode != mode) { + glPolygonModeDLL(GL_BACK, mode); + gl_state.polygon_back_face_mode = mode; + } + break; + } +} + +void gl_state_set_primitive_restart_index(GLuint index, bool force) { + if (force || gl_state.primitive_restart_index != index) { + glPrimitiveRestartIndex(index); + gl_state.primitive_restart_index = index; + } +} + +void gl_state_set_stencil_mask(GLuint mask, bool force) { + if (force || gl_state.stencil_mask != mask) { + glStencilMask(mask); + gl_state.stencil_mask = mask; + } +} + +void gl_state_use_program(GLuint program, bool force) { + if (force || gl_state.program != program) { + glUseProgram(program); + gl_state.program = program; + } +} diff --git a/src/DivaGL/gl_state.hpp b/src/DivaGL/gl_state.hpp new file mode 100644 index 0000000..94cf942 --- /dev/null +++ b/src/DivaGL/gl_state.hpp @@ -0,0 +1,127 @@ +/* + by korenkonder + GitHub/GitLab: korenkonder +*/ + +#pragma once + +#include "../KKdLib/default.hpp" +#include "wrap.hpp" + +struct gl_state_struct { + GLint program; + GLenum active_texture; + GLuint active_texture_index; + GLint texture_binding_2d[32]; + GLint texture_binding_cube_map[32]; + GLint sampler_binding[32]; + GLboolean blend; + GLenum blend_src_rgb; + GLenum blend_src_alpha; + GLenum blend_dst_rgb; + GLenum blend_dst_alpha; + GLenum blend_mode_rgb; + GLenum blend_mode_alpha; + GLuint read_framebuffer_binding; + GLuint draw_framebuffer_binding; + GLuint vertex_array_binding; + GLuint array_buffer_binding; + GLuint element_array_buffer_binding; + GLuint uniform_buffer_binding; + GLuint uniform_buffer_bindings[14]; + GLintptr uniform_buffer_offsets[14]; + GLsizeiptr uniform_buffer_sizes[14]; + GLuint shader_storage_buffer_binding; + GLuint shader_storage_buffer_bindings[14]; + GLintptr shader_storage_buffer_offsets[14]; + GLsizeiptr shader_storage_buffer_sizes[14]; + GLboolean color_mask[4]; + GLboolean cull_face; + GLenum cull_face_mode; + GLboolean depth_test; + GLenum depth_func; + GLboolean depth_mask; + GLenum polygon_front_face_mode; + GLenum polygon_back_face_mode; + GLboolean multisample; + GLboolean primitive_restart; + GLuint primitive_restart_index; + GLboolean scissor_test; + GLboolean stencil_test; + GLuint stencil_mask; +}; + +extern gl_state_struct gl_state; + +extern void gl_state_active_bind_texture_2d(int32_t index, GLuint texture, bool force = false); +extern void gl_state_active_bind_texture_cube_map(int32_t index, GLuint texture, bool force = false); +extern void gl_state_active_texture(size_t index, bool force = false); +extern void gl_state_bind_framebuffer(GLuint framebuffer, bool force = false); +extern void gl_state_bind_read_framebuffer(GLuint framebuffer, bool force = false); +extern void gl_state_bind_draw_framebuffer(GLuint framebuffer, bool force = false); +extern void gl_state_bind_vertex_array(GLuint array, bool force = false); +extern void gl_state_bind_array_buffer(GLuint buffer, bool force = false); +extern void gl_state_bind_element_array_buffer(GLuint buffer, bool force = false); +extern void gl_state_bind_uniform_buffer(GLuint buffer, bool force = false); +extern void gl_state_bind_uniform_buffer_base(GLuint index, GLuint buffer, bool force = false); +extern void gl_state_bind_uniform_buffer_range(GLuint index, + GLuint buffer, GLintptr offset, GLsizeiptr size, bool force = false); +extern void gl_state_bind_shader_storage_buffer(GLuint buffer, bool force = false); +extern void gl_state_bind_shader_storage_buffer_base(GLuint index, GLuint buffer, bool force = false); +extern void gl_state_bind_shader_storage_buffer_range(GLuint index, + GLuint buffer, GLintptr offset, GLsizeiptr size, bool force = false); +extern void gl_state_bind_texture_2d(GLuint texture, bool force = false); +extern void gl_state_bind_texture_cube_map(GLuint texture, bool force = false); +extern void gl_state_bind_sampler(int32_t index, GLuint sampler, bool force = false); +extern bool gl_state_check_uniform_buffer_binding(); +extern bool gl_state_check_uniform_buffer_binding_base(size_t index); +extern bool gl_state_check_shader_storage_buffer_binding(); +extern bool gl_state_check_shader_storage_buffer_binding_base(size_t index); +extern bool gl_state_check_texture_binding_2d(size_t index); +extern bool gl_state_check_texture_binding_cube_map(size_t index); +extern bool gl_state_check_sampler_binding(int32_t index, GLuint sampler); +extern void gl_state_disable_blend(bool force = false); +extern void gl_state_disable_cull_face(bool force = false); +extern void gl_state_disable_depth_test(bool force = false); +extern void gl_state_disable_multisample(bool force = false); +extern void gl_state_disable_primitive_restart(bool force = false); +extern void gl_state_disable_scissor_test(bool force = false); +extern void gl_state_disable_stencil_test(bool force = false); +extern void gl_state_enable_blend(bool force = false); +extern void gl_state_enable_cull_face(bool force = false); +extern void gl_state_enable_depth_test(bool force = false); +extern void gl_state_enable_multisample(bool force = false); +extern void gl_state_enable_primitive_restart(bool force = false); +extern void gl_state_enable_scissor_test(bool force = false); +extern void gl_state_enable_stencil_test(bool force = false); +extern void gl_state_get(); +extern void gl_state_get_all_gl_errors(); +extern GLenum gl_state_get_error(); +extern GLuint gl_state_get_program(); +extern void gl_state_set_blend_func(GLenum src, GLenum dst, bool force = false); +extern void gl_state_set_blend_func_separate(GLenum src_rgb, GLenum dst_rgb, + GLenum src_alpha, GLenum dst_alpha, bool force = false); +extern void gl_state_set_blend_equation(GLenum mode, bool force = false); +extern void gl_state_set_blend_equation_separate( + GLenum mode_rgb, GLenum mode_alpha, bool force = false); +extern void gl_state_set_color_mask(GLboolean red, GLboolean green, + GLboolean blue, GLboolean alpha, bool force = false); +extern void gl_state_set_cull_face_mode(GLenum mode, bool force = false); +extern void gl_state_set_depth_func(GLenum func, bool force = false); +extern void gl_state_set_depth_mask(GLboolean flag, bool force = false); +extern void gl_state_set_polygon_mode(GLenum face, GLenum mode, bool force = false); +extern void gl_state_set_primitive_restart_index(GLuint index, bool force = false); +extern void gl_state_set_stencil_mask(GLuint mask, bool force = false); +extern void gl_state_use_program(GLuint program, bool force = false); + +inline constexpr void gl_state_begin_event(const char* str) { +#ifdef DEBUG + glPushDebugGroup(GL_DEBUG_SOURCE_APPLICATION, 0, (GLsizei)utf8_length(str), str); +#endif +} + +inline constexpr void gl_state_end_event() { +#ifdef DEBUG + glPopDebugGroup(); +#endif +} diff --git a/src/DivaGL/gl_uniform_buffer.hpp b/src/DivaGL/gl_uniform_buffer.hpp new file mode 100644 index 0000000..18fa1aa --- /dev/null +++ b/src/DivaGL/gl_uniform_buffer.hpp @@ -0,0 +1,144 @@ +/* + by korenkonder + GitHub/GitLab: korenkonder +*/ + +#pragma once + +#include "wrap.hpp" +#include "gl_state.hpp" + +struct GLUniformBuffer { +private: + GLuint buffer; + +public: + inline GLUniformBuffer() : buffer() { + + } + + inline ~GLUniformBuffer() { + + } + + inline void Bind(int32_t index, bool force = false) { + gl_state_bind_uniform_buffer_base(index, buffer, force); + } + + inline void Create(size_t size) { + if (buffer) + return; + + if (GL_VERSION_4_5) { + glCreateBuffers(1, &buffer); + glNamedBufferStorage(buffer, (GLsizeiptr)size, 0, GL_DYNAMIC_STORAGE_BIT | GL_MAP_WRITE_BIT); + } + else { + glGenBuffers(1, &buffer); + gl_state_bind_uniform_buffer(buffer); + if (GL_VERSION_4_4) + glBufferStorage(GL_UNIFORM_BUFFER, (GLsizeiptr)size, + 0, GL_DYNAMIC_STORAGE_BIT | GL_MAP_WRITE_BIT); + else + glBufferData(GL_UNIFORM_BUFFER, (GLsizeiptr)size, 0, GL_DYNAMIC_DRAW); + } + + } + + inline void Create(size_t size, const void* data, bool dynamic = false) { + if (buffer) + return; + + if (GL_VERSION_4_5) { + glCreateBuffers(1, &buffer); + glNamedBufferStorage(buffer, (GLsizeiptr)size, data, + dynamic ? GL_DYNAMIC_STORAGE_BIT | GL_MAP_WRITE_BIT : 0); + } + else { + glGenBuffers(1, &buffer); + gl_state_bind_uniform_buffer(buffer); + if (GL_VERSION_4_4) + glBufferStorage(GL_UNIFORM_BUFFER, (GLsizeiptr)size, data, + dynamic ? GL_DYNAMIC_STORAGE_BIT | GL_MAP_WRITE_BIT : 0); + else + glBufferData(GL_UNIFORM_BUFFER, (GLsizeiptr)size, data, + dynamic ? GL_DYNAMIC_DRAW : GL_STATIC_DRAW); + } + } + + inline void Destroy() { + if (buffer) { + glDeleteBuffers(1, &buffer); + buffer = 0; + } + } + + inline bool IsNull() { + return !buffer; + } + + inline void* MapMemory() { + if (!buffer) + return 0; + + void* data; + if (GL_VERSION_4_5) + data = glMapNamedBuffer(buffer, GL_WRITE_ONLY); + else { + gl_state_bind_uniform_buffer(buffer); + data = glMapBuffer(GL_UNIFORM_BUFFER, GL_WRITE_ONLY); + } + + if (data) + return data; + + if (GL_VERSION_4_5) + glUnmapNamedBuffer(buffer); + else { + glUnmapBuffer(GL_UNIFORM_BUFFER); + gl_state_bind_uniform_buffer(0); + } + return 0; + } + + inline bool NotNull() { + return !!buffer; + } + + inline void UnmapMemory() { + if (!buffer) + return; + + if (GL_VERSION_4_5) + glUnmapNamedBuffer(buffer); + else { + glUnmapBuffer(GL_UNIFORM_BUFFER); + gl_state_bind_uniform_buffer(0); + } + } + + inline void WriteMemory(size_t offset, size_t size, const void* data) { + if (!buffer) + return; + + if (GL_VERSION_4_5) + glNamedBufferSubData(buffer, (GLsizeiptr)offset, (GLsizeiptr)size, data); + else { + gl_state_bind_uniform_buffer(buffer); + glBufferSubData(GL_UNIFORM_BUFFER, (GLsizeiptr)offset, (GLsizeiptr)size, data); + } + } + + template + inline void WriteMemory(T& data) { + if (!buffer) + return; + + if (GL_VERSION_4_5) + glNamedBufferSubData(buffer, 0, sizeof(T), &data); + else { + gl_state_bind_uniform_buffer(buffer); + glBufferSubData(GL_UNIFORM_BUFFER, 0, sizeof(T), &data); + } + } +}; diff --git a/src/DivaGL/hook.cpp b/src/DivaGL/hook.cpp new file mode 100644 index 0000000..8356551 --- /dev/null +++ b/src/DivaGL/hook.cpp @@ -0,0 +1,117 @@ +/* + by korenkonder + GitHub/GitLab: korenkonder +*/ + +#include "hook.hpp" +#include "Glitter/glitter.hpp" +#include "mdl/disp_manager.hpp" +#include "rob/rob.hpp" +#include "auth_3d.hpp" +#include "camera.hpp" +#include "shader_glsl_ft.hpp" +#include "sprite.hpp" +#include "stage.hpp" +#include "texture.hpp" +#include + +HOOK(int32_t, FASTCALL, data_init, 0x0000000140192FF0) { + extern void FASTCALL wrap_addresses(); + wrap_addresses(); + + auth_3d_patch(); + camera_patch(); + mdl::disp_manager_patch(); + render_manager_patch(); + rob_patch(); + sprite_patch(); + stage_patch(); + Glitter::Patch(); + + rctx = new render_context; + int32_t ret = originaldata_init(); + + extern size_t diva_handle; + diva_handle = (size_t)WindowFromDC(wglGetCurrentDC()); + + rctx->init(); + sprite_manager_init(); + return ret; +} + +HOOK(int32_t, FASTCALL, data_free, 0x000000140192490) { + sprite_manager_free(); + rctx->free(); + + int32_t ret = originaldata_free(); + delete rctx; + return ret; +} + +HOOK(void, FASTCALL, sub_140194CD0, 0x000000140194CD0) { + rctx->ctrl(); + originalsub_140194CD0(); +} + +HOOK(void, FASTCALL, _gl_state_get, 0x0000000140442DF0) { + gl_state_get(); +} + +HOOK(void, FASTCALL, rndr__Render__update_res, 0x00000001404A9480, rndr::Render* rend, bool set, int32_t base_downsample) { + rend->update_res(set, base_downsample); +} + +HOOK(void, FASTCALL, rndr__Render__init_tone_map_buffers, 0x00000001404A9FF0, rndr::Render* rend) { + rend->init_tone_map_buffers(); +} + +HOOK(void, FASTCALL, rndr__Render__init_render_buffers, 0x00000001404AB0C0, rndr::Render* rend, + int32_t width, int32_t height, int32_t ssaa, int32_t hd_res, int32_t ss_alpha_mask) { + rend->init_render_buffers(width, height, ssaa, hd_res, ss_alpha_mask); +} + +HOOK(void, FASTCALL, rndr__Render__free, 0x00000001404AB900, rndr::Render* rend) { + rend->free(); +} + +HOOK(void, FASTCALL, rndr__RenderManager__render_ctrl, 0x0000000140502C90) { + render_manager->render->ctrl(); +} + +HOOK(void, FASTCALL, rndr__RenderManager__render_all, 0x0000000140502CA0) { + render_manager->render_all(); +} + +HOOK(int32_t, FASTCALL, shader_get_index_by_name, 0x00000001405E4ED0, const char* name) { + return shaders_ft.get_index_by_name(name); +} + +HOOK(void, FASTCALL, env_set_blend_color, 0x00000001405E5600, float_t r, float_t g, float_t b, float_t a) { + rctx->obj_batch.g_blend_color = { r, g, b, a }; +} + +HOOK(void, FASTCALL, env_set_offset_color, 0x00000001405E5630, float_t r, float_t g, float_t b, float_t a) { + rctx->obj_batch.g_offset_color = { r, g, b, a }; +} + +void hook_funcs() { + INSTALL_HOOK(data_init); + INSTALL_HOOK(data_free); + + INSTALL_HOOK(sub_140194CD0); + + INSTALL_HOOK(_gl_state_get); + + INSTALL_HOOK(rndr__Render__update_res); + INSTALL_HOOK(rndr__Render__init_tone_map_buffers); + INSTALL_HOOK(rndr__Render__init_render_buffers); + INSTALL_HOOK(rndr__Render__free); + + INSTALL_HOOK(rndr__RenderManager__render_ctrl); + INSTALL_HOOK(rndr__RenderManager__render_all); + + INSTALL_HOOK(shader_get_index_by_name); + + INSTALL_HOOK(env_set_blend_color); + INSTALL_HOOK(env_set_offset_color); +} \ No newline at end of file diff --git a/src/DivaGL/hook.hpp b/src/DivaGL/hook.hpp new file mode 100644 index 0000000..a0e81fd --- /dev/null +++ b/src/DivaGL/hook.hpp @@ -0,0 +1,10 @@ +/* + by korenkonder + GitHub/GitLab: korenkonder +*/ + +#pragma once + +#include "gl_state.hpp" + +extern void hook_funcs(); diff --git a/src/DivaGL/inject.cpp b/src/DivaGL/inject.cpp new file mode 100644 index 0000000..fc73d07 --- /dev/null +++ b/src/DivaGL/inject.cpp @@ -0,0 +1,126 @@ +/* + by korenkonder + GitHub/GitLab: korenkonder +*/ + +#include "inject.hpp" +#include "gl.hpp" +#include "print.hpp" +#include "shader_table.hpp" +#include "shader_glsl_ft.hpp" +#include "sprite.hpp" +#include + +struct patch_struct { + void* address; + size_t func_ptr; +}; + +void inject_data(void* address, const void* data, size_t count) { + DWORD old_protect; + VirtualProtect(address, count, PAGE_EXECUTE_READWRITE, &old_protect); + memmove(address, (const void*)data, count); + VirtualProtect(address, count, old_protect, &old_protect); +} + +void inject_uint8_t(void* address, uint8_t data) { + DWORD old_protect; + VirtualProtect(address, sizeof(uint8_t), PAGE_EXECUTE_READWRITE, &old_protect); + *(uint8_t*)address = data; + VirtualProtect(address, sizeof(uint8_t), old_protect, &old_protect); +} + +void inject_uint16_t(void* address, uint16_t data) { + DWORD old_protect; + VirtualProtect(address, sizeof(uint16_t), PAGE_EXECUTE_READWRITE, &old_protect); + *(uint16_t*)address = data; + VirtualProtect(address, sizeof(uint16_t), old_protect, &old_protect); +} + +void inject_uint32_t(void* address, uint32_t data) { + DWORD old_protect; + VirtualProtect(address, sizeof(uint32_t), PAGE_EXECUTE_READWRITE, &old_protect); + *(uint32_t*)address = data; + VirtualProtect(address, sizeof(uint32_t), old_protect, &old_protect); +} + +void inject_uint64_t(void* address, uint64_t data) { + DWORD old_protect; + VirtualProtect(address, sizeof(uint64_t), PAGE_EXECUTE_READWRITE, &old_protect); + *(uint64_t*)address = data; + VirtualProtect(address, sizeof(uint64_t), old_protect, &old_protect); +} + +extern size_t glut_handle; + +static patch_struct patch_data[] = { + { (void*)0x00000001405E4CE0, (uint64_t)&shader_set, }, + { (void*)0x00000001405E4FC0, (uint64_t)&shader_load_all_shaders, }, + { (void*)0x00000001405E4DB0, (uint64_t)&shader_free, }, + { (void*)0x00000001405E4B50, (uint64_t)&shader_bind, }, + { (void*)0x00000001401D3860, (uint64_t)&printf_proxy, }, + { (void*)0x00000001400DE640, (uint64_t)&printf_proxy, }, + { (void*)0x0000000140442FB4, (uint64_t)&gl_state_get, }, +}; + +static HGLRC FASTCALL glut_create_context(int64_t a1, int64_t a2, int64_t a3, int64_t a4, int32_t a5); + +void inject_patches() { + // Reorder gl_state_get end + inject_data((void*)0x0000000140442F99, + "\xFF\x15\x51\x2B\x52\x00\x48\x8B\x5C\x24\x30\x48\x8B\x74\x24\x38" + "\x48\x8B\x7C\x24\x40\x48\x83\xC4\x20\x41\x5E\xC3", 28); + + uint8_t buf[0x0C]; + buf[0x00] = 0x48; + buf[0x01] = 0xB8; + buf[0x0A] = 0xFF; + buf[0x0B] = 0xE0; + + for (int32_t i = 0; i < sizeof(patch_data) / sizeof(patch_struct); i++) + if (patch_data[i].func_ptr) { + *(uint64_t*)&buf[0x02] = patch_data[i].func_ptr; + inject_data(patch_data[i].address, buf, 0x0C); + } + ; + + *(uint64_t*)&buf[0x02] = (uint64_t)&glut_create_context; + inject_data((void*)(glut_handle + 0x0000A970), buf, 0x0C); + + inject_uint64_t((void*)&shader_name_bind_func_table[0].bind_func, (uint64_t)&shader_bind_blinn); + inject_uint64_t((void*)&shader_name_bind_func_table[1].bind_func, (uint64_t)&shader_bind_cloth); + inject_uint64_t((void*)&shader_name_bind_func_table[2].bind_func, (uint64_t)&shader_bind_hair); + inject_uint64_t((void*)&shader_name_bind_func_table[3].bind_func, (uint64_t)&shader_bind_membrane); + inject_uint64_t((void*)&shader_name_bind_func_table[4].bind_func, (uint64_t)&shader_bind_eye_ball); + inject_uint64_t((void*)&shader_name_bind_func_table[5].bind_func, (uint64_t)&shader_bind_tone_map); + + // Patch font shader index + inject_uint32_t((void*)0x00000001401982D8, SHADER_FT_FONT); +} + +static HGLRC FASTCALL glut_create_context(int64_t a1, int64_t a2, int64_t a3, int64_t a4, int32_t a5) { + HDC& hDc = *(HDC*)(glut_handle + 0x55F20); + + if (true/*a5*/) { + const int32_t attrib_list[] = { + WGL_CONTEXT_MAJOR_VERSION_ARB, 4, + WGL_CONTEXT_MINOR_VERSION_ARB, 3, + WGL_CONTEXT_PROFILE_MASK_ARB, WGL_CONTEXT_CORE_PROFILE_BIT_ARB, + WGL_CONTEXT_FLAGS_ARB, WGL_CONTEXT_DEBUG_BIT_ARB, + 0, + }; + + typedef HGLRC(GLAPIENTRY* PFNWGLCREATECONTEXTGLUTPROC)(HDC hDc); + + HGLRC tmp_ctx = wglCreateContextGLUT(hDc);; + wglMakeCurrentGLUT(hDc, tmp_ctx); + PFNWGLCREATECONTEXTATTRIBSARBPROC _wglCreateContextAttribsARB + = (PFNWGLCREATECONTEXTATTRIBSARBPROC)wglGetProcAddressGLUT("wglCreateContextAttribsARB"); + HGLRC ctx = _wglCreateContextAttribsARB(hDc, 0, attrib_list); + wglMakeCurrentGLUT(hDc, ctx); + wglDeleteContextGLUT(tmp_ctx); + return ctx; + } + else + return wglCreateContextGLUT(hDc); +} diff --git a/src/DivaGL/inject.hpp b/src/DivaGL/inject.hpp new file mode 100644 index 0000000..fc0d0cb --- /dev/null +++ b/src/DivaGL/inject.hpp @@ -0,0 +1,15 @@ +/* + by korenkonder + GitHub/GitLab: korenkonder +*/ + +#pragma once + +#include "../KKdLib/default.hpp" + +extern void inject_data(void* address, const void* data, size_t count); +extern void inject_uint8_t(void* address, uint8_t data); +extern void inject_uint16_t(void* address, uint16_t data); +extern void inject_uint32_t(void* address, uint32_t data); +extern void inject_uint64_t(void* address, uint64_t data); +extern void inject_patches(); diff --git a/src/DivaGL/light_param/fog.cpp b/src/DivaGL/light_param/fog.cpp new file mode 100644 index 0000000..9fe3b8d --- /dev/null +++ b/src/DivaGL/light_param/fog.cpp @@ -0,0 +1,95 @@ +/* + by korenkonder + GitHub/GitLab: korenkonder +*/ + +#include "fog.hpp" +#include "../render_context.hpp" + +fog* fog_data = (fog*)0x00000001411974D0; + +fog_type fog::get_type() const { + return type; +} + +void fog::set_type(fog_type value) { + type = value; +} + +float_t fog::get_density() const { + return density; +} + +void fog::set_density(float_t value) { + density = value; +} + +float_t fog::get_start() const { + return start; +} + +void fog::set_start(float_t value) { + start = value; +} + +float_t fog::get_end() const { + return end; +} + +void fog::set_end(float_t value) { + end = value; +} + +int32_t fog::get_index() const { + return index; +} + +void fog::set_index(int32_t value) { + index = value; +} + +void fog::get_color(vec4& value) const { + value = color; +} + +void fog::set_color(const vec4& value) { + color = value; +} + +void fog::set_color(const vec4&& value) { + color = value; +} + +void fog::data_set(fog_id id) { + fog_type type = get_type(); + if (type == FOG_NONE) + return; + + float_t density = get_density(); + float_t start = get_start(); + float_t end = get_end(); + if (start >= end) + start = end - 0.01f; + + vec4 params; + params.x = density; + params.y = start; + params.z = end; + params.w = 1.0f / (end - start); + + extern render_context* rctx; + + switch (id) { + case FOG_DEPTH: + get_color(rctx->obj_scene.g_fog_depth_color); + rctx->obj_scene.g_fog_state_params = params; + break; + case FOG_HEIGHT: + get_color(rctx->obj_scene.g_fog_height_color); + rctx->obj_scene.g_fog_height_params = params; + break; + case FOG_BUMP: + rctx->obj_scene.g_fog_bump_params = params; + break; + } +} diff --git a/src/DivaGL/light_param/fog.hpp b/src/DivaGL/light_param/fog.hpp new file mode 100644 index 0000000..f40d80a --- /dev/null +++ b/src/DivaGL/light_param/fog.hpp @@ -0,0 +1,38 @@ +/* + by korenkonder + GitHub/GitLab: korenkonder +*/ + +#pragma once + +#include "../../KKdLib/default.hpp" +#include "../../KKdLib/light_param/fog.hpp" +#include "../../KKdLib/vec.hpp" + +struct fog { + fog_type type; + float_t density; + float_t start; + float_t end; + int32_t index; + vec4 color; + + fog_type get_type() const; + void set_type(fog_type value); + float_t get_density() const; + void set_density(float_t value); + float_t get_start() const; + void set_start(float_t value); + float_t get_end() const; + void set_end(float_t value); + int32_t get_index() const; + void set_index(int32_t value); + void get_color(vec4& value) const; + void set_color(const vec4& value); + void set_color(const vec4&& value); + void data_set(fog_id id); +}; + +static_assert(sizeof(fog) == 0x24, "\"fog\" struct should have a size of 0x24"); + +extern fog* fog_data; diff --git a/src/DivaGL/light_param/light.cpp b/src/DivaGL/light_param/light.cpp new file mode 100644 index 0000000..1160384 --- /dev/null +++ b/src/DivaGL/light_param/light.cpp @@ -0,0 +1,497 @@ +/* + by korenkonder + GitHub/GitLab: korenkonder +*/ + +#include "light.hpp" +#include "../../KKdLib/mat.hpp" +#include "../render_context.hpp" +#include "../uniform.hpp" + +light_set* light_set_data = (light_set*)0x00000001411A00A0; + +static vec4* npr_cloth_spec_color = (vec4*)0x0000000140C9B2A0; + +static void light_get_direction_from_position(vec4* pos_dir, light_data* light, bool force = false); + +light_type light_data::get_type() const { + return type; +} + +void light_data::set_type(light_type value) { + type = value; + if (value < LIGHT_POINT) + position.w = 0.0f; + else + position.w = 1.0f; +} + +void light_data::get_ambient(vec4& value) const { + value = ambient; +} + +void light_data::set_ambient(const vec4& value) { + ambient = value; +} + +void light_data::set_ambient(const vec4&& value) { + ambient = value; +} + +void light_data::set_ambient(const vec4& value, bool set[4]) { + if (set[0]) + ambient.x = value.x; + if (set[1]) + ambient.y = value.y; + if (set[2]) + ambient.z = value.z; + if (set[3]) + ambient.w = value.w; +} + +void light_data::set_ambient(const vec4&& value, bool set[4]) { + if (set[0]) + ambient.x = value.x; + if (set[1]) + ambient.y = value.y; + if (set[2]) + ambient.z = value.z; + if (set[3]) + ambient.w = value.w; +} + +void light_data::get_diffuse(vec4& value) const { + value = diffuse; +} + +void light_data::set_diffuse(const vec4& value) { + diffuse = value; +} + +void light_data::set_diffuse(const vec4&& value) { + diffuse = value; +} + +void light_data::set_diffuse(const vec4& value, bool set[4]) { + if (set[0]) + diffuse.x = value.x; + if (set[1]) + diffuse.y = value.y; + if (set[2]) + diffuse.z = value.z; + if (set[3]) + diffuse.w = value.w; +} + +void light_data::set_diffuse(const vec4&& value, bool set[4]) { + if (set[0]) + diffuse.x = value.x; + if (set[1]) + diffuse.y = value.y; + if (set[2]) + diffuse.z = value.z; + if (set[3]) + diffuse.w = value.w; +} + +void light_data::get_specular(vec4& value) const { + value = specular; +} + +void light_data::set_specular(const vec4& value) { + specular = value; +} + +void light_data::set_specular(const vec4&& value) { + specular = value; +} + +void light_data::set_specular(const vec4& value, bool set[4]) { + if (set[0]) + specular.x = value.x; + if (set[1]) + specular.y = value.y; + if (set[2]) + specular.z = value.z; + if (set[3]) + specular.w = value.w; +} + +void light_data::set_specular(const vec4&& value, bool set[4]) { + if (set[0]) + specular.x = value.x; + if (set[1]) + specular.y = value.y; + if (set[2]) + specular.z = value.z; + if (set[3]) + specular.w = value.w; +} + +void light_data::get_position(vec3& value) const { + value = *(vec3*)&position; +} + +void light_data::set_position(const vec3& value) { + *(vec3*)&position = value; +} + +void light_data::set_position(const vec3&& value) { + *(vec3*)&position = value; +} + +void light_data::get_position(vec4& value) const { + value = position; +} + +void light_data::set_position(const vec4& value) { + position = value; +} + +void light_data::set_position(const vec4&& value) { + position = value; +} + +void light_data::get_spot_direction(vec3& value) const { + value = spot_direction; +} + +void light_data::set_spot_direction(const vec3& value) { + spot_direction = value; +} + +void light_data::set_spot_direction(const vec3&& value) { + spot_direction = value; +} + +float_t light_data::get_spot_exponent() const { + return spot_exponent; +} + +void light_data::set_spot_exponent(float_t value) { + spot_exponent = value; +} + +float_t light_data::get_spot_cutoff() const { + return spot_cutoff; +} + +void light_data::set_spot_cutoff(float_t value) { + spot_cutoff = value; +} + +float_t light_data::get_constant() const { + return attenuation.constant; +} + +void light_data::set_constant(float_t value) { + attenuation.constant = value; +} + +float_t light_data::get_linear() const { + return attenuation.linear; +} + +void light_data::set_linear(float_t value) { + attenuation.linear = value; +} + +float_t light_data::get_quadratic() const { + return attenuation.quadratic; +} + +void light_data::set_quadratic(float_t value) { + attenuation.quadratic = value; +} + +void light_data::get_attenuation(light_attenuation& value) const { + value = attenuation; +} + +void light_data::set_attenuation(const light_attenuation& value) { + attenuation = value; +} + +void light_data::set_attenuation(const light_attenuation&& value) { + attenuation = value; +} + +void light_data::get_ibl_color0(vec4& value) const { + value = ibl_color0; +} + +void light_data::set_ibl_color0(const vec4& value) { + ibl_color0 = value; +} + +void light_data::set_ibl_color0(const vec4&& value) { + ibl_color0 = value; +} + +void light_data::get_ibl_color1(vec4& value) const { + value = ibl_color1; +} + +void light_data::set_ibl_color1(const vec4& value) { + ibl_color1 = value; +} + +void light_data::set_ibl_color1(const vec4&& value) { + ibl_color1 = value; +} + +void light_data::get_ibl_direction(vec4& value) const { + value = ibl_direction; +} + +void light_data::set_ibl_direction(const vec4& value) { + ibl_direction = value; +} + +void light_data::set_ibl_direction(const vec4&& value) { + ibl_direction = value; +} + +void light_data::get_tone_curve(light_tone_curve& value) const { + value = tone_curve; +} + +void light_data::set_tone_curve(const light_tone_curve& value) { + tone_curve = value; +} + +void light_data::set_tone_curve(const light_tone_curve&& value) { + tone_curve = value; +} + +void light_data::get_clip_plane(light_clip_plane& value) const { + value = clip_plane; +} + +void light_data::set_clip_plane(const light_clip_plane& value) { + clip_plane = value; +} + +void light_data::set_clip_plane(const light_clip_plane&& value) { + clip_plane = value; +} + +void light_set::get_ambient_intensity(vec4& value) { + value = ambient_intensity; +} + +void light_set::set_ambient_intensity(const vec4& value) { + ambient_intensity = value; +} + +void light_set::set_ambient_intensity(const vec4&& value) { + ambient_intensity = value; +} + +void light_set::get_irradiance(mat4& r, mat4& g, mat4& b) { + r = irradiance_r; + g = irradiance_g; + b = irradiance_b; +} + +void light_set::set_irradiance(const mat4& r, const mat4& g, const mat4& b) { + irradiance_r = r; + irradiance_g = g; + irradiance_b = b; +} + +void light_set::set_irradiance(const mat4&& r, const mat4&& g, const mat4&& b) { + irradiance_r = r; + irradiance_g = g; + irradiance_b = b; +} + +void light_set::data_set(light_set_id id) { + static const float_t spec_coef = (float_t)(1.0 / (1.0 - cos(18.0 * DEG_TO_RAD))); + static const float_t luce_coef = (float_t)(1.0 / (1.0 - cos(45.0 * DEG_TO_RAD))); + + extern render_context* rctx; + obj_scene_shader_data& obj_scene = rctx->obj_scene; + + lights[LIGHT_STAGE].get_diffuse(obj_scene.g_light_env_stage_diffuse); + lights[LIGHT_STAGE].get_specular(obj_scene.g_light_env_stage_specular); + + lights[LIGHT_CHARA].get_diffuse(obj_scene.g_light_env_chara_diffuse); + lights[LIGHT_CHARA].get_ambient(obj_scene.g_light_env_chara_ambient); + lights[LIGHT_CHARA].get_specular(obj_scene.g_light_env_chara_specular); + + lights[LIGHT_REFLECT].get_diffuse(obj_scene.g_light_env_reflect_diffuse); + lights[LIGHT_REFLECT].get_ambient(obj_scene.g_light_env_reflect_ambient); + + lights[LIGHT_PROJECTION].get_diffuse(obj_scene.g_light_env_proj_diffuse); + lights[LIGHT_PROJECTION].get_specular(obj_scene.g_light_env_proj_specular); + lights[LIGHT_PROJECTION].get_position(obj_scene.g_light_env_proj_position); + if (lights[LIGHT_PROJECTION].get_type() == LIGHT_PARALLEL) + light_get_direction_from_position(&obj_scene.g_light_env_proj_position, 0, true); + + vec4 light_chara_dir; + vec4 light_chara_ibl_color0; + vec4 light_chara_ibl_color1; + vec4 light_chara_specular; + lights[LIGHT_CHARA].get_position(light_chara_dir); + light_get_direction_from_position(&light_chara_dir, &lights[LIGHT_CHARA]); + lights[LIGHT_CHARA].get_ibl_color0(light_chara_ibl_color0); + lights[LIGHT_CHARA].get_ibl_color1(light_chara_ibl_color1); + lights[LIGHT_CHARA].get_specular(light_chara_specular); + + obj_scene.g_light_chara_dir = light_chara_dir; + obj_scene.g_light_chara_spec = light_chara_specular * light_chara_ibl_color0 * spec_coef; + obj_scene.g_light_chara_luce = light_chara_ibl_color0 * luce_coef; + obj_scene.g_light_chara_back = light_chara_specular * light_chara_ibl_color1 * spec_coef; + + vec4 light_stage_dir; + vec4 light_stage_ibl_color; + vec4 light_stage_diffuse; + vec4 light_stage_specular; + lights[LIGHT_STAGE].get_position(light_stage_dir); + light_get_direction_from_position(&light_stage_dir, &lights[LIGHT_STAGE]); + lights[LIGHT_STAGE].get_ibl_color0(light_stage_ibl_color); + lights[LIGHT_STAGE].get_diffuse(light_stage_diffuse); + lights[LIGHT_STAGE].get_specular(light_stage_specular); + + obj_scene.g_light_stage_dir = light_stage_dir; + obj_scene.g_light_stage_diff = light_stage_diffuse * light_stage_ibl_color; + obj_scene.g_light_stage_spec = light_stage_specular * light_stage_ibl_color * spec_coef; + + mat4 irradiance_r_transforms; + mat4 irradiance_g_transforms; + mat4 irradiance_b_transforms; + get_irradiance(irradiance_r_transforms, irradiance_g_transforms, irradiance_b_transforms); + obj_scene.set_g_irradiance_r_transforms(irradiance_r_transforms); + obj_scene.set_g_irradiance_g_transforms(irradiance_g_transforms); + obj_scene.set_g_irradiance_b_transforms(irradiance_b_transforms); + + + float_t* (FASTCALL * face_data_get)() = (float_t * (FASTCALL*)())0x00000001403D8310; + float_t offset = face_data_get()[0]; + float_t v28 = (float_t)(1.0 - exp(offset * -0.44999999)) * 2.0f; + offset = max_def(offset, 0.0f); + obj_scene.g_light_face_diff = { v28 * 0.1f, offset * 0.06f, 1.0f, 1.0f }; + + if (lights[LIGHT_CHARA_COLOR].get_type() == LIGHT_PARALLEL) { + lights[LIGHT_CHARA_COLOR].get_ambient(obj_scene.g_chara_color_rim); + lights[LIGHT_CHARA_COLOR].get_diffuse(obj_scene.g_chara_color0); + lights[LIGHT_CHARA_COLOR].get_specular(obj_scene.g_chara_color1); + if (obj_scene.g_chara_color1.w > 1.0f) + obj_scene.g_chara_color1.w = 1.0f; + } + else { + obj_scene.g_chara_color_rim = 0.0f; + obj_scene.g_chara_color0 = 0.0f; + obj_scene.g_chara_color1 = 0.0f; + } + + if (lights[LIGHT_TONE_CURVE].get_type() == LIGHT_PARALLEL) { + uniform->arr[U_TONE_CURVE] = 1; + vec4 chara_f_dir; + vec4 chara_f_ambient; + vec4 chara_f_diffuse; + vec4 chara_tc_param; + lights[LIGHT_TONE_CURVE].get_position(chara_f_dir); + light_get_direction_from_position(&chara_f_dir, &lights[LIGHT_TONE_CURVE]); + lights[LIGHT_TONE_CURVE].get_ambient(chara_f_ambient); + lights[LIGHT_TONE_CURVE].get_diffuse(chara_f_diffuse); + + light_tone_curve tone_curve; + lights[LIGHT_TONE_CURVE].get_tone_curve(tone_curve); + chara_tc_param.x = tone_curve.start_point; + float_t end_point = min_def(tone_curve.end_point, 1.0f) - tone_curve.start_point; + if (end_point > 0.0f) + chara_tc_param.y = 1.0f / end_point; + else + chara_tc_param.y = 0.0f; + chara_tc_param.z = tone_curve.coefficient; + chara_tc_param.w = 0.0f; + + obj_scene.g_chara_f_dir = chara_f_dir; + obj_scene.g_chara_f_ambient = chara_f_ambient; + obj_scene.g_chara_f_diffuse = chara_f_diffuse; + obj_scene.g_chara_tc_param = chara_tc_param; + } + else { + uniform->arr[U_TONE_CURVE] = 0; + obj_scene.g_chara_f_dir = { 0.0f, 1.0f, 0.0f, 0.0f }; + obj_scene.g_chara_f_ambient = 0.0f; + obj_scene.g_chara_f_diffuse = 0.0f; + obj_scene.g_chara_tc_param = 0.0f; + } + + vec4 light_reflect_dir; + lights[LIGHT_CHARA].get_position(light_reflect_dir); + if (fabsf(light_reflect_dir.x) <= 0.000001f && fabsf(light_reflect_dir.y) <= 0.000001f + && fabsf(light_reflect_dir.z) <= 0.000001f) + *(vec3*)&light_reflect_dir = vec3(0.0f, 1.0f, 0.0f); + else { + float_t length = vec3::length(*(vec3*)&light_reflect_dir); + if (length != 0.0f) + *(vec3*)&light_reflect_dir *= 1.0f / length; + } + light_reflect_dir.w = 1.0f; + + obj_scene.g_light_reflect_dir = light_reflect_dir; + + if (lights[LIGHT_REFLECT].get_type() == LIGHT_SPOT) { + vec3 spot_direction; + vec4 position; + lights[LIGHT_REFLECT].get_spot_direction(spot_direction); + lights[LIGHT_REFLECT].get_position(position); + vec4 clip_plane; + *(vec3*)&clip_plane = -spot_direction; + light_get_direction_from_position(&clip_plane, &lights[LIGHT_REFLECT], true); + clip_plane.w = -vec3::dot(*(vec3*)&position, *(vec3*)&clip_plane); + + obj_scene.g_clip_plane = clip_plane; + } + else if (lights[LIGHT_REFLECT].get_type() == LIGHT_POINT) + obj_scene.g_clip_plane = { 0.0f, -1.0f, 0.0f, 9999.0f }; + else + obj_scene.g_clip_plane = { 0.0f, -1.0f, 0.0f, 0.0f }; + + vec4 light_chara_ibl_direction; + vec4 light_chara_position; + lights[LIGHT_CHARA].get_ibl_direction(light_chara_ibl_direction); + lights[LIGHT_CHARA].get_position(light_chara_position); + + mat4 normal_tangent_transforms = mat4_identity; + + float_t length = vec3::length(*(vec3*)&light_chara_ibl_direction); + if (length >= 0.000001f) { + vec3 ibl_direction = *(vec3*)&light_chara_ibl_direction * (1.0f / length); + + length = vec3::length(*(vec3*)&light_chara_position); + if (length >= 0.000001f) { + vec3 position = *(vec3*)&light_chara_position * (1.0f / length); + + vec3 axis = vec3::cross(ibl_direction, position); + length = vec3::length(axis); + + float_t v52 = vec3::dot(ibl_direction, position); + float_t angle = fabsf(atan2f(length, v52)); + if (angle >= 0.01f && angle <= 3.131592653589793f) { + if (length != 0.0f) + axis *= 1.0f / length; + + mat4_set(&axis, -angle, &normal_tangent_transforms); + } + } + } + + obj_scene.set_g_normal_tangent_transforms(normal_tangent_transforms); + obj_scene.g_npr_cloth_spec_color = *npr_cloth_spec_color; +} + +static void light_get_direction_from_position(vec4* pos_dir, light_data* light, bool force) { + if (force || light->get_type() == LIGHT_PARALLEL) { + float_t length = vec3::length(*(vec3*)pos_dir); + if (length <= 0.000001) + *(vec3*)pos_dir = vec3(0.0f, 1.0f, 0.0f); + else + *(vec3*)pos_dir *= 1.0f / length; + pos_dir->w = 0.0f; + } +} diff --git a/src/DivaGL/light_param/light.hpp b/src/DivaGL/light_param/light.hpp new file mode 100644 index 0000000..37dbfa8 --- /dev/null +++ b/src/DivaGL/light_param/light.hpp @@ -0,0 +1,105 @@ +/* + by korenkonder + GitHub/GitLab: korenkonder +*/ + +#pragma once + +#include "../../KKdLib/default.hpp" +#include "../../KKdLib/light_param/light.hpp" +#include "../../KKdLib/mat.hpp" +#include "../../KKdLib/vec.hpp" + +struct light_data { + light_type type; + vec4 ambient; + vec4 diffuse; + vec4 specular; + vec4 position; + vec3 spot_direction; + float_t spot_exponent; + float_t spot_cutoff; + light_attenuation attenuation; + vec4 ibl_color0; + vec4 ibl_color1; + vec4 ibl_direction; + light_tone_curve tone_curve; + light_clip_plane clip_plane; + + light_type get_type() const; + void set_type(light_type value); + void get_ambient(vec4& value) const; + void set_ambient(const vec4& value); + void set_ambient(const vec4&& value); + void set_ambient(const vec4& value, bool set[4]); + void set_ambient(const vec4&& value, bool set[4]); + void get_diffuse(vec4& value) const; + void set_diffuse(const vec4& value); + void set_diffuse(const vec4&& value); + void set_diffuse(const vec4& value, bool set[4]); + void set_diffuse(const vec4&& value, bool set[4]); + void get_specular(vec4& value) const; + void set_specular(const vec4& value); + void set_specular(const vec4&& value); + void set_specular(const vec4& value, bool set[4]); + void set_specular(const vec4&& value, bool set[4]); + void get_position(vec3& value) const; + void set_position(const vec3& value); + void set_position(const vec3&& value); + void get_position(vec4& value) const; + void set_position(const vec4& value); + void set_position(const vec4&& value); + void get_spot_direction(vec3& value) const; + void set_spot_direction(const vec3& value); + void set_spot_direction(const vec3&& value); + float_t get_spot_exponent() const; + void set_spot_exponent(float_t value); + float_t get_spot_cutoff() const; + void set_spot_cutoff(float_t value); + float_t get_constant() const; + void set_constant(float_t value); + float_t get_linear() const; + void set_linear(float_t value); + float_t get_quadratic() const; + void set_quadratic(float_t value); + void get_attenuation(light_attenuation& value) const; + void set_attenuation(const light_attenuation& value); + void set_attenuation(const light_attenuation&& value); + void get_ibl_color0(vec4& value) const; + void set_ibl_color0(const vec4& value); + void set_ibl_color0(const vec4&& value); + void get_ibl_color1(vec4& value) const; + void set_ibl_color1(const vec4& value); + void set_ibl_color1(const vec4&& value); + void get_ibl_direction(vec4& value) const; + void set_ibl_direction(const vec4& value); + void set_ibl_direction(const vec4&& value); + void get_tone_curve(light_tone_curve& value) const; + void set_tone_curve(const light_tone_curve& value); + void set_tone_curve(const light_tone_curve&& value); + void get_clip_plane(light_clip_plane& value) const; + void set_clip_plane(const light_clip_plane& value); + void set_clip_plane(const light_clip_plane&& value); +}; + +static_assert(sizeof(light_data) == 0xA4, "\"light\" struct should have a size of 0xA4"); + +struct light_set { + light_data lights[LIGHT_MAX]; + vec4 ambient_intensity; + mat4 irradiance_r; + mat4 irradiance_g; + mat4 irradiance_b; + + void get_ambient_intensity(vec4& value); + void set_ambient_intensity(const vec4& value); + void set_ambient_intensity(const vec4&& value); + void get_irradiance(mat4& r, mat4& g, mat4& b); + void set_irradiance(const mat4& r, const mat4& g, const mat4& b); + void set_irradiance(const mat4&& r, const mat4&& g, const mat4&& b); + void data_set(light_set_id id); +}; + +static_assert(sizeof(light_set) == 0x5F0, "\"light_set\" struct should have a size of 0x5F0"); + +extern light_set* light_set_data; diff --git a/src/DivaGL/mdl/disp_manager.cpp b/src/DivaGL/mdl/disp_manager.cpp new file mode 100644 index 0000000..1138fe2 --- /dev/null +++ b/src/DivaGL/mdl/disp_manager.cpp @@ -0,0 +1,2343 @@ +/* + by korenkonder + GitHub/GitLab: korenkonder +*/ + +#include "disp_manager.hpp" +#include "../gl_state.hpp" +#include "../render_manager.hpp" +#include "../shader_glsl_ft.hpp" +#include "../uniform.hpp" +#include "../wrap.hpp" +#include "draw_object.hpp" +#include + +mdl::DispManager* disp_manager = (mdl::DispManager*)0x00000001411A27F0; + +static mat4* matrix_buffer = (mat4*)0x000000014CC587D0; +static BOOL* matrix_buffer_init = (BOOL*)0x000000014CC5D7D0; + +static void object_data_get_vertex_attrib_buffer_bindings(const mdl::ObjSubMeshArgs* args, + int32_t texcoord_array[2], GLuint vertex_attrib_buffer_binding[16]); + +static const GLuint POSITION_INDEX = 0; +static const GLuint BONE_WEIGHT_INDEX = 1; +static const GLuint NORMAL_INDEX = 2; +static const GLuint COLOR0_INDEX = 3; +static const GLuint COLOR1_INDEX = 4; +static const GLuint MORPH_COLOR_INDEX = 5; +static const GLuint TANGENT_INDEX = 6; +static const GLuint UNKNOWN_INDEX = 7; +static const GLuint TEXCOORD0_INDEX = 8; +static const GLuint TEXCOORD1_INDEX = 9; +static const GLuint MORPH_POSITION_INDEX = 10; +static const GLuint MORPH_NORMAL_INDEX = 11; +static const GLuint MORPH_TANGENT_INDEX = 12; +static const GLuint MORPH_TEXCOORD0_INDEX = 13; +static const GLuint MORPH_TEXCOORD1_INDEX = 14; +static const GLuint BONE_INDEX_INDEX = 15; + +namespace mdl { + prj::vector vertex_array_cache; + prj::vector etc_vertex_array_cache; + + void EtcObj::init(EtcObjType type) { + this->type = type; + color = 0xFFFFFFFF; + fog = false; + switch (type) { + case ETC_OBJ_TEAPOT: + data.teapot = {}; + break; + case ETC_OBJ_GRID: + data.grid = {}; + break; + case ETC_OBJ_CUBE: + data.cube = {}; + break; + case ETC_OBJ_SPHERE: + data.sphere = {}; + break; + case ETC_OBJ_PLANE: + data.plane = {}; + break; + case ETC_OBJ_CONE: + data.cone = {}; + break; + case ETC_OBJ_LINE: + data.line = {}; + break; + case ETC_OBJ_CROSS: + data.cross = {}; + break; + } + } + + void ObjData::init_etc(const mat4* mat, mdl::EtcObj* etc) { + kind = mdl::OBJ_KIND_ETC; + this->mat = *mat; + args.etc = *etc; + + disp_manager->add_vertex_array(&args.etc, this->mat); + } + + void ObjData::init_sub_mesh(const mat4* mat, + float_t radius, obj_sub_mesh* sub_mesh, obj_mesh* mesh, obj_material_data* material, + prj::vector* textures, int32_t mat_count, mat4* mats, GLuint vertex_buffer, + GLuint index_buffer, vec4* blend_color, GLuint morph_vertex_buffer, + int32_t instances_count, mat4* instances_mat, + void(FASTCALL* func)(const ObjSubMeshArgs*), const ObjSubMeshArgs* func_data) { + kind = mdl::OBJ_KIND_NORMAL; + this->mat = *mat; + this->radius = radius; + + mdl::ObjSubMeshArgs* args = &this->args.sub_mesh; + args->mesh = mesh; + args->morph_weight = disp_manager->morph.weight; + args->material = material; + args->sub_mesh = sub_mesh; + args->textures = textures; + args->mat_count = mat_count; + args->mats = mats; + args->vertex_buffer = vertex_buffer; + args->index_buffer = index_buffer; + args->morph_vertex_buffer = morph_vertex_buffer; + + args->texture_pattern_count = disp_manager->texture_pattern_count; + for (int32_t i = 0; i < disp_manager->texture_pattern_count && i < TEXTURE_PATTERN_COUNT; i++) + args->texture_pattern_array[i] = disp_manager->texture_pattern_array[i]; + + args->texture_transform_count = disp_manager->texture_transform_count; + for (int32_t i = 0; i < disp_manager->texture_transform_count && i < TEXTURE_TRANSFORM_COUNT; i++) + args->texture_transform_array[i] = disp_manager->texture_transform_array[i]; + + if (blend_color && *blend_color != 1.0f) { + args->set_blend_color = true; + args->blend_color = *blend_color; + } + else { + args->set_blend_color = false; + args->blend_color = 1.0f; + } + + args->chara_color = disp_manager->chara_color; + args->self_shadow = disp_manager->obj_flags & (mdl::OBJ_8 | mdl::OBJ_4) ? 1 : 0; + args->shadow = disp_manager->shadow_type; + args->texture_color_coefficients = disp_manager->texture_color_coefficients; + args->texture_color_coefficients.w = disp_manager->wet_param; + args->texture_color_offset = disp_manager->texture_color_offset; + args->texture_specular_coefficients = disp_manager->texture_specular_coefficients; + args->texture_specular_offset = disp_manager->texture_specular_offset; + args->instances_count = instances_count; + args->instances_mat = instances_mat; + args->func = func; + args->func_data = func_data; + + disp_manager->add_vertex_array(args); + } + + void ObjData::init_translucent(const mat4* mat, ObjTranslucentArgs* translucent) { + kind = mdl::OBJ_KIND_TRANSLUCENT; + this->mat = *mat; + args.translucent = *translucent; + } + + void ObjData::init_user(const mat4* mat, UserArgsFunc func, void* data) { + kind = OBJ_KIND_USER; + this->mat = *mat; + args.user.func = func; + args.user.data = data; + } + + + void DispManager::add_vertex_array(ObjSubMeshArgs* args) { + const obj_mesh* mesh = args->mesh; + const obj_sub_mesh* sub_mesh = args->sub_mesh; + const obj_material_data* material = args->material; + + GLuint vertex_buffer = args->vertex_buffer; + GLuint morph_vertex_buffer = args->morph_vertex_buffer; + GLuint index_buffer = args->index_buffer; + + int32_t texcoord_array[2] = { -1, -1 }; + int32_t color_tex_index = 0; + for (const obj_material_texture_data& i : material->material.texdata) { + if (i.tex_index == -1) + continue; + + int32_t texcoord_index = obj_material_texture_type_get_texcoord_index( + i.shader_info.m.tex_type, color_tex_index); + if (texcoord_index < 0) + continue; + + texcoord_array[texcoord_index] = sub_mesh->uv_index[&i - material->material.texdata]; + + if (i.shader_info.m.tex_type == OBJ_MATERIAL_TEXTURE_COLOR) + color_tex_index++; + } + + GLuint vertex_attrib_buffer_binding[16] = {}; + object_data_get_vertex_attrib_buffer_bindings(args, + texcoord_array, vertex_attrib_buffer_binding); + + GLsizei size_vertex = (GLsizei)mesh->size_vertex; + obj_vertex_format vertex_format = mesh->vertex_format; + + DispManager::vertex_array* vertex_array = 0; + for (DispManager::vertex_array& i : vertex_array_cache) + if (i.alive_time >= 0 && i.vertex_buffer == vertex_buffer + && i.morph_vertex_buffer == morph_vertex_buffer + && i.index_buffer == index_buffer && i.vertex_format == vertex_format + && i.size_vertex == size_vertex + && !memcmp(i.vertex_attrib_buffer_binding, + vertex_attrib_buffer_binding, sizeof(vertex_attrib_buffer_binding)) + && !memcmp(i.texcoord_array, texcoord_array, sizeof(texcoord_array))) + if (i.vertex_array) { + i.alive_time = 60; + return; + } + else { + vertex_array = &i; + break; + } + + if (!vertex_array) + for (DispManager::vertex_array& i : vertex_array_cache) + if (i.alive_time <= 0) { + vertex_array = &i; + break; + } + + if (!vertex_array) { + vertex_array_cache.push_back({}); + vertex_array = &vertex_array_cache.back(); + } + + if (!vertex_array->vertex_array) { + glGenVertexArrays(1, &vertex_array->vertex_array); + + gl_state_bind_vertex_array(vertex_array->vertex_array); + glVertexAttrib4f(POSITION_INDEX, 0.0f, 0.0f, 0.0f, 1.0f); + glVertexAttrib4f(BONE_WEIGHT_INDEX, 0.0f, 0.0f, 0.0f, 0.0f); + glVertexAttrib4f(NORMAL_INDEX, 0.0f, 0.0f, 0.0f, 1.0f); + glVertexAttrib4f(COLOR0_INDEX, 1.0f, 1.0f, 1.0f, 1.0f); + glVertexAttrib4f(COLOR1_INDEX, 1.0f, 1.0f, 1.0f, 1.0f); + glVertexAttrib4f(MORPH_COLOR_INDEX, 1.0f, 1.0f, 1.0f, 1.0f); + glVertexAttrib4f(TANGENT_INDEX, 0.0f, 0.0f, 0.0f, 1.0f); + glVertexAttrib4f(UNKNOWN_INDEX, 0.0f, 0.0f, 0.0f, 1.0f); + glVertexAttrib4f(TEXCOORD0_INDEX, 0.0f, 0.0f, 0.0f, 1.0f); + glVertexAttrib4f(TEXCOORD1_INDEX, 0.0f, 0.0f, 0.0f, 1.0f); + glVertexAttrib4f(MORPH_POSITION_INDEX, 0.0f, 0.0f, 0.0f, 1.0f); + glVertexAttrib4f(MORPH_NORMAL_INDEX, 0.0f, 0.0f, 0.0f, 1.0f); + glVertexAttrib4f(MORPH_TANGENT_INDEX, 0.0f, 0.0f, 0.0f, 1.0f); + glVertexAttrib4f(MORPH_TEXCOORD0_INDEX, 0.0f, 0.0f, 0.0f, 1.0f); + glVertexAttrib4f(MORPH_TEXCOORD1_INDEX, 0.0f, 0.0f, 0.0f, 1.0f); + glVertexAttrib4f(BONE_INDEX_INDEX, 0.0f, 0.0f, 0.0f, 0.0f); + } + + vertex_array->vertex_buffer = vertex_buffer; + vertex_array->morph_vertex_buffer = morph_vertex_buffer; + vertex_array->index_buffer = index_buffer; + vertex_array->alive_time = 60; + vertex_array->vertex_format = vertex_format; + vertex_array->size_vertex = size_vertex; + memcpy(&vertex_array->texcoord_array, texcoord_array, sizeof(texcoord_array)); + memcpy(&vertex_array->vertex_attrib_buffer_binding, + vertex_attrib_buffer_binding, sizeof(vertex_attrib_buffer_binding)); + + gl_state_bind_vertex_array(vertex_array->vertex_array); + gl_state_bind_array_buffer(vertex_buffer); + if (index_buffer) + gl_state_bind_element_array_buffer(index_buffer, true); + + size_t offset = 0; + if (vertex_format & OBJ_VERTEX_POSITION) { + if (!vertex_array->vertex_attrib_array[POSITION_INDEX]) { + glEnableVertexAttribArray(POSITION_INDEX); + vertex_array->vertex_attrib_array[POSITION_INDEX] = true; + } + + glVertexAttribPointer(POSITION_INDEX, + 3, GL_FLOAT, GL_FALSE, size_vertex, (void*)offset); + offset += 12; + } + else if (vertex_array->vertex_attrib_array[POSITION_INDEX]) { + glDisableVertexAttribArray(POSITION_INDEX); + vertex_array->vertex_attrib_array[POSITION_INDEX] = false; + } + + if (vertex_format & OBJ_VERTEX_NORMAL) { + if (!vertex_array->vertex_attrib_array[NORMAL_INDEX]) { + glEnableVertexAttribArray(NORMAL_INDEX); + vertex_array->vertex_attrib_array[NORMAL_INDEX] = true; + } + + glVertexAttribPointer(NORMAL_INDEX, + 3, GL_FLOAT, GL_FALSE, size_vertex, (void*)offset); + offset += 12; + } + else if (vertex_array->vertex_attrib_array[NORMAL_INDEX]) { + glDisableVertexAttribArray(NORMAL_INDEX); + vertex_array->vertex_attrib_array[NORMAL_INDEX] = false; + } + + if (vertex_format & OBJ_VERTEX_TANGENT) { + if (!vertex_array->vertex_attrib_array[TANGENT_INDEX]) { + glEnableVertexAttribArray(TANGENT_INDEX); + vertex_array->vertex_attrib_array[TANGENT_INDEX] = true; + } + + glVertexAttribPointer(TANGENT_INDEX, + 4, GL_FLOAT, GL_FALSE, size_vertex, (void*)offset); + offset += 16; + } + else if (vertex_array->vertex_attrib_array[TANGENT_INDEX]) { + glDisableVertexAttribArray(TANGENT_INDEX); + vertex_array->vertex_attrib_array[TANGENT_INDEX] = false; + } + + if (vertex_format & OBJ_VERTEX_BINORMAL) + offset += 12; + + for (int32_t i = 0; i < 2; i++) { + int32_t texcoord_index = texcoord_array[i]; + if (texcoord_index < 0) { + if (vertex_array->vertex_attrib_array[TEXCOORD0_INDEX + i]) { + glDisableVertexAttribArray(TEXCOORD0_INDEX + i); + vertex_array->vertex_attrib_array[TEXCOORD0_INDEX + i] = false; + } + continue; + } + + if (vertex_format & (OBJ_VERTEX_TEXCOORD0 << texcoord_index)) { + if (!vertex_array->vertex_attrib_array[TEXCOORD0_INDEX + i]) { + glEnableVertexAttribArray(TEXCOORD0_INDEX + i); + vertex_array->vertex_attrib_array[TEXCOORD0_INDEX + i] = true; + } + + glVertexAttribPointer(TEXCOORD0_INDEX + i, 2, GL_FLOAT, GL_FALSE, + size_vertex, (void*)(offset + 8ULL * texcoord_index)); + } + } + + if (vertex_format & OBJ_VERTEX_TEXCOORD0) + offset += 8; + if (vertex_format & OBJ_VERTEX_TEXCOORD1) + offset += 8; + if (vertex_format & OBJ_VERTEX_TEXCOORD2) + offset += 8; + if (vertex_format & OBJ_VERTEX_TEXCOORD3) + offset += 8; + + if (vertex_format & OBJ_VERTEX_COLOR0) { + if (!vertex_array->vertex_attrib_array[COLOR0_INDEX]) { + glEnableVertexAttribArray(COLOR0_INDEX); + vertex_array->vertex_attrib_array[COLOR0_INDEX] = true; + } + + glVertexAttribPointer(COLOR0_INDEX, + 4, GL_FLOAT, GL_FALSE, size_vertex, (void*)offset); + offset += 16; + } + else if (vertex_array->vertex_attrib_array[COLOR0_INDEX]) { + glDisableVertexAttribArray(COLOR0_INDEX); + vertex_array->vertex_attrib_array[COLOR0_INDEX] = false; + } + + if (vertex_format & OBJ_VERTEX_COLOR1) + offset += 16; + + if ((vertex_format & OBJ_VERTEX_BONE_DATA) == OBJ_VERTEX_BONE_DATA) { + if (!vertex_array->vertex_attrib_array[BONE_WEIGHT_INDEX]) { + glEnableVertexAttribArray(BONE_WEIGHT_INDEX); + vertex_array->vertex_attrib_array[BONE_WEIGHT_INDEX] = true; + } + + glVertexAttribPointer(BONE_WEIGHT_INDEX, + 4, GL_FLOAT, GL_FALSE, size_vertex, (void*)offset); + offset += 16; + + if (!vertex_array->vertex_attrib_array[BONE_INDEX_INDEX]) { + glEnableVertexAttribArray(BONE_INDEX_INDEX); + vertex_array->vertex_attrib_array[BONE_INDEX_INDEX] = true; + } + + glVertexAttribIPointer(BONE_INDEX_INDEX, + 4, GL_SHORT, size_vertex, (void*)offset); + offset += 8; + } + else { + if (vertex_array->vertex_attrib_array[BONE_WEIGHT_INDEX]) { + glDisableVertexAttribArray(BONE_WEIGHT_INDEX); + vertex_array->vertex_attrib_array[BONE_WEIGHT_INDEX] = false; + } + + if (vertex_array->vertex_attrib_array[BONE_INDEX_INDEX]) { + glDisableVertexAttribArray(BONE_INDEX_INDEX); + vertex_array->vertex_attrib_array[BONE_INDEX_INDEX] = false; + } + } + + if (vertex_format & OBJ_VERTEX_UNKNOWN) { + if (!vertex_array->vertex_attrib_array[UNKNOWN_INDEX]) { + glEnableVertexAttribArray(UNKNOWN_INDEX); + vertex_array->vertex_attrib_array[UNKNOWN_INDEX] = true; + } + + glVertexAttribPointer(UNKNOWN_INDEX, + 4, GL_FLOAT, GL_FALSE, size_vertex, (void*)offset); + offset += 16; + } + else if (vertex_array->vertex_attrib_array[UNKNOWN_INDEX]) { + glDisableVertexAttribArray(UNKNOWN_INDEX); + vertex_array->vertex_attrib_array[UNKNOWN_INDEX] = false; + } + + if (morph_vertex_buffer) { + gl_state_bind_array_buffer(morph_vertex_buffer); + + size_t offset = 0; + if (vertex_format & OBJ_VERTEX_POSITION) { + if (!vertex_array->vertex_attrib_array[MORPH_POSITION_INDEX]) { + glEnableVertexAttribArray(MORPH_POSITION_INDEX); + vertex_array->vertex_attrib_array[MORPH_POSITION_INDEX] = true; + } + + glVertexAttribPointer(MORPH_POSITION_INDEX, + 3, GL_FLOAT, GL_FALSE, size_vertex, (void*)offset); + offset += 12; + } + else if (vertex_array->vertex_attrib_array[MORPH_POSITION_INDEX]) { + glDisableVertexAttribArray(MORPH_POSITION_INDEX); + vertex_array->vertex_attrib_array[MORPH_POSITION_INDEX] = false; + } + + if (vertex_format & OBJ_VERTEX_NORMAL) { + if (!vertex_array->vertex_attrib_array[MORPH_NORMAL_INDEX]) { + glEnableVertexAttribArray(MORPH_NORMAL_INDEX); + vertex_array->vertex_attrib_array[MORPH_NORMAL_INDEX] = true; + } + + glVertexAttribPointer(MORPH_NORMAL_INDEX, + 3, GL_FLOAT, GL_FALSE, size_vertex, (void*)offset); + offset += 12; + } + else if (vertex_array->vertex_attrib_array[MORPH_NORMAL_INDEX]) { + glDisableVertexAttribArray(MORPH_NORMAL_INDEX); + vertex_array->vertex_attrib_array[MORPH_NORMAL_INDEX] = false; + } + + if (vertex_format & OBJ_VERTEX_TANGENT) { + if (!vertex_array->vertex_attrib_array[MORPH_TANGENT_INDEX]) { + glEnableVertexAttribArray(MORPH_TANGENT_INDEX); + vertex_array->vertex_attrib_array[MORPH_TANGENT_INDEX] = true; + } + + glVertexAttribPointer(MORPH_TANGENT_INDEX, + 4, GL_FLOAT, GL_FALSE, size_vertex, (void*)offset); + offset += 16; + } + else if (vertex_array->vertex_attrib_array[MORPH_TANGENT_INDEX]) { + glDisableVertexAttribArray(MORPH_TANGENT_INDEX); + vertex_array->vertex_attrib_array[MORPH_TANGENT_INDEX] = false; + } + + if (vertex_format & OBJ_VERTEX_BINORMAL) + offset += 12; + + if (vertex_format & OBJ_VERTEX_TEXCOORD0) { + if (!vertex_array->vertex_attrib_array[MORPH_TEXCOORD0_INDEX]) { + glEnableVertexAttribArray(MORPH_TEXCOORD0_INDEX); + vertex_array->vertex_attrib_array[MORPH_TEXCOORD0_INDEX] = true; + } + + glVertexAttribPointer(MORPH_TEXCOORD0_INDEX, + 2, GL_FLOAT, GL_FALSE, size_vertex, (void*)offset); + offset += 8; + } + else if (vertex_array->vertex_attrib_array[MORPH_TEXCOORD0_INDEX]) { + glDisableVertexAttribArray(MORPH_TEXCOORD0_INDEX); + vertex_array->vertex_attrib_array[MORPH_TEXCOORD0_INDEX] = false; + } + + if (vertex_format & OBJ_VERTEX_TEXCOORD1) { + if (!vertex_array->vertex_attrib_array[MORPH_TEXCOORD1_INDEX]) { + glEnableVertexAttribArray(MORPH_TEXCOORD1_INDEX); + vertex_array->vertex_attrib_array[MORPH_TEXCOORD1_INDEX] = true; + } + + glVertexAttribPointer(MORPH_TEXCOORD1_INDEX, + 2, GL_FLOAT, GL_FALSE, size_vertex, (void*)offset); + offset += 8; + } + else if (vertex_array->vertex_attrib_array[MORPH_TEXCOORD1_INDEX]) { + glDisableVertexAttribArray(MORPH_TEXCOORD1_INDEX); + vertex_array->vertex_attrib_array[MORPH_TEXCOORD1_INDEX] = false; + } + + if (vertex_format & OBJ_VERTEX_TEXCOORD2) + offset += 8; + if (vertex_format & OBJ_VERTEX_TEXCOORD3) + offset += 8; + + if (vertex_format & OBJ_VERTEX_COLOR0) { + uniform->arr[U_MORPH_COLOR] = 1; + + if (!vertex_array->vertex_attrib_array[MORPH_COLOR_INDEX]) { + glEnableVertexAttribArray(MORPH_COLOR_INDEX); + vertex_array->vertex_attrib_array[MORPH_COLOR_INDEX] = true; + } + + glVertexAttribPointer(MORPH_COLOR_INDEX, + 4, GL_FLOAT, GL_FALSE, size_vertex, (void*)offset); + offset += 16; + } + else if (vertex_array->vertex_attrib_array[MORPH_COLOR_INDEX]) { + glDisableVertexAttribArray(MORPH_COLOR_INDEX); + vertex_array->vertex_attrib_array[MORPH_COLOR_INDEX] = false; + } + + if (vertex_format & OBJ_VERTEX_COLOR1) + offset += 16; + + if ((vertex_format & OBJ_VERTEX_BONE_DATA) == OBJ_VERTEX_BONE_DATA) + offset += 32; + + if (vertex_format & OBJ_VERTEX_UNKNOWN) + offset += 16; + } + else { + if (vertex_array->vertex_attrib_array[MORPH_POSITION_INDEX]) { + glDisableVertexAttribArray(MORPH_POSITION_INDEX); + vertex_array->vertex_attrib_array[MORPH_POSITION_INDEX] = false; + } + + if (vertex_array->vertex_attrib_array[MORPH_NORMAL_INDEX]) { + glDisableVertexAttribArray(MORPH_NORMAL_INDEX); + vertex_array->vertex_attrib_array[MORPH_NORMAL_INDEX] = false; + } + + if (vertex_array->vertex_attrib_array[MORPH_TANGENT_INDEX]) { + glDisableVertexAttribArray(MORPH_TANGENT_INDEX); + vertex_array->vertex_attrib_array[MORPH_TANGENT_INDEX] = false; + } + + if (vertex_array->vertex_attrib_array[MORPH_TEXCOORD0_INDEX]) { + glDisableVertexAttribArray(MORPH_TEXCOORD0_INDEX); + vertex_array->vertex_attrib_array[MORPH_TEXCOORD0_INDEX] = false; + } + + if (vertex_array->vertex_attrib_array[MORPH_TEXCOORD1_INDEX]) { + glDisableVertexAttribArray(MORPH_TEXCOORD1_INDEX); + vertex_array->vertex_attrib_array[MORPH_TEXCOORD1_INDEX] = false; + } + + if (vertex_array->vertex_attrib_array[MORPH_COLOR_INDEX]) { + glDisableVertexAttribArray(MORPH_COLOR_INDEX); + vertex_array->vertex_attrib_array[MORPH_COLOR_INDEX] = false; + } + } + + gl_state_bind_array_buffer(0); + gl_state_bind_vertex_array(0); + if (index_buffer) + gl_state_bind_element_array_buffer(0); + } + + static void gen_cube_vertices(prj::vector& data) { + data.resize(sizeof(vec3) * 2 * 4 * 6); + + vec3* vtx = (vec3*)data.data(); + *vtx++ = { -1.0f, -1.0f, -1.0f }; + *vtx++ = { 0.0f, 0.0f, -1.0f }; + *vtx++ = { 1.0f, 1.0f, -1.0f }; + *vtx++ = { 0.0f, 0.0f, -1.0f }; + *vtx++ = { 1.0f, -1.0f, -1.0f }; + *vtx++ = { 0.0f, 0.0f, -1.0f }; + *vtx++ = { -1.0f, 1.0f, -1.0f }; + *vtx++ = { 0.0f, 0.0f, -1.0f }; + + *vtx++ = { -1.0f, -1.0f, 1.0f }; + *vtx++ = { 0.0f, 0.0f, 1.0f }; + *vtx++ = { 1.0f, -1.0f, 1.0f }; + *vtx++ = { 0.0f, 0.0f, 1.0f }; + *vtx++ = { 1.0f, 1.0f, 1.0f }; + *vtx++ = { 0.0f, 0.0f, 1.0f }; + *vtx++ = { -1.0f, 1.0f, 1.0f }; + *vtx++ = { 0.0f, 0.0f, 1.0f }; + + *vtx++ = { -1.0f, 1.0f, 1.0f }; + *vtx++ = { -1.0f, 0.0f, 0.0f }; + *vtx++ = { -1.0f, 1.0f, -1.0f }; + *vtx++ = { -1.0f, 0.0f, 0.0f }; + *vtx++ = { -1.0f, -1.0f, -1.0f }; + *vtx++ = { -1.0f, 0.0f, 0.0f }; + *vtx++ = { -1.0f, -1.0f, 1.0f }; + *vtx++ = { -1.0f, 0.0f, 0.0f }; + + *vtx++ = { 1.0f, 1.0f, -1.0f }; + *vtx++ = { 1.0f, 0.0f, 0.0f }; + *vtx++ = { 1.0f, 1.0f, 1.0f }; + *vtx++ = { 1.0f, 0.0f, 0.0f }; + *vtx++ = { 1.0f, -1.0f, -1.0f }; + *vtx++ = { 1.0f, 0.0f, 0.0f }; + *vtx++ = { 1.0f, -1.0f, 1.0f }; + *vtx++ = { 1.0f, 0.0f, 0.0f }; + + *vtx++ = { -1.0f, -1.0f, -1.0f }; + *vtx++ = { 0.0f, -1.0f, 0.0f }; + *vtx++ = { 1.0f, -1.0f, -1.0f }; + *vtx++ = { 0.0f, -1.0f, 0.0f }; + *vtx++ = { 1.0f, -1.0f, 1.0f }; + *vtx++ = { 0.0f, -1.0f, 0.0f }; + *vtx++ = { -1.0f, -1.0f, 1.0f }; + *vtx++ = { 0.0f, -1.0f, 0.0f }; + + *vtx++ = { -1.0f, 1.0f, -1.0f }; + *vtx++ = { 0.0f, 1.0f, 0.0f }; + *vtx++ = { 1.0f, 1.0f, 1.0f }; + *vtx++ = { 0.0f, 1.0f, 0.0f }; + *vtx++ = { 1.0f, 1.0f, -1.0f }; + *vtx++ = { 0.0f, 1.0f, 0.0f }; + *vtx++ = { -1.0f, 1.0f, 1.0f }; + *vtx++ = { 0.0f, 1.0f, 0.0f }; + } + + static size_t gen_cube_indices(prj::vector& indices) { + const uint32_t sides_indices[] = { + 0, 1, 2, 0, 3, 1, + 4, 5, 6, 6, 7, 4, + 8, 9, 10, 10, 11, 8, + 12, 13, 14, 15, 14, 13, + 16, 17, 18, 18, 19, 16, + 20, 21, 22, 20, 23, 21, + }; + + const uint32_t edges_indices[] = { + 0, 2, 1, 2, 0, 3, 1, 3, + 4, 5, 6, 5, 4, 7, 6, 7, + 0, 4, 1, 6, 2, 5, 3, 7, + }; + + indices.insert(indices.end(), sides_indices, + sides_indices + sizeof(sides_indices) / sizeof(uint32_t)); + + size_t wire_offset = indices.size(); + + indices.insert(indices.end(), edges_indices, + edges_indices + sizeof(edges_indices) / sizeof(uint32_t)); + + return wire_offset; + } + + static void gen_sphere_vertices(prj::vector& data, + int32_t slices, int32_t stacks, float_t radius) { + if (slices < 2 || stacks < 2) + return; + + data.reserve(sizeof(vec3) * 2); + + data.push_back(0.0f); + data.push_back(radius); + data.push_back(0.0f); + + data.push_back(0.0f); + data.push_back(1.0f); + data.push_back(0.0f); + + double_t slice_step = (M_PI * 2.0) / (double_t)slices; + double_t stack_step = M_PI / (double_t)stacks; + + for (int32_t i = 1; i < stacks; i++) { + float_t stack_angle = (float_t)((M_PI / 2.0) - (double_t)i * stack_step); + float_t xz = cosf(stack_angle); + float_t y = sinf(stack_angle); + + data.reserve(sizeof(vec3) * 2 * slices); + + for (int32_t j = 0; j < slices; j++) { + float_t slice_angle = (float_t)((double_t)j * slice_step); + + float_t x = xz * cosf(slice_angle); + float_t z = xz * sinf(slice_angle); + + data.push_back(x * radius); + data.push_back(y * radius); + data.push_back(z * radius); + + data.push_back(x); + data.push_back(y); + data.push_back(z); + } + } + + data.reserve(sizeof(vec3) * 2); + + data.push_back(0.0f); + data.push_back(-radius); + data.push_back(0.0f); + + data.push_back(0.0f); + data.push_back(-1.0f); + data.push_back(0.0f); + } + + static size_t gen_sphere_indices(prj::vector& indices, + int32_t slices, int32_t stacks) { + if (slices < 2 || stacks < 2) + return 0; + + // Top stack vertices + { + int32_t m1 = 0; + int32_t m2 = 1; + + indices.reserve(3LL * slices); + + for (int32_t j = 0, k = 1; j < slices; j++) { + indices.push_back(m1); + indices.push_back(k + m2); + indices.push_back(j + m2); + + if (++k >= slices) + k = 0; + } + } + + // Middle stacks vertices + for (int32_t i = 1; i < stacks - 1; i++) { + int32_t m1 = (i - 1) * slices + 1; + int32_t m2 = m1 + slices; + + indices.reserve(6LL * slices); + + for (int32_t j = 0, k = 1; j < slices; j++) { + indices.push_back(j + m1); + indices.push_back(k + m1); + indices.push_back(j + m2); + + indices.push_back(k + m1); + indices.push_back(k + m2); + indices.push_back(j + m2); + + if (++k >= slices) + k = 0; + } + } + + // Bottom stack vertices + { + int32_t m1 = (stacks - 2) * slices + 1; + int32_t m2 = m1 + slices; + + indices.reserve(3LL * slices); + + for (int32_t j = 0, k = 1; j < slices; j++) { + indices.push_back(j + m1); + indices.push_back(k + m1); + indices.push_back(m2); + + if (++k >= slices) + k = 0; + } + } + + size_t wire_offset = indices.size(); + + // Top stack wireframe + { + int32_t m1 = 0; + int32_t m2 = 1; + + indices.reserve(2LL * slices); + + for (int32_t j = 0; j < slices; j++) { + indices.push_back(m1); + indices.push_back(j + m2); + } + } + + // Middle stacks wireframe + for (int32_t i = 1; i < stacks - 1; i++) { + int32_t m1 = (i - 1) * slices + 1; + int32_t m2 = m1 + slices; + + indices.reserve(2LL * slices); + + for (int32_t j = 0; j < slices; j++) { + indices.push_back(j + m1); + indices.push_back(j + m2); + } + } + + // Bottom stack wireframe + { + int32_t m1 = (stacks - 2) * slices + 1; + int32_t m2 = m1 + slices; + + indices.reserve(2LL * slices); + + for (int32_t j = 0; j < slices; j++) { + indices.push_back(j + m1); + indices.push_back(m2); + } + } + + // Slices wireframe + for (int32_t i = 1; i < stacks; i++) { + int32_t m = (i - 1) * slices + 1; + + indices.reserve(2LL * slices); + + for (int32_t j = 0, k = 1; j < slices; j++) { + indices.push_back(j + m); + indices.push_back(k + m); + + if (k++ >= slices) + k = 0; + } + } + + return wire_offset; + } + + void DispManager::add_vertex_array(EtcObj* etc, mat4& mat) { + EtcObjType type = etc->type; + switch (type) { + case mdl::ETC_OBJ_TEAPOT: + case mdl::ETC_OBJ_GRID: + case mdl::ETC_OBJ_CUBE: + case mdl::ETC_OBJ_SPHERE: + case mdl::ETC_OBJ_PLANE: + case mdl::ETC_OBJ_CONE: + case mdl::ETC_OBJ_LINE: + case mdl::ETC_OBJ_CROSS: + break; + default: + return; + } + + bool indexed = false; + bool wire = false; + float_t length = 0.0f; + + switch (type) { + case mdl::ETC_OBJ_TEAPOT: { + EtcObjTeapot& teapot = etc->data.teapot; + + indexed = true; + } break; + case mdl::ETC_OBJ_GRID: { + EtcObjGrid& grid = etc->data.grid; + + } break; + case mdl::ETC_OBJ_CUBE: { + EtcObjCube& cube = etc->data.cube; + + vec3 size = cube.size * 0.5f; + mat4_scale_rot(&mat, &size, &mat); + + indexed = true; + wire = cube.wire; + } break; + case mdl::ETC_OBJ_SPHERE: { + EtcObjSphere& sphere = etc->data.sphere; + + indexed = true; + wire = sphere.wire; + } break; + case mdl::ETC_OBJ_PLANE: { + EtcObjPlane& plane = etc->data.plane; + + mat4_scale_rot(&mat, (float_t)plane.w * 0.5f, 1.0f, (float_t)plane.h * 0.5f, &mat); + } break; + case mdl::ETC_OBJ_CONE: { + EtcObjCone& cone = etc->data.cone; + + indexed = true; + wire = cone.wire; + } break; + case mdl::ETC_OBJ_LINE: { + EtcObjLine& line = etc->data.line; + + } break; + case mdl::ETC_OBJ_CROSS: { + EtcObjCross& cross = etc->data.cross; + + mat4_scale_rot(&mat, cross.size, &mat); + } break; + } + + DispManager::etc_vertex_array* etc_vertex_array = 0; + for (DispManager::etc_vertex_array& i : etc_vertex_array_cache) { + if (i.alive_time <= 0 || i.type != type || i.vertex_buffer.IsNull()) + continue; + + if (type == mdl::ETC_OBJ_TEAPOT + || type == mdl::ETC_OBJ_GRID + && !memcmp(&i.data.grid, &etc->data.grid, sizeof(EtcObjGrid)) + || type == mdl::ETC_OBJ_CUBE + || type == mdl::ETC_OBJ_SPHERE + && i.data.sphere.slices == etc->data.sphere.slices + && i.data.sphere.stacks == etc->data.sphere.stacks + && fabsf(i.data.sphere.radius - etc->data.sphere.radius) < 0.00001f + || type == mdl::ETC_OBJ_PLANE + || type == mdl::ETC_OBJ_CONE + && i.data.cone.slices == etc->data.cone.slices + && i.data.cone.stacks == etc->data.cone.stacks + && fabsf(i.data.cone.base - etc->data.cone.base) < 0.00001f + && fabsf(i.data.cone.height - etc->data.cone.height) < 0.00001f + || type == mdl::ETC_OBJ_LINE + || type == mdl::ETC_OBJ_CROSS) + if (i.vertex_array) { + i.alive_time = 2; + if (!wire) { + etc->count = i.count; + etc->offset = i.offset; + } + else { + etc->count = i.wire_count; + etc->offset = i.wire_offset; + } + return; + } + else { + etc_vertex_array = &i; + break; + } + } + + if (!etc_vertex_array) + for (DispManager::etc_vertex_array& i : etc_vertex_array_cache) + if (i.alive_time <= 0) { + etc_vertex_array = &i; + break; + } + + if (!etc_vertex_array) { + etc_vertex_array_cache.push_back({}); + etc_vertex_array = &etc_vertex_array_cache.back(); + } + + if (!etc_vertex_array->vertex_array) { + glGenVertexArrays(1, &etc_vertex_array->vertex_array); + + gl_state_bind_vertex_array(etc_vertex_array->vertex_array); + glVertexAttrib4f( POSITION_INDEX, 0.0f, 0.0f, 0.0f, 1.0f); + glVertexAttrib4f( BONE_WEIGHT_INDEX, 0.0f, 0.0f, 0.0f, 0.0f); + glVertexAttrib4f( NORMAL_INDEX, 0.0f, 0.0f, 0.0f, 1.0f); + glVertexAttrib4f( COLOR0_INDEX, 1.0f, 1.0f, 1.0f, 1.0f); + glVertexAttrib4f( COLOR1_INDEX, 1.0f, 1.0f, 1.0f, 1.0f); + glVertexAttrib4f( MORPH_COLOR_INDEX, 1.0f, 1.0f, 1.0f, 1.0f); + glVertexAttrib4f( TANGENT_INDEX, 0.0f, 0.0f, 0.0f, 1.0f); + glVertexAttrib4f( UNKNOWN_INDEX, 0.0f, 0.0f, 0.0f, 1.0f); + glVertexAttrib4f( TEXCOORD0_INDEX, 0.0f, 0.0f, 0.0f, 1.0f); + glVertexAttrib4f( TEXCOORD1_INDEX, 0.0f, 0.0f, 0.0f, 1.0f); + glVertexAttrib4f( MORPH_POSITION_INDEX, 0.0f, 0.0f, 0.0f, 1.0f); + glVertexAttrib4f( MORPH_NORMAL_INDEX, 0.0f, 0.0f, 0.0f, 1.0f); + glVertexAttrib4f( MORPH_TANGENT_INDEX, 0.0f, 0.0f, 0.0f, 1.0f); + glVertexAttrib4f(MORPH_TEXCOORD0_INDEX, 0.0f, 0.0f, 0.0f, 1.0f); + glVertexAttrib4f(MORPH_TEXCOORD1_INDEX, 0.0f, 0.0f, 0.0f, 1.0f); + glVertexAttrib4f( BONE_INDEX_INDEX, 0.0f, 0.0f, 0.0f, 0.0f); + } + + etc_vertex_array->alive_time = 2; + etc_vertex_array->data = etc->data; + etc_vertex_array->type = type; + + prj::vector vtx_data; + prj::vector vtx_indices; + switch (type) { + case mdl::ETC_OBJ_TEAPOT: { + EtcObjTeapot& teapot = etc->data.teapot; + + etc_vertex_array->count = (GLsizei)vtx_indices.size(); + } break; + case mdl::ETC_OBJ_GRID: { + EtcObjGrid& grid = etc->data.grid; + + etc_vertex_array->count = (GLsizei)(vtx_data.size() / 6); + } break; + case mdl::ETC_OBJ_CUBE: { + EtcObjCube& cube = etc->data.cube; + + gen_cube_vertices(vtx_data); + size_t wire_offset = gen_cube_indices(vtx_indices); + + etc_vertex_array->offset = 0; + etc_vertex_array->count = (GLsizei)wire_offset; + etc_vertex_array->wire_offset = wire_offset * sizeof(uint32_t); + etc_vertex_array->wire_count = (GLsizei)(vtx_indices.size() - wire_offset); + } break; + case mdl::ETC_OBJ_SPHERE: { + EtcObjSphere& sphere = etc->data.sphere; + + gen_sphere_vertices(vtx_data, sphere.slices, sphere.stacks, sphere.radius); + size_t wire_offset = gen_sphere_indices(vtx_indices, sphere.slices, sphere.stacks); + + etc_vertex_array->offset = 0; + etc_vertex_array->count = (GLsizei)wire_offset; + etc_vertex_array->wire_offset = wire_offset * sizeof(uint32_t); + etc_vertex_array->wire_count = (GLsizei)(vtx_indices.size() - wire_offset); + } break; + case mdl::ETC_OBJ_PLANE: { + EtcObjPlane& plane = etc->data.plane; + + etc_vertex_array->count = (GLsizei)(vtx_data.size() / 6); + } break; + case mdl::ETC_OBJ_CONE: { + EtcObjCone& cone = etc->data.cone; + + etc_vertex_array->count = (GLsizei)vtx_indices.size(); + } break; + case mdl::ETC_OBJ_LINE: { + EtcObjLine& line = etc->data.line; + + etc_vertex_array->count = (GLsizei)(vtx_data.size() / 6); + } break; + case mdl::ETC_OBJ_CROSS: { + EtcObjCross& cross = etc->data.cross; + + etc_vertex_array->count = (GLsizei)(vtx_data.size() / 6); + } break; + } + + if (!wire) { + etc->count = etc_vertex_array->count; + etc->offset = etc_vertex_array->offset; + } + else { + etc->count = etc_vertex_array->wire_count; + etc->offset = etc_vertex_array->wire_offset; + } + + if (!etc_vertex_array->count) + return; + + if (etc_vertex_array->max_vtx < vtx_data.size()) { + etc_vertex_array->max_vtx = vtx_data.size(); + + etc_vertex_array->vertex_buffer.Destroy(); + } + + if (etc_vertex_array->max_idx < vtx_indices.size()) { + etc_vertex_array->max_idx = vtx_indices.size(); + + etc_vertex_array->index_buffer.Destroy(); + } + + GLsizei size_vertex = sizeof(vec3) * 2; + + gl_state_bind_vertex_array(etc_vertex_array->vertex_array); + + if (etc_vertex_array->vertex_buffer.IsNull()) + etc_vertex_array->vertex_buffer.Create(sizeof(float_t) * vtx_data.size()); + + etc_vertex_array->vertex_buffer.Bind(); + glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(float_t) + * vtx_data.size(), vtx_data.data()); + + if (indexed) { + if (etc_vertex_array->index_buffer.IsNull()) + etc_vertex_array->index_buffer.Create(sizeof(uint32_t) * vtx_indices.size()); + + etc_vertex_array->index_buffer.Bind(); + glBufferSubData(GL_ELEMENT_ARRAY_BUFFER, 0, sizeof(uint32_t) + * vtx_indices.size(), vtx_indices.data()); + } + + glEnableVertexAttribArray(POSITION_INDEX); + glVertexAttribPointer(POSITION_INDEX, + 3, GL_FLOAT, GL_FALSE, size_vertex, (void*)0); + + glEnableVertexAttribArray(NORMAL_INDEX); + glVertexAttribPointer(NORMAL_INDEX, + 3, GL_FLOAT, GL_FALSE, size_vertex, (void*)sizeof(vec3)); + + gl_state_bind_array_buffer(0); + gl_state_bind_vertex_array(0); + if (indexed) + gl_state_bind_element_array_buffer(0); + } + + void* DispManager::alloc_data(int32_t size) { + if (!buff || buff_offset + size > buff_size) + return 0; + + void* data = (void*)((size_t)buff + buff_offset); + buff_offset += size; + buff_max = max_def(buff_max, buff_offset); + return data; + } + + ObjData* DispManager::alloc_obj_data(ObjKind kind) { + int32_t size = (int32_t)align_val(sizeof(ObjKind) + sizeof(mat4) + sizeof(float_t) * 2, 0x08); + switch (kind) { + case OBJ_KIND_NORMAL: + return (ObjData*)alloc_data(size + sizeof(ObjSubMeshArgs)); + case OBJ_KIND_ETC: + return (ObjData*)alloc_data(size + sizeof(EtcObj)); + case OBJ_KIND_USER: + return (ObjData*)alloc_data(size + sizeof(UserArgs)); + case OBJ_KIND_TRANSLUCENT: + return (ObjData*)alloc_data(size + sizeof(ObjTranslucentArgs)); + default: + return 0; + } + } + + mat4* DispManager::alloc_mat4_array(int32_t count) { + return (mat4*)alloc_data(sizeof(mat4) * count); + } + + void DispManager::buffer_reset() { + buff_offset = 0; + } + + void DispManager::check_vertex_arrays() { + for (DispManager::vertex_array& i : vertex_array_cache) + if (i.alive_time > 0 && --i.alive_time <= 0) { + i.vertex_buffer = 0; + i.morph_vertex_buffer = 0; + } + + for (DispManager::etc_vertex_array& i : etc_vertex_array_cache) + if (i.alive_time > 0 && --i.alive_time <= 0) { + gl_state_bind_vertex_array(i.vertex_array); + glDisableVertexAttribArray(POSITION_INDEX); + glDisableVertexAttribArray(NORMAL_INDEX); + gl_state_bind_array_buffer(0, true); + gl_state_bind_element_array_buffer(0, true); + gl_state_bind_vertex_array(0); + } + } + + void DispManager::draw(ObjType type, int32_t depth_mask, bool a4) { + if (get_obj_count(type) < 1) + return; + + int32_t alpha_test = 0; + float_t min_alpha = 1.0f; + float_t alpha_threshold = 0.0f; + bool reflect = uniform->arr[U_REFLECT] == 1; + void(*func)(const ObjSubMeshArgs * args) = draw_sub_mesh_default; + + for (int32_t i = 0; i < 5; i++) + gl_state_active_bind_texture_2d(i, rctx->empty_texture_2d); + gl_state_active_bind_texture_cube_map(5, rctx->empty_texture_cube_map); + gl_state_active_texture(0); + gl_state_set_blend_func(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + uniform_value_reset(); + gl_state_get(); + + rctx->obj_scene_ubo.Bind(0); + rctx->obj_batch_ubo.Bind(1); + rctx->obj_skinning_ubo.Bind(3); + + switch (type) { + case OBJ_TYPE_TRANSLUCENT: + case OBJ_TYPE_TRANSLUCENT_NO_SHADOW: + //case OBJ_TYPE_TRANSLUCENT_LOCAL: + if (depth_mask) + func = draw_sub_mesh_translucent; + else + gl_state_set_depth_mask(GL_FALSE); + alpha_test = 1; + min_alpha = 0.0f; + alpha_threshold = 0.0f; + break; + case OBJ_TYPE_TRANSPARENT: + //case OBJ_TYPE_TRANSPARENT_LOCAL: + alpha_test = 1; + min_alpha = 0.1f; + alpha_threshold = 0.5f; + break; + case OBJ_TYPE_SHADOW_CHARA: + case OBJ_TYPE_SHADOW_STAGE: + case OBJ_TYPE_SHADOW_OBJECT_CHARA: + case OBJ_TYPE_SHADOW_OBJECT_STAGE: + func = draw_sub_mesh_shadow; + break; + case OBJ_TYPE_TYPE_6: + func = draw_sub_mesh_translucent; + gl_state_set_color_mask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE); + draw_state->shader_index = SHADER_FT_SIL; + break; + case OBJ_TYPE_TYPE_7: + func = draw_sub_mesh_translucent; + gl_state_set_color_mask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE); + draw_state->shader_index = SHADER_FT_SIL; + alpha_test = 1; + min_alpha = 0.0f; + alpha_threshold = 0.99999994f; + break; + case OBJ_TYPE_REFLECT_CHARA_OPAQUE: + gl_state_set_cull_face_mode(GL_FRONT); + if (reflect) + func = draw_sub_mesh_reflect; + else if (render_manager->reflect_type == STAGE_DATA_REFLECT_REFLECT_MAP) + func = draw_sub_mesh_reflect_reflect_map; + break; + case OBJ_TYPE_REFLECT_CHARA_TRANSLUCENT: + gl_state_set_cull_face_mode(GL_FRONT); + if (reflect) + func = draw_sub_mesh_reflect; + else if (render_manager->reflect_type == STAGE_DATA_REFLECT_REFLECT_MAP) + func = draw_sub_mesh_reflect_reflect_map; + min_alpha = 0.0f; + break; + case OBJ_TYPE_REFLECT_CHARA_TRANSPARENT: + gl_state_set_cull_face_mode(GL_FRONT); + if (reflect) + func = draw_sub_mesh_reflect; + else if (render_manager->reflect_type == STAGE_DATA_REFLECT_REFLECT_MAP) + func = draw_sub_mesh_reflect_reflect_map; + alpha_test = 1; + min_alpha = 0.1f; + alpha_threshold = 0.5f; + break; + case OBJ_TYPE_REFLECT_OPAQUE: + alpha_test = 1; + if (!a4) + func = draw_sub_mesh_reflect_reflect_map; + break; + case OBJ_TYPE_REFLECT_TRANSLUCENT: + case OBJ_TYPE_REFRACT_TRANSLUCENT: + gl_state_set_depth_mask(GL_FALSE); + min_alpha = 0.0f; + alpha_threshold = 0.0f; + break; + case OBJ_TYPE_REFLECT_TRANSPARENT: + case OBJ_TYPE_REFRACT_TRANSPARENT: + alpha_test = 1; + min_alpha = 0.1f; + alpha_threshold = 0.0f; + break; + case OBJ_TYPE_SSS: + func = draw_sub_mesh_sss; + break; + case OBJ_TYPE_USER: + func = draw_sub_mesh_translucent; + break; + default: + break; + } + rctx->obj_batch.g_max_alpha = { 0.0f, 0.0f, alpha_threshold, min_alpha }; + uniform->arr[U_ALPHA_TEST] = alpha_test; + + for (ObjData*& i : obj[type]) { + switch (i->kind) { + case OBJ_KIND_NORMAL: { + draw_sub_mesh(&i->args.sub_mesh, &i->mat, func); + } break; + case OBJ_KIND_ETC: { + draw_object_model_mat_load(i->mat); + draw_etc_obj(&i->args.etc); + } break; + case OBJ_KIND_USER: { + draw_object_model_mat_load(i->mat); + i->args.user.func(i->args.user.data); + } break; + case OBJ_KIND_TRANSLUCENT: { + for (uint32_t j = 0; j < i->args.translucent.count; j++) + draw_sub_mesh(i->args.translucent.sub_mesh[j], &i->mat, func); + } break; + } + } + + switch (type) { + case OBJ_TYPE_TRANSLUCENT: + case OBJ_TYPE_TRANSLUCENT_NO_SHADOW: + case OBJ_TYPE_REFLECT_TRANSLUCENT: + case OBJ_TYPE_REFRACT_TRANSLUCENT: + if (!depth_mask) + gl_state_set_depth_mask(GL_TRUE); + break; + case OBJ_TYPE_TYPE_6: + case OBJ_TYPE_TYPE_7: + draw_state->shader_index = -1; + gl_state_set_color_mask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); + break; + case OBJ_TYPE_REFLECT_CHARA_OPAQUE: + case OBJ_TYPE_REFLECT_CHARA_TRANSLUCENT: + case OBJ_TYPE_REFLECT_CHARA_TRANSPARENT: + gl_state_set_cull_face_mode(GL_BACK); + break; + } + + uniform_value_reset(); + gl_state_bind_vertex_array(0); + shader_glsl::unbind(); + gl_state_set_blend_func(GL_ONE, GL_ZERO); + for (int32_t i = 0; i < 5; i++) + gl_state_bind_sampler(i, 0); + } + + void DispManager::draw_translucent(ObjType type, int32_t alpha) { + if (get_obj_count(type) < 1) + return; + + int32_t alpha_test = 0; + float_t min_alpha = 1.0f; + float_t alpha_threshold = 0.0f; + bool reflect = uniform->arr[U_REFLECT] == 1; + void(*func)(const ObjSubMeshArgs * args) = draw_sub_mesh_default; + + for (int32_t i = 0; i < 5; i++) + gl_state_active_bind_texture_2d(i, rctx->empty_texture_2d); + gl_state_active_bind_texture_cube_map(5, rctx->empty_texture_cube_map); + gl_state_active_texture(0); + gl_state_set_blend_func(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + uniform_value_reset(); + gl_state_get(); + + rctx->obj_scene_ubo.Bind(0); + rctx->obj_batch_ubo.Bind(1); + rctx->obj_skinning_ubo.Bind(3); + + switch (type) { + case OBJ_TYPE_TRANSLUCENT_ALPHA_ORDER_1: + case OBJ_TYPE_TRANSLUCENT_ALPHA_ORDER_2: + case OBJ_TYPE_TRANSLUCENT_ALPHA_ORDER_3: + //case OBJ_TYPE_TRANSLUCENT_ALPHA_ORDER_2_LOCAL: + gl_state_set_depth_mask(GL_FALSE); + alpha_test = 1; + min_alpha = 0.0f; + alpha_threshold = 0.0f; + break; + case OBJ_TYPE_TRANSPARENT_ALPHA_ORDER_1: + case OBJ_TYPE_TRANSPARENT_ALPHA_ORDER_2: + case OBJ_TYPE_TRANSPARENT_ALPHA_ORDER_3: + //case OBJ_TYPE_TRANSPARENT_ALPHA_ORDER_2_LOCAL: + alpha_test = 1; + min_alpha = 0.1f; + alpha_threshold = 0.5f; + break; + } + rctx->obj_batch.g_max_alpha = { 0.0f, 0.0f, alpha_threshold, min_alpha }; + uniform->arr[U_ALPHA_TEST] = alpha_test; + + for (ObjData*& i : obj[type]) { + switch (i->kind) { + case OBJ_KIND_NORMAL: { + int32_t a = (int32_t)(i->args.sub_mesh.blend_color.w * 255.0f); + a = clamp_def(a, 0, 255); + if (a == alpha) + draw_sub_mesh(&i->args.sub_mesh, &i->mat, func); + } break; + case OBJ_KIND_TRANSLUCENT: { + for (uint32_t j = 0; j < i->args.translucent.count; j++) { + ObjSubMeshArgs* args = i->args.translucent.sub_mesh[j]; + int32_t a = (int32_t)(args->blend_color.w * 255.0f); + a = clamp_def(a, 0, 255); + if (a == alpha) + draw_sub_mesh(args, &i->mat, func); + } + } break; + } + } + + switch (type) { + case OBJ_TYPE_TRANSLUCENT_ALPHA_ORDER_1: + case OBJ_TYPE_TRANSLUCENT_ALPHA_ORDER_2: + case OBJ_TYPE_TRANSLUCENT_ALPHA_ORDER_3: + gl_state_set_depth_mask(GL_TRUE); + break; + case OBJ_TYPE_TRANSPARENT_ALPHA_ORDER_1: + case OBJ_TYPE_TRANSPARENT_ALPHA_ORDER_2: + case OBJ_TYPE_TRANSPARENT_ALPHA_ORDER_3: + gl_state_set_cull_face_mode(GL_BACK); + break; + } + + uniform_value_reset(); + shader_glsl::unbind(); + gl_state_set_blend_func(GL_ONE, GL_ZERO); + } + + /*void DispManager::draw_show_vector(ObjType type, int32_t show_vector) { + if (get_obj_count(type) < 1) + return; + + render_context* rctx = rctx_ptr; + + for (int32_t i = 0; i < 5; i++) + gl_state_active_bind_texture_2d(i, rctx->empty_texture_2d); + gl_state_active_bind_texture_cube_map(5, rctx->empty_texture_cube_map); + gl_state_active_texture(0); + gl_state_set_blend_func(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + uniform_value_reset(); + gl_state_get(); + + for (ObjData*& i : obj[type]) { + switch (i->type) { + case OBJ_KIND_NORMAL: { + draw_sub_mesh_show_vector(&i->args.sub_mesh, + &i->mat, show_vector); + } break; + case OBJ_KIND_TRANSLUCENT: { + for (uint32_t j = 0; j < i->args.translucent.count; j++) + draw_sub_mesh_show_vector(i->args.translucent.sub_mesh[j], + &i->mat, show_vector); + } break; + } + } + gl_state_set_blend_func(GL_ONE, GL_ZERO); + }*/ + + void DispManager::entry_list(ObjType type, ObjData* data) { + obj[type].push_back(data); + } + + static int32_t obj_axis_aligned_bounding_box_check_visibility( + obj_axis_aligned_bounding_box* aabb, const mat4* mat) { + vec3 points[8]; + points[0] = aabb->center + (aabb->size ^ vec3(0.0f, 0.0f, 0.0f)); + points[1] = aabb->center + (aabb->size ^ vec3(-0.0f, -0.0f, -0.0f)); + points[2] = aabb->center + (aabb->size ^ vec3(-0.0f, 0.0f, 0.0f)); + points[3] = aabb->center + (aabb->size ^ vec3(0.0f, -0.0f, -0.0f)); + points[4] = aabb->center + (aabb->size ^ vec3(0.0f, -0.0f, 0.0f)); + points[5] = aabb->center + (aabb->size ^ vec3(-0.0f, 0.0f, -0.0f)); + points[6] = aabb->center + (aabb->size ^ vec3(0.0f, 0.0f, -0.0f)); + points[7] = aabb->center + (aabb->size ^ vec3(-0.0f, -0.0f, 0.0f)); + + mat4 view_mat; + mat4_transpose(&camera_data->view_matrix, &view_mat); + mat4_mul(mat, &view_mat, &view_mat); + for (int32_t i = 0; i < 8; i++) + mat4_transform_point(&view_mat, &points[i], &points[i]); + + vec4 v2[6]; + *(vec3*)&v2[0] = { 0.0f, 0.0f, -1.0f }; + v2[0].w = (float_t)-camera_data->min_distance; + *(vec3*)&v2[1] = camera_data->field_1E4; + v2[1].w = 0.0f; + *(vec3*)&v2[2] = camera_data->field_1F0; + v2[2].w = 0.0f; + *(vec3*)&v2[3] = camera_data->field_1FC; + v2[3].w = 0.0f; + *(vec3*)&v2[4] = camera_data->field_208; + v2[4].w = 0.0f; + *(vec3*)&v2[5] = { 0.0f, 0.0f, 1.0f }; + v2[5].w = (float_t)camera_data->max_distance; + + for (int32_t i = 0; i < 6; i++) + for (int32_t j = 0; j < 8; j++) { + float_t v34 = vec3::dot(*(vec3*)&v2[i], points[j]) + v2[i].w; + if (v34 > 0.0f) + break; + + if (j == 7) + return 0; + } + return 1; + } + + static int32_t obj_bounding_sphere_check_visibility(obj_bounding_sphere* sphere, + CullingCheck* culling, const mat4* mat) { + if (disp_manager->culling_func) + return disp_manager->culling_func(sphere); + + mat4 view_mat; + mat4_transpose(&camera_data->view_matrix, &view_mat); + + vec3 center; + mat4_transform_point(mat, &sphere->center, ¢er); + mat4_transform_point(&view_mat, ¢er, ¢er); + float_t radius = mat4_get_max_scale(mat) * sphere->radius; + + double_t min_depth = (double_t)center.z - (double_t)radius; + double_t max_depth = (double_t)center.z + (double_t)radius; + if (-camera_data->min_distance < min_depth || -camera_data->max_distance > max_depth) + return 0; + + float_t v5 = vec3::dot(camera_data->field_1E4, center); + if (v5 < -radius) + return 0; + + float_t v6 = vec3::dot(camera_data->field_1F0, center); + if (v6 < -radius) + return 0; + + float_t v7 = vec3::dot(camera_data->field_1FC, center); + if (v7 < -radius) + return 0; + + float_t v8 = vec3::dot(camera_data->field_208, center); + if (v8 < -radius) + return 0; + + if (-camera_data->min_distance >= max_depth && -camera_data->max_distance <= min_depth + && v5 >= radius && v6 >= radius && v7 >= radius && v8 >= radius) + return 1; + return 2; + } + + bool DispManager::entry_obj(::obj* object, obj_mesh_vertex_buffer* obj_vertex_buf, + obj_mesh_index_buffer* obj_index_buf, const mat4* mat, + prj::vector* textures, vec4* blend_color, mat4* bone_mat, ::obj* object_morph, + obj_mesh_vertex_buffer* obj_morph_vertex_buf, int32_t instances_count, mat4* instances_mat, + void(*func)(const ObjSubMeshArgs*), const ObjSubMeshArgs* func_data, + bool enable_bone_mat, bool local) { + if (!obj_vertex_buf || !obj_index_buf) + return false; + + camera_struct::update_data(); + + if (!local && object_culling && !instances_count && !bone_mat && (!object + || !obj_bounding_sphere_check_visibility( + &object->bounding_sphere, &culling, mat))) { + culling.culled.objects++; + return false; + } + culling.passed.objects++; + + for (uint32_t i = 0; i < object->num_mesh; i++) { + obj_mesh* mesh = &object->mesh_array[i]; + obj_mesh* mesh_morph = 0; + if (obj_vertex_buf && obj_morph_vertex_buf) { + if (obj_vertex_buf[i].get_size() != obj_morph_vertex_buf[i].get_size()) + continue; + + if (object_morph && i < object_morph->num_mesh) + mesh_morph = &object_morph->mesh_array[i]; + } + + if (!local && object_culling && !instances_count && !bone_mat + && !obj_bounding_sphere_check_visibility( + &mesh->bounding_sphere, &culling, mat) + && (!mesh_morph || !obj_bounding_sphere_check_visibility( + &mesh_morph->bounding_sphere, &culling, mat))) { + culling.culled.meshes++; + continue; + } + culling.passed.meshes++; + + ObjSubMeshArgs* translucent_priority[40]; + int32_t translucent_priority_count = 0; + + for (uint32_t j = 0; j < mesh->num_submesh; j++) { + obj_sub_mesh* sub_mesh = &mesh->submesh_array[j]; + obj_sub_mesh* sub_mesh_morph = 0; + if (sub_mesh->attrib.m.cloth) + continue; + + if (!local && object_culling && !instances_count && !bone_mat) { + int32_t v32 = obj_bounding_sphere_check_visibility( + &sub_mesh->bounding_sphere, &culling, mat); + if (v32 != 2 || (!mesh->attrib.m.billboard && !mesh->attrib.m.billboard_y_axis)) { + if (v32 == 2) { + if (disp_manager->culling_func) + v32 = 1; + else + v32 = obj_axis_aligned_bounding_box_check_visibility( + sub_mesh->axis_aligned_bounding_box, mat); + } + + if (!v32) { + if (!mesh_morph || j >= mesh_morph->num_submesh) { + culling.culled.submesh_array++; + continue; + } + + sub_mesh_morph = &mesh_morph->submesh_array[j]; + if (!sub_mesh_morph) { + culling.culled.submesh_array++; + continue; + } + + v32 = obj_bounding_sphere_check_visibility( + &sub_mesh_morph->bounding_sphere, &culling, mat); + if (v32 == 2) { + if (disp_manager->culling_func) + v32 = 1; + else + v32 = obj_axis_aligned_bounding_box_check_visibility( + sub_mesh_morph->axis_aligned_bounding_box, mat); + } + + if (!v32) { + culling.culled.submesh_array++; + continue; + } + } + } + } + culling.passed.submesh_array++; + + int32_t num_bone_index = sub_mesh->num_bone_index; + uint16_t* bone_index = sub_mesh->bone_index_array; + + mat4* mats; + if (num_bone_index && enable_bone_mat) { + mats = alloc_mat4_array(num_bone_index); + if (bone_mat) + for (int32_t k = 0; k < num_bone_index; k++, bone_index++) + mats[k] = bone_mat[*bone_index]; + else + for (int32_t k = 0; k < num_bone_index; k++) + mats[k] = mat4_identity; + } + else { + mats = 0; + num_bone_index = 0; + } + + obj_material_data* material = &object->material_array[sub_mesh->material_index]; + ObjData* data = alloc_obj_data(OBJ_KIND_NORMAL); + if (!data) + continue; + + GLuint morph_vertex_buffer = 0; + if (obj_morph_vertex_buf) + morph_vertex_buffer = obj_morph_vertex_buf[i].get_buffer(); + + GLuint index_buffer = 0; + if (obj_index_buf) + index_buffer = obj_index_buf[i].buffer; + + GLuint vertex_buffer = 0; + if (obj_vertex_buf) + vertex_buffer = obj_vertex_buf[i].get_buffer(); + + if (!vertex_buffer || !index_buffer || obj_morph_vertex_buf && !morph_vertex_buffer) + continue; + + vec4 _blend_color = 1.0f; + if (blend_color) + _blend_color = *blend_color; + + data->init_sub_mesh(mat, object->bounding_sphere.radius, sub_mesh, + mesh, material, textures, num_bone_index, mats, vertex_buffer, index_buffer, + &_blend_color, morph_vertex_buffer, instances_count, instances_mat, func, func_data); + + if (obj_flags & mdl::OBJ_SHADOW_OBJECT) { + entry_list((ObjType)(OBJ_TYPE_SHADOW_OBJECT_CHARA + + shadow_type), data); + if (obj_flags & mdl::OBJ_USER) + entry_list(OBJ_TYPE_USER, data); + continue; + } + + obj_material_attrib_member attrib = material->material.attrib.m; + if (obj_flags & (mdl::OBJ_ALPHA_ORDER_1 | mdl::OBJ_ALPHA_ORDER_2 | mdl::OBJ_ALPHA_ORDER_3) + && data->args.sub_mesh.blend_color.w < 1.0f) { + if (!(obj_flags & mdl::OBJ_NO_TRANSLUCENCY)) { + if (attrib.flag_28 || (attrib.punch_through + || !(attrib.alpha_texture | attrib.alpha_material)) + && !sub_mesh->attrib.m.transparent) { + if (!attrib.punch_through) { + if (obj_flags & mdl::OBJ_ALPHA_ORDER_1) + entry_list(OBJ_TYPE_OPAQUE_ALPHA_ORDER_1, data); + else if (obj_flags & mdl::OBJ_ALPHA_ORDER_2) + entry_list(/*local ? OBJ_TYPE_OPAQUE_ALPHA_ORDER_2_LOCAL + : */OBJ_TYPE_OPAQUE_ALPHA_ORDER_2, data); + else + entry_list(OBJ_TYPE_OPAQUE_ALPHA_ORDER_3, data); + } + else { + if (obj_flags & mdl::OBJ_ALPHA_ORDER_1) + entry_list(OBJ_TYPE_TRANSPARENT_ALPHA_ORDER_1, data); + else if (obj_flags & mdl::OBJ_ALPHA_ORDER_2) + entry_list(/*local ? OBJ_TYPE_TRANSPARENT_ALPHA_ORDER_2_LOCAL + : */OBJ_TYPE_TRANSPARENT_ALPHA_ORDER_2, data); + else + entry_list(OBJ_TYPE_TRANSPARENT_ALPHA_ORDER_3, data); + } + + if (obj_flags & mdl::OBJ_SSS) + entry_list(OBJ_TYPE_SSS, data); + } + + if (obj_flags & mdl::OBJ_ALPHA_ORDER_1) + entry_list(OBJ_TYPE_TRANSLUCENT_ALPHA_ORDER_1, data); + else if (obj_flags & mdl::OBJ_ALPHA_ORDER_2) + entry_list(/*local ? OBJ_TYPE_TRANSLUCENT_ALPHA_ORDER_2_LOCAL + : */OBJ_TYPE_TRANSLUCENT_ALPHA_ORDER_2, data); + else + entry_list(OBJ_TYPE_TRANSLUCENT_ALPHA_ORDER_3, data); + } + } + else { + if (attrib.flag_28 || data->args.sub_mesh.blend_color.w >= 1.0f + && (attrib.punch_through || !(attrib.alpha_texture | attrib.alpha_material)) + && !sub_mesh->attrib.m.transparent) { + if (obj_flags & mdl::OBJ_SHADOW) + entry_list((ObjType)(OBJ_TYPE_SHADOW_CHARA + shadow_type), data); + + if (obj_flags & mdl::OBJ_SSS) + entry_list(OBJ_TYPE_SSS, data); + + if (attrib.punch_through) { + if (!(obj_flags & mdl::OBJ_NO_TRANSLUCENCY)) + entry_list(/*local ? OBJ_TYPE_TRANSPARENT_LOCAL + : */OBJ_TYPE_TRANSPARENT, data); + + if (obj_flags & mdl::OBJ_CHARA_REFLECT) + entry_list(OBJ_TYPE_REFLECT_CHARA_OPAQUE, data); + + if (obj_flags & mdl::OBJ_REFLECT) + entry_list(OBJ_TYPE_REFLECT_OPAQUE, data); + + if (obj_flags & mdl::OBJ_REFRACT) + entry_list(OBJ_TYPE_REFRACT_TRANSPARENT, data); + } + else { + if (!(obj_flags & mdl::OBJ_NO_TRANSLUCENCY)) + entry_list(/*local ? OBJ_TYPE_OPAQUE_LOCAL + : */OBJ_TYPE_OPAQUE, data); + + if (obj_flags & mdl::OBJ_20) + entry_list(OBJ_TYPE_TYPE_6, data); + + if (obj_flags & mdl::OBJ_CHARA_REFLECT) + entry_list(OBJ_TYPE_REFLECT_CHARA_OPAQUE, data); + + if (obj_flags & mdl::OBJ_REFLECT) + entry_list(OBJ_TYPE_REFLECT_OPAQUE, data); + + if (obj_flags & mdl::OBJ_REFRACT) + entry_list(OBJ_TYPE_REFRACT_OPAQUE, data); + } + + if (obj_flags & mdl::OBJ_USER) + entry_list(OBJ_TYPE_USER, data); + continue; + } + else if (!(obj_flags & mdl::OBJ_NO_TRANSLUCENCY)) { + if (!attrib.translucent_priority) + /*if (local) + entry_list(OBJ_TYPE_TRANSLUCENT_LOCAL, data); + else */if (mesh->attrib.m.translucent_no_shadow + || obj_flags & mdl::OBJ_TRANSLUCENT_NO_SHADOW) { + entry_list(OBJ_TYPE_TRANSLUCENT_NO_SHADOW, data); + } + else + entry_list(OBJ_TYPE_TRANSLUCENT, data); + else if (translucent_priority_count < 40) + translucent_priority[translucent_priority_count++] = &data->args.sub_mesh; + } + } + + if (obj_flags & mdl::OBJ_SHADOW) + entry_list((ObjType)(OBJ_TYPE_SHADOW_CHARA + + shadow_type), data); + if (obj_flags & mdl::OBJ_40) + entry_list(OBJ_TYPE_TYPE_7, data); + if (obj_flags & mdl::OBJ_CHARA_REFLECT) + entry_list(OBJ_TYPE_REFLECT_CHARA_OPAQUE, data); + if (obj_flags & mdl::OBJ_REFLECT) { + if (render_manager->reflect_type != STAGE_DATA_REFLECT_REFLECT_MAP) + entry_list(OBJ_TYPE_REFLECT_OPAQUE, data); + else + entry_list(OBJ_TYPE_REFLECT_TRANSLUCENT, data); + } + if (obj_flags & mdl::OBJ_REFRACT) + entry_list(OBJ_TYPE_REFRACT_TRANSLUCENT, data); + if (obj_flags & mdl::OBJ_USER) + entry_list(OBJ_TYPE_USER, data); + } + + if (!translucent_priority_count) + continue; + + ObjTranslucentArgs translucent_args; + translucent_args.count = 0; + for (int32_t j = 62; j; j--) + for (int32_t k = 0; k < translucent_priority_count; k++) { + ObjSubMeshArgs* sub_mesh = translucent_priority[k]; + if (sub_mesh->material->material.attrib.m.translucent_priority != j) + continue; + + translucent_args.sub_mesh[translucent_args.count] = sub_mesh; + translucent_args.count++; + } + + ObjData* data = alloc_obj_data(OBJ_KIND_TRANSLUCENT); + if (!data) + continue; + + data->init_translucent(mat, &translucent_args); + if (obj_flags & mdl::OBJ_ALPHA_ORDER_1) + entry_list(OBJ_TYPE_TRANSLUCENT_ALPHA_ORDER_1, data); + else if (obj_flags & mdl::OBJ_ALPHA_ORDER_2) + entry_list(/*local ? OBJ_TYPE_TRANSLUCENT_ALPHA_ORDER_2_LOCAL + : */OBJ_TYPE_TRANSLUCENT_ALPHA_ORDER_2, data); + else if (obj_flags & mdl::OBJ_ALPHA_ORDER_3) + entry_list(OBJ_TYPE_TRANSLUCENT_ALPHA_ORDER_3, data); + else + entry_list(/*local ? OBJ_TYPE_TRANSLUCENT_LOCAL + : */OBJ_TYPE_TRANSLUCENT, data); + } + return true; + } + + void DispManager::entry_obj_by_obj(const mat4* mat, + ::obj* obj, prj::vector* textures, obj_mesh_vertex_buffer* obj_vert_buf, + obj_mesh_index_buffer* obj_index_buf, mat4* bone_mat, float_t alpha) { + if (!obj) + return; + + vec4 blend_color = { 1.0f, 1.0f, 1.0f, alpha }; + vec4* blend_color_ptr = alpha < 1.0f ? &blend_color : 0; + + entry_obj(obj, obj_vert_buf, obj_index_buf, mat, textures, blend_color_ptr, + bone_mat, 0, 0, 0, 0, 0, 0, !!bone_mat); + } + + bool DispManager::entry_obj_by_object_info(const mat4* mat, object_info obj_info, mat4* bone_mat) { + vec4 blend_color = 1.0f; + return entry_obj_by_object_info(mat, obj_info, &blend_color, bone_mat, 0, 0, 0, 0, true); + } + + bool DispManager::entry_obj_by_object_info(const mat4* mat, object_info obj_info, + vec4* blend_color, mat4* bone_mat, int32_t instances_count, mat4* instances_mat, + void(*func)(const ObjSubMeshArgs*), const ObjSubMeshArgs* func_data, + bool enable_bone_mat, bool local) { + if (obj_info.id == -1 && obj_info.set_id == -1) + return false; + + ::obj* object = object_info_get_object(obj_info); + if (!object) + return false; + + prj::vector* textures = obj_database_get_obj_set_textures(obj_info.set_id); + obj_mesh_vertex_buffer* obj_vertex_buffer = object_info_get_mesh_vertex_buffer(obj_info, 0); + obj_mesh_index_buffer* obj_index_buffer = object_info_get_mesh_index_buffer(obj_info, 0); + + ::obj* obj_morph = 0; + obj_mesh_vertex_buffer* obj_morph_vertex_buffer = 0; + if (morph.object.set_id != -1) { + obj_morph = object_info_get_object(morph.object); + obj_morph_vertex_buffer = object_info_get_mesh_vertex_buffer(morph.object, 0); + } + + return entry_obj(object, obj_vertex_buffer, obj_index_buffer, + mat, textures, blend_color, bone_mat, obj_morph, obj_morph_vertex_buffer, + instances_count, instances_mat, func, func_data, enable_bone_mat, local); + } + + bool DispManager::entry_obj_by_object_info(const mat4* mat, + object_info obj_info, float_t alpha, mat4* bone_mat) { + vec4 blend_color = 1.0f; + blend_color.w = alpha; + return entry_obj_by_object_info(mat, obj_info, &blend_color, bone_mat, 0, 0, 0, 0, true); + } + + bool DispManager::entry_obj_by_object_info(const mat4* mat, object_info obj_info, + float_t r, float_t g, float_t b, float_t a, mat4* bone_mat, bool local) { + vec4 blend_color = { r, g, b, a }; + return entry_obj_by_object_info(mat, obj_info, &blend_color, bone_mat, 0, 0, 0, 0, true, local); + } + + bool DispManager::entry_obj_by_object_info(const mat4* mat, object_info obj_info, + vec4* blend_color, mat4* bone_mat, bool local) { + return entry_obj_by_object_info(mat, obj_info, blend_color, 0, 0, 0, 0, 0, false, local); + } + + void DispManager::entry_obj_by_object_info_object_skin(object_info obj_info, + prj::vector* texture_pattern, texture_data_struct* texture_data, float_t alpha, + mat4* matrices, mat4* ex_data_matrices, const mat4* mat, const mat4* global_mat) { + obj_skin* skin = obj_database_get_object_skin(obj_info); + if (!skin) + return; + + if (!*matrix_buffer_init) { + *matrix_buffer_init |= 1u; + mat4* mat = matrix_buffer; + for (int32_t i = 320; i; i--) + *mat++ = mat4_null; + } + + obj_skin_set_matrix_buffer(skin, matrices, ex_data_matrices, matrix_buffer, mat, global_mat); + + vec4 texture_color_coefficients; + vec4 texture_color_offset; + vec4 texture_specular_coefficients; + vec4 texture_specular_offset; + if (texture_data && !texture_data->field_0) { + vec4 value; + get_texture_color_coeff(texture_color_coefficients); + *(vec3*)&value = texture_data->texture_color_coefficients * *(vec3*)&texture_color_coefficients; + value.w = 0.0f; + set_texture_color_coefficients(value); + + get_texture_color_offset(texture_color_offset); + *(vec3*)&value = texture_data->texture_color_offset; + value.w = 0.0f; + set_texture_color_offset(value); + + get_texture_specular_coeff(texture_specular_coefficients); + *(vec3*)&value = texture_data->texture_specular_coefficients * *(vec3*)&texture_specular_coefficients; + value.w = 0.0f; + set_texture_specular_coefficients(value); + + get_texture_specular_offset(texture_specular_offset); + *(vec3*)&value = texture_data->texture_specular_offset; + value.w = 0.0f; + set_texture_specular_offset(value); + } + + size_t texture_pattern_count = texture_pattern ? texture_pattern->size() : 0; + if (texture_pattern && texture_pattern_count) + set_texture_pattern((int32_t)texture_pattern_count, texture_pattern->data()); + + if (fabsf(alpha - 1.0f) > 0.000001f) + entry_obj_by_object_info(global_mat, obj_info, alpha, matrix_buffer); + else + entry_obj_by_object_info(global_mat, obj_info, matrix_buffer); + + if (texture_pattern && texture_pattern_count) + set_texture_pattern(); + + if (texture_data && !texture_data->field_0) { + set_texture_color_coefficients(texture_color_coefficients); + set_texture_color_offset(texture_color_offset); + set_texture_specular_coefficients(texture_specular_coefficients); + set_texture_specular_offset(texture_specular_offset); + } + } + + void DispManager::entry_obj_etc(const mat4* mat, EtcObj* etc, bool local) { + ObjData* data = alloc_obj_data(mdl::OBJ_KIND_ETC); + if (!data) + return; + + data->init_etc(mat, etc); + if (etc->color.a == 0xFF) { + if (!local && (obj_flags & OBJ_SHADOW)) + mdl::DispManager::entry_list((mdl::ObjType)(OBJ_TYPE_SHADOW_CHARA + shadow_type), data); + mdl::DispManager::entry_list(/*local ? OBJ_TYPE_OPAQUE_LOCAL : */OBJ_TYPE_OPAQUE, data); + } + else + mdl::DispManager::entry_list(/*local ? OBJ_TYPE_TRANSLUCENT_LOCAL : */OBJ_TYPE_TRANSLUCENT, data); + } + + void DispManager::entry_obj_user(const mat4* mat, UserArgsFunc func, void* data, ObjType type) { + ObjData* _data = alloc_obj_data(OBJ_KIND_USER); + if (_data) { + _data->init_user(mat, func, data); + entry_list(type, _data); + } + } + + GLuint DispManager::get_vertex_array(const ObjSubMeshArgs* args) { + const obj_mesh* mesh = args->mesh; + const obj_sub_mesh* sub_mesh = args->sub_mesh; + const obj_material_data* material = args->material; + + GLuint vertex_buffer = args->vertex_buffer; + GLuint morph_vertex_buffer = args->morph_vertex_buffer; + GLuint index_buffer = args->index_buffer; + + int32_t texcoord_array[2] = { -1, -1 }; + int32_t color_tex_index = 0; + for (const obj_material_texture_data& i : material->material.texdata) { + if (i.tex_index == -1) + continue; + + int32_t texcoord_index = obj_material_texture_type_get_texcoord_index( + i.shader_info.m.tex_type, color_tex_index); + if (texcoord_index < 0) + continue; + + texcoord_array[texcoord_index] = sub_mesh->uv_index[&i - material->material.texdata]; + + if (i.shader_info.m.tex_type == OBJ_MATERIAL_TEXTURE_COLOR) + color_tex_index++; + } + + GLuint vertex_attrib_buffer_binding[16] = {}; + object_data_get_vertex_attrib_buffer_bindings(args, + texcoord_array, vertex_attrib_buffer_binding); + + GLsizei size_vertex = (GLsizei)mesh->size_vertex; + obj_vertex_format vertex_format = mesh->vertex_format; + + for (DispManager::vertex_array& i : vertex_array_cache) + if (i.alive_time > 0 && i.vertex_buffer == vertex_buffer + && i.morph_vertex_buffer == morph_vertex_buffer + && i.index_buffer == index_buffer && i.vertex_format == vertex_format + && i.size_vertex == size_vertex + && !memcmp(i.vertex_attrib_buffer_binding, + vertex_attrib_buffer_binding, sizeof(vertex_attrib_buffer_binding)) + && !memcmp(i.texcoord_array, texcoord_array, sizeof(texcoord_array))) + return i.vertex_array; + return 0; + } + + GLuint DispManager::get_vertex_array(const mdl::EtcObj* etc) { + EtcObjType type = etc->type; + float_t length = 0; + switch (type) { + case mdl::ETC_OBJ_TEAPOT: + case mdl::ETC_OBJ_GRID: + case mdl::ETC_OBJ_CUBE: + case mdl::ETC_OBJ_SPHERE: + case mdl::ETC_OBJ_PLANE: + case mdl::ETC_OBJ_CONE: + case mdl::ETC_OBJ_LINE: + case mdl::ETC_OBJ_CROSS: + break; + default: + return 0; + } + + for (DispManager::etc_vertex_array& i : etc_vertex_array_cache) { + if (i.alive_time <= 0 || i.type != type) + continue; + + switch (type) { + case mdl::ETC_OBJ_TEAPOT: + return i.vertex_array; + case mdl::ETC_OBJ_GRID: + if (!memcmp(&i.data.grid, &etc->data.grid, sizeof(EtcObjGrid))) + return i.vertex_array; + break; + case mdl::ETC_OBJ_CUBE: + return i.vertex_array; + case mdl::ETC_OBJ_SPHERE: + if (i.data.sphere.slices == etc->data.sphere.slices + && i.data.sphere.stacks == etc->data.sphere.stacks + && fabsf(i.data.sphere.radius - etc->data.sphere.radius) < 0.00001f) + return i.vertex_array; + break; + case mdl::ETC_OBJ_PLANE: + return i.vertex_array; + case mdl::ETC_OBJ_CONE: + if (i.data.cone.slices == etc->data.cone.slices + && i.data.cone.stacks == etc->data.cone.stacks + && fabsf(i.data.cone.base - etc->data.cone.base) < 0.00001f + && fabsf(i.data.cone.height - etc->data.cone.height) < 0.00001f) + return i.vertex_array; + break; + case mdl::ETC_OBJ_LINE: + return i.vertex_array; + case mdl::ETC_OBJ_CROSS: + return i.vertex_array; + } + } + return 0; + } + + bool DispManager::get_chara_color() { + return chara_color; + } + + ObjFlags DispManager::get_obj_flags() { + return obj_flags; + } + + void DispManager::get_morph(object_info& object, float_t& weight) { + weight = morph.weight; + object = morph.object; + } + + int32_t DispManager::get_obj_count(ObjType type) { + return (int32_t)obj[type].size(); + } + + shadow_type_enum DispManager::get_shadow_type() { + return shadow_type; + } + + void DispManager::get_texture_color_coeff(vec4& value) { + value = texture_color_coefficients; + } + + void DispManager::get_texture_color_offset(vec4& value) { + value = texture_color_offset; + } + + void DispManager::get_texture_pattern(int32_t& count, texture_pattern_struct*& value) { + count = texture_pattern_count; + + for (int32_t i = 0; i < count; i++) + value[i] = texture_pattern_array[i]; + } + + void DispManager::get_texture_specular_coeff(vec4& value) { + value = texture_specular_coefficients; + } + + void DispManager::get_texture_specular_offset(vec4& value) { + value = texture_specular_offset; + } + + void DispManager::get_texture_transform(int32_t& count, texture_transform_struct*& value) { + count = texture_transform_count; + + for (int32_t i = 0; i < count; i++) + value[i] = texture_transform_array[i]; + } + + float_t DispManager::get_wet_param() { + return wet_param; + } + + void DispManager::obj_sort(mat4* view, ObjType type, int32_t compare_func) { + prj::list& list = obj[type]; + if (list.size() < 1) + return; + + for (ObjData*& i : list) { + vec3 center; + mat4_get_translation(&i->mat, ¢er); + if (i->kind == OBJ_KIND_NORMAL) { + mat4 mat = i->mat; + if (i->args.sub_mesh.mesh->attrib.m.billboard) + model_mat_face_camera_view(view, &mat, &mat); + else if (i->args.sub_mesh.mesh->attrib.m.billboard_y_axis) + model_mat_face_camera_position(view, &mat, &mat); + + const obj_sub_mesh* sub_mesh = i->args.sub_mesh.sub_mesh; + if (i->args.sub_mesh.mat_count < 1 || !sub_mesh->num_bone_index) + mat4_transform_point(&mat, &sub_mesh->bounding_sphere.center, ¢er); + else { + vec3 center_sum = 0.0f; + for (uint32_t j = 0; j < sub_mesh->num_bone_index; j++) { + center = sub_mesh->bounding_sphere.center; + mat4_transform_point(&i->args.sub_mesh.mats[j], ¢er, ¢er); + center_sum += center; + } + center_sum *= 1.0f / (float_t)sub_mesh->num_bone_index; + } + i->radius = i->args.sub_mesh.mesh->bounding_sphere.radius; + } + + mat4_transform_point(view, ¢er, ¢er); + i->view_z = center.z; + } + + switch (compare_func) { + case 0: + list.sort([](ObjData* left, ObjData* right) { + return left->view_z > right->view_z; + }); + break; + case 1: + list.sort([](ObjData* left, ObjData* right) { + return left->view_z < right->view_z; + }); + break; + case 2: + list.sort([](ObjData* left, ObjData* right) { + return left->radius > right->radius; + }); + break; + } + } + + void DispManager::refresh() { + culling.passed_prev = culling.passed; + culling.culled_prev = culling.culled; + culling.passed = {}; + culling.culled = {}; + + obj_flags = (::mdl::ObjFlags)0; + field_8 = 0; + field_C = 0; + + texture_pattern_count = 0; + memset(texture_pattern_array, 0, sizeof(texture_pattern_array)); + texture_transform_count = 0; + memset(texture_transform_array, 0, sizeof(texture_transform_array)); + texture_color_coefficients = 1.0f; + texture_color_offset = 0.0f; + texture_specular_coefficients = 1.0f; + texture_specular_offset = 0.0f; + + for (prj::list& i : obj) + i.clear(); + + buffer_reset(); + } + + void DispManager::set_chara_color(bool value) { + chara_color = value; + } + + void DispManager::set_culling_finc(bool(FASTCALL* func)(obj_bounding_sphere*)) { + culling_func = func; + } + + void DispManager::set_obj_flags(ObjFlags flags) { + obj_flags = flags; + } + + void DispManager::set_morph(object_info object, float_t weight) { + morph.weight = weight; + morph.object = object; + } + + void DispManager::set_shadow_type(shadow_type_enum type) { + if (type == SHADOW_CHARA || type == SHADOW_STAGE) + shadow_type = type; + } + + void DispManager::set_texture_color_coefficients(vec4& value) { + texture_color_coefficients = value; + } + + void DispManager::set_texture_color_offset(vec4& value) { + texture_color_offset = value; + } + + void DispManager::set_texture_pattern(int32_t count, texture_pattern_struct* value) { + if (count > TEXTURE_PATTERN_COUNT) + return; + + texture_pattern_count = count; + + if (count) + for (int32_t i = 0; i < count; i++) + texture_pattern_array[i] = value[i]; + else + for (int32_t i = 0; i < TEXTURE_PATTERN_COUNT; i++) + texture_pattern_array[i] = {}; + } + + void DispManager::set_texture_specular_coefficients(vec4& value) { + texture_specular_coefficients = value; + } + + void DispManager::set_texture_specular_offset(vec4& value) { + texture_specular_offset = value; + } + + void DispManager::set_texture_transform(int32_t count, texture_transform_struct* value) { + if (count > TEXTURE_TRANSFORM_COUNT) + return; + + texture_transform_count = count; + + if (count) + for (int32_t i = 0; i < count; i++) + texture_transform_array[i] = value[i]; + else + for (int32_t i = count; i < TEXTURE_TRANSFORM_COUNT; i++) + texture_transform_array[i] = {}; + } + + void DispManager::set_wet_param(float_t value) { + wet_param = value; + } + + static const mat4* rob_chara_item_equip_mat = 0; + + HOOK(void, FASTCALL, DispManager__entry_obj, 0x00000001404379E0, + obj* obj_data, obj_mesh_vertex_buffer* obj_vert_buf, obj_mesh_index_buffer* obj_index_buf, + prj::vector* textures, vec4* blend_color, mat4* bone_mat, obj* obj_morph, + obj_mesh_vertex_buffer* obj_morph_vert_buf, float_t morph_value, + int32_t instances_count, mat4* instances_mat, obj_mesh_vertex_buffer* a12, int32_t* a13, + void(FASTCALL* func)(const mdl::ObjSubMeshArgs*), const mdl::ObjSubMeshArgs* func_data, bool enable_bone_mat) { + abort(); + } + + HOOK(void, FASTCALL, DispManager__entry_obj_by_obj, 0x0000000140439A20, obj* obj_data, prj::vector* textures, + obj_mesh_vertex_buffer* obj_vert_buf, obj_mesh_index_buffer* obj_index_buf, mat4* bone_mat, float_t alpha) { + if (!obj_data) + return; + + vec4 blend_color = 1.0f; + blend_color.w = alpha; + + vec4* blend_color_ptr = alpha < 1.0f ? &blend_color : 0; + disp_manager->entry_obj(obj_data, obj_vert_buf, obj_index_buf, rob_chara_item_equip_mat, + textures, blend_color_ptr, bone_mat, 0, 0, 0, 0, 0, 0, 0, !!bone_mat); + } + + HOOK(void, FASTCALL, DispManager__entry_obj_by_object_info_object_skin, 0x00000001405E8E20, + object_info obj_info, prj::vector* texture_pattern, + texture_data_struct* texture_data, float_t alpha, mat4* matrices, mat4* ex_data_matrices, mat4* mat) { + disp_manager->entry_obj_by_object_info_object_skin(obj_info, texture_pattern, texture_data, + alpha, matrices, ex_data_matrices, mat, rob_chara_item_equip_mat); + } + + void disp_manager_patch() { + WRITE_NOP_6(0x0000000140542019); + WRITE_NOP_6(0x000000014054204F); + WRITE_NOP_6(0x000000014054208E); + + uint8_t buf[0x1B] = {}; + buf[0x00] = 0x48; + buf[0x01] = 0x8D; + buf[0x02] = 0x8F; + buf[0x03] = 0xFC; + buf[0x04] = 0x00; + buf[0x05] = 0x00; + buf[0x06] = 0x00; + buf[0x07] = 0x48; + buf[0x08] = 0xB8; + *(uint64_t*)&buf[0x09] = (uint64_t)&rob_chara_item_equip_mat; + buf[0x11] = 0x48; + buf[0x12] = 0x89; + buf[0x13] = 0x08; + buf[0x14] = 0x0F; + buf[0x15] = 0x1F; + buf[0x16] = 0x80; + buf[0x17] = 0x00; + buf[0x18] = 0x00; + buf[0x19] = 0x00; + buf[0x1A] = 0x00; + WRITE_MEMORY_STRING(0x0000000140512A82, buf, sizeof(buf)); + + WRITE_NOP_6(0x0000000140512BE6); + + INSTALL_HOOK(DispManager__entry_obj); + INSTALL_HOOK(DispManager__entry_obj_by_obj); + INSTALL_HOOK(DispManager__entry_obj_by_object_info_object_skin); + } +} + +static void object_data_get_vertex_attrib_buffer_bindings(const mdl::ObjSubMeshArgs* args, + int32_t texcoord_array[2], GLuint vertex_attrib_buffer_binding[16]) { + const obj_mesh* mesh = args->mesh; + const obj_sub_mesh* sub_mesh = args->sub_mesh; + + GLuint vertex_buffer = args->vertex_buffer; + GLuint morph_vertex_buffer = args->morph_vertex_buffer; + + GLsizei size_vertex = (GLsizei)mesh->size_vertex; + obj_vertex_format vertex_format = mesh->vertex_format; + + if (vertex_format & OBJ_VERTEX_POSITION) + vertex_attrib_buffer_binding[POSITION_INDEX] = vertex_buffer; + if (vertex_format & OBJ_VERTEX_NORMAL) + vertex_attrib_buffer_binding[NORMAL_INDEX] = vertex_buffer; + if (vertex_format & OBJ_VERTEX_TANGENT) + vertex_attrib_buffer_binding[TANGENT_INDEX] = vertex_buffer; + + for (int32_t i = 0; i < 2; i++) { + int32_t texcoord_index = texcoord_array[i]; + if (texcoord_index >= 0) + if (vertex_format & (OBJ_VERTEX_TEXCOORD0 << texcoord_index)) + vertex_attrib_buffer_binding[TEXCOORD0_INDEX + i] = vertex_buffer; + } + + if (vertex_format & OBJ_VERTEX_COLOR0) + vertex_attrib_buffer_binding[COLOR0_INDEX] = vertex_buffer; + + if ((vertex_format & OBJ_VERTEX_BONE_DATA) == OBJ_VERTEX_BONE_DATA) { + vertex_attrib_buffer_binding[BONE_WEIGHT_INDEX] = vertex_buffer; + vertex_attrib_buffer_binding[BONE_INDEX_INDEX] = vertex_buffer; + } + + if (vertex_format & OBJ_VERTEX_UNKNOWN) + vertex_attrib_buffer_binding[UNKNOWN_INDEX] = vertex_buffer; + + if (args->morph_vertex_buffer) { + if (vertex_format & OBJ_VERTEX_POSITION) + vertex_attrib_buffer_binding[MORPH_POSITION_INDEX] = morph_vertex_buffer; + if (vertex_format & OBJ_VERTEX_NORMAL) + vertex_attrib_buffer_binding[MORPH_NORMAL_INDEX] = morph_vertex_buffer; + if (vertex_format & OBJ_VERTEX_TANGENT) + vertex_attrib_buffer_binding[MORPH_TANGENT_INDEX] = morph_vertex_buffer; + if (vertex_format & OBJ_VERTEX_TEXCOORD0) + vertex_attrib_buffer_binding[MORPH_TEXCOORD0_INDEX] = morph_vertex_buffer; + if (vertex_format & OBJ_VERTEX_TEXCOORD1) + vertex_attrib_buffer_binding[MORPH_TEXCOORD1_INDEX] = morph_vertex_buffer; + if (vertex_format & OBJ_VERTEX_COLOR0) + vertex_attrib_buffer_binding[MORPH_COLOR_INDEX] = morph_vertex_buffer; + } +} diff --git a/src/DivaGL/mdl/disp_manager.hpp b/src/DivaGL/mdl/disp_manager.hpp new file mode 100644 index 0000000..641ada5 --- /dev/null +++ b/src/DivaGL/mdl/disp_manager.hpp @@ -0,0 +1,449 @@ +/* + by korenkonder + GitHub/GitLab: korenkonder +*/ + +#pragma once + +#include "../../KKdLib/default.hpp" +#include "../../KKdLib/mat.hpp" +#include "../../KKdLib/vec.hpp" +#include "../gl_array_buffer.hpp" +#include "../gl_element_array_buffer.hpp" +#include "../color.hpp" +#include "../object.hpp" +#include "../shadow.hpp" + +#define TEXTURE_PATTERN_COUNT 24 +#define TEXTURE_TRANSFORM_COUNT 24 + +namespace mdl { + enum EtcObjType { + ETC_OBJ_TEAPOT = 0, + ETC_OBJ_GRID, + ETC_OBJ_CUBE, + ETC_OBJ_SPHERE, + ETC_OBJ_PLANE, + ETC_OBJ_CONE, + ETC_OBJ_LINE, + ETC_OBJ_CROSS, + ETC_OBJ_MAX, + }; + + enum ObjKind { + OBJ_KIND_NORMAL = 0, + OBJ_KIND_ETC, + OBJ_KIND_USER, + OBJ_KIND_TRANSLUCENT, + OBJ_KIND_MAX, + }; + + enum ObjFlags : uint32_t { + OBJ_SHADOW = 0x00000001, + OBJ_2 = 0x00000002, + OBJ_4 = 0x00000004, + OBJ_8 = 0x00000008, + OBJ_10 = 0x00000010, + OBJ_20 = 0x00000020, + OBJ_40 = 0x00000040, + OBJ_SHADOW_OBJECT = 0x00000080, + OBJ_CHARA_REFLECT = 0x00000100, + OBJ_REFLECT = 0x00000200, + OBJ_REFRACT = 0x00000400, + OBJ_800 = 0x00000800, + OBJ_TRANSLUCENT_NO_SHADOW = 0x00001000, + OBJ_SSS = 0x00002000, + OBJ_4000 = 0x00004000, + OBJ_8000 = 0x00008000, + OBJ_ALPHA_ORDER_1 = 0x00010000, + OBJ_ALPHA_ORDER_2 = 0x00020000, + OBJ_ALPHA_ORDER_3 = 0x00040000, + OBJ_80000 = 0x00080000, + OBJ_100000 = 0x00100000, + OBJ_200000 = 0x00200000, + OBJ_400000 = 0x00400000, + OBJ_800000 = 0x00800000, + OBJ_USER = 0x01000000, + OBJ_2000000 = 0x02000000, + OBJ_4000000 = 0x04000000, + OBJ_8000000 = 0x08000000, + OBJ_10000000 = 0x10000000, + OBJ_20000000 = 0x20000000, + OBJ_40000000 = 0x40000000, + OBJ_NO_TRANSLUCENCY = 0x80000000, + }; + + enum ObjType { + OBJ_TYPE_OPAQUE = 0, + OBJ_TYPE_TRANSLUCENT, + OBJ_TYPE_TRANSLUCENT_NO_SHADOW, + OBJ_TYPE_TRANSPARENT, + OBJ_TYPE_SHADOW_CHARA, + OBJ_TYPE_SHADOW_STAGE, + OBJ_TYPE_TYPE_6, + OBJ_TYPE_TYPE_7, + OBJ_TYPE_SHADOW_OBJECT_CHARA, + OBJ_TYPE_SHADOW_OBJECT_STAGE, + OBJ_TYPE_REFLECT_CHARA_OPAQUE, + OBJ_TYPE_REFLECT_CHARA_TRANSLUCENT, + OBJ_TYPE_REFLECT_CHARA_TRANSPARENT, + OBJ_TYPE_REFLECT_OPAQUE, + OBJ_TYPE_REFLECT_TRANSLUCENT, + OBJ_TYPE_REFLECT_TRANSPARENT, + OBJ_TYPE_REFRACT_OPAQUE, + OBJ_TYPE_REFRACT_TRANSLUCENT, + OBJ_TYPE_REFRACT_TRANSPARENT, + OBJ_TYPE_SSS, + OBJ_TYPE_OPAQUE_ALPHA_ORDER_1, + OBJ_TYPE_TRANSPARENT_ALPHA_ORDER_1, + OBJ_TYPE_TRANSLUCENT_ALPHA_ORDER_1, + OBJ_TYPE_OPAQUE_ALPHA_ORDER_2, + OBJ_TYPE_TRANSPARENT_ALPHA_ORDER_2, + OBJ_TYPE_TRANSLUCENT_ALPHA_ORDER_2, + OBJ_TYPE_OPAQUE_ALPHA_ORDER_3, + OBJ_TYPE_TRANSPARENT_ALPHA_ORDER_3, + OBJ_TYPE_TRANSLUCENT_ALPHA_ORDER_3, + OBJ_TYPE_USER, + OBJ_TYPE_MAX, + }; +} + +struct morph_struct { + object_info object; + float_t weight; +}; + +static_assert(sizeof(morph_struct) == 0x08, "\"morph_struct\" struct should have a size of 0x08"); + +struct texture_pattern_struct { + uint32_t src; + uint32_t dst; +}; + +static_assert(sizeof(texture_pattern_struct) == 0x08, "\"texture_pattern_struct\" struct should have a size of 0x08"); + +struct texture_transform_struct { + uint32_t id; + mat4 mat; +}; + +static_assert(sizeof(texture_transform_struct) == 0x44, "\"texture_pattern_struct\" struct should have a size of 0x44"); + +struct texture_data_struct { + int32_t field_0; + vec3 texture_color_coefficients; + vec3 texture_color_offset; + vec3 texture_specular_coefficients; + vec3 texture_specular_offset; +}; + +static_assert(sizeof(texture_data_struct) == 0x34, "\"texture_pattern_struct\" struct should have a size of 0x34"); + +namespace mdl { + struct ObjSubMeshArgs { + obj_sub_mesh* sub_mesh; + obj_mesh* mesh; + obj_material_data* material; + prj::vector* textures; + int32_t mat_count; + mat4* mats; + GLuint vertex_buffer; + GLuint index_buffer; + bool set_blend_color; + bool chara_color; + vec4 blend_color; + int32_t self_shadow; + shadow_type_enum shadow; + GLuint morph_vertex_buffer; + float_t morph_weight; + int32_t texture_pattern_count; + texture_pattern_struct texture_pattern_array[TEXTURE_PATTERN_COUNT]; + vec4 texture_color_coefficients; + vec4 texture_color_offset; + vec4 texture_specular_coefficients; + vec4 texture_specular_offset; + int32_t texture_transform_count; + texture_transform_struct texture_transform_array[TEXTURE_TRANSFORM_COUNT]; + int32_t field_7C4; + int32_t field_7C8; + int32_t instances_count; + mat4* instances_mat; + void(FASTCALL* func)(const ObjSubMeshArgs*); + const ObjSubMeshArgs* func_data; + }; + + static_assert(sizeof(mdl::ObjSubMeshArgs) == 0x7E8, "\"mdl::ObjSubMeshArgs\" struct should have a size of 0x7F8"); + + struct EtcObjTeapot { + float_t size; + }; + + static_assert(sizeof(mdl::EtcObjTeapot) == 0x04, "\"mdl::EtcObjTeapot\" struct should have a size of 0x04"); + + struct EtcObjGrid { + int32_t w; + int32_t h; + int32_t ws; + int32_t hs; + }; + + static_assert(sizeof(mdl::EtcObjGrid) == 0x10, "\"mdl::EtcObjGrid\" struct should have a size of 0x10"); + + struct EtcObjCube { + vec3 size; + bool wire; + }; + + static_assert(sizeof(mdl::EtcObjCube) == 0x10, "\"mdl::EtcObjCube\" struct should have a size of 0x10"); + + struct EtcObjSphere { + float_t radius; + int32_t slices; + int32_t stacks; + bool wire; + }; + + static_assert(sizeof(mdl::EtcObjSphere) == 0x10, "\"mdl::EtcObjSphere\" struct should have a size of 0x10"); + + struct EtcObjPlane { + int32_t w; + int32_t h; + }; + + static_assert(sizeof(mdl::EtcObjPlane) == 0x08, "\"mdl::EtcObjPlane\" struct should have a size of 0x08"); + + struct EtcObjCone { + float_t base; + float_t height; + int32_t slices; + int32_t stacks; + bool wire; + }; + + static_assert(sizeof(mdl::EtcObjCone) == 0x14, "\"mdl::EtcObjCone\" struct should have a size of 0x14"); + + struct EtcObjLine { + vec3 pos[2]; + }; + + static_assert(sizeof(mdl::EtcObjLine) == 0x18, "\"mdl::EtcObjLine\" struct should have a size of 0x18"); + + struct EtcObjCross { + float_t size; + }; + + static_assert(sizeof(mdl::EtcObjCross) == 0x04, "\"mdl::EtcObjCross\" struct should have a size of 0x04"); + + struct EtcObj { + union Data { + EtcObjTeapot teapot; + EtcObjGrid grid; + EtcObjCube cube; + EtcObjSphere sphere; + EtcObjPlane plane; + EtcObjCone cone; + EtcObjLine line; + EtcObjCross cross; + }; + + EtcObjType type; + color4u8_bgra color; + bool fog; + Data data; + GLsizei count; // Added + size_t offset; // Added + + void init(EtcObjType type); + }; + + static_assert(sizeof(mdl::EtcObj) == 0x30, "\"mdl::EtcObj\" struct should have a size of 0x30"); + + typedef void(*UserArgsFunc)(void* data); + + struct UserArgs { + UserArgsFunc func; + void* data; + }; + + static_assert(sizeof(mdl::UserArgs) == 0x10, "\"mdl::UserArgs\" struct should have a size of 0x10"); + + struct ObjTranslucentArgs { + uint32_t count; + ObjSubMeshArgs* sub_mesh[40]; + }; + + static_assert(sizeof(mdl::ObjTranslucentArgs) == 0x148, "\"mdl::ObjTranslucentArgs\" struct should have a size of 0x148"); + + struct ObjData { + union Args { + ObjSubMeshArgs sub_mesh; + EtcObj etc; + UserArgs user; + ObjTranslucentArgs translucent; + }; + + ObjKind kind; + mat4 mat; + float_t view_z; + float_t radius; + Args args; + + void init_etc(const mat4* mat, mdl::EtcObj* etc); + void init_sub_mesh(const mat4* mat, + float_t radius, obj_sub_mesh* sub_mesh, obj_mesh* mesh, obj_material_data* material, + prj::vector* textures, int32_t mat_count, mat4* mats, GLuint vertex_buffer, + GLuint index_buffer, vec4* blend_color, GLuint morph_vertex_buffer, + int32_t instances_count, mat4* instances_mat, + void(FASTCALL* func)(const ObjSubMeshArgs*), const ObjSubMeshArgs* func_data); + void init_translucent(const mat4* mat, ObjTranslucentArgs* translucent); + void init_user(const mat4* mat, UserArgsFunc func, void* data); + }; + + static_assert(sizeof(mdl::ObjData) == 0x838, "\"mdl::ObjData\" struct should have a size of 0x838"); + + struct CullingCheck { + struct Info { + int32_t objects; + int32_t meshes; + int32_t submesh_array; + int pad; + }; + + static_assert(sizeof(mdl::CullingCheck::Info) == 0x10, "\"mdl::CullingCheck::Info\" struct should have a size of 0x10"); + + Info passed; + Info culled; + Info passed_prev; + Info culled_prev; + }; + + static_assert(sizeof(mdl::CullingCheck) == 0x40, "\"mdl::CullingCheck\" struct should have a size of 0x40"); + + struct DispManager { + struct vertex_array { + GLuint vertex_buffer; + GLuint morph_vertex_buffer; + GLuint index_buffer; + int32_t alive_time; + GLuint vertex_array; + bool vertex_attrib_array[16]; + obj_vertex_format vertex_format; + GLsizei size_vertex; + bool compressed; + GLuint vertex_attrib_buffer_binding[16]; + int32_t texcoord_array[2]; + }; + + struct etc_vertex_array { + GLArrayBuffer vertex_buffer; + GLElementArrayBuffer index_buffer; + int32_t alive_time; + GLuint vertex_array; + EtcObj::Data data; + EtcObjType type; + GLsizei count; + size_t offset; + GLsizei wire_count; + size_t wire_offset; + size_t max_vtx; + size_t max_idx; + }; + + mdl::ObjFlags obj_flags; + shadow_type_enum shadow_type; + int32_t field_8; + int32_t field_C; + prj::list obj[mdl::OBJ_TYPE_MAX]; + mdl::CullingCheck culling; + int32_t put_index; + bool show_alpha_center; + bool show_mat_center; + bool object_culling; + bool object_sort; + bool chara_color; + int32_t buff_offset; + int32_t buff_max; + int32_t buff_size; + size_t buff; + morph_struct morph; + int32_t texture_pattern_count; + texture_pattern_struct texture_pattern_array[TEXTURE_PATTERN_COUNT]; + vec4 texture_color_coefficients; + vec4 texture_color_offset; + vec4 texture_specular_coefficients; + vec4 texture_specular_offset; + float_t wet_param; + int32_t texture_transform_count; + texture_transform_struct texture_transform_array[TEXTURE_TRANSFORM_COUNT]; + bool(FASTCALL* culling_func)(obj_bounding_sphere*); + + void add_vertex_array(ObjSubMeshArgs* args); + void add_vertex_array(EtcObj* etc, mat4& mat); + void* alloc_data(int32_t size); + ObjData* alloc_obj_data(ObjKind kind); + mat4* alloc_mat4_array(int32_t count); + void buffer_reset(); + void check_vertex_arrays(); + void draw(mdl::ObjType type, int32_t depth_mask = 0, bool a4 = true); + void draw_translucent(mdl::ObjType type, int32_t alpha); + /*void draw_show_vector(mdl::ObjType type, int32_t show_vector);*/ + void entry_list(ObjType type, ObjData* data); + bool entry_obj(::obj* object, obj_mesh_vertex_buffer* obj_vertex_buf, + obj_mesh_index_buffer* obj_index_buf, const mat4* mat, + prj::vector* textures, vec4* blend_color, mat4* bone_mat, ::obj* object_morph, + obj_mesh_vertex_buffer* obj_morph_vertex_buf, int32_t instances_count, mat4* instances_mat, + void(*func)(const mdl::ObjSubMeshArgs*), const ObjSubMeshArgs* func_data, + bool enable_bone_mat, bool local = false); + void entry_obj_by_obj(const mat4* mat, + ::obj* obj, prj::vector* textures, obj_mesh_vertex_buffer* obj_vert_buf, + obj_mesh_index_buffer* obj_index_buf, mat4* bone_mat, float_t alpha); + bool entry_obj_by_object_info(const mat4* mat, object_info obj_info, mat4* bone_mat = 0); + bool entry_obj_by_object_info(const mat4* mat, object_info obj_info, + vec4* blend_color, mat4* bone_mat, int32_t instances_count, mat4* instances_mat, + void(*func)(const ObjSubMeshArgs*), const ObjSubMeshArgs* func_data, bool enable_bone_mat, bool local = false); + bool entry_obj_by_object_info(const mat4* mat, object_info obj_info, float_t alpha, mat4* bone_mat = 0); + bool entry_obj_by_object_info(const mat4* mat, object_info obj_info, + float_t r, float_t g, float_t b, float_t a, mat4* bone_mat = 0, bool local = false); + bool entry_obj_by_object_info(const mat4* mat, object_info obj_info, + vec4* blend_color, mat4* bone_mat = 0, bool local = false); + void entry_obj_by_object_info_object_skin(object_info obj_info, + prj::vector* texture_pattern, texture_data_struct* texture_data, float_t alpha, + mat4* matrices, mat4* ex_data_matrices, const mat4* mat, const mat4* global_mat); + void entry_obj_etc(const mat4* mat, EtcObj* etc, bool local = false); + void entry_obj_user(const mat4* mat, UserArgsFunc func, void* data, ObjType type); + GLuint get_vertex_array(const ObjSubMeshArgs* args); + GLuint get_vertex_array(const mdl::EtcObj* etc); + bool get_chara_color(); + ObjFlags get_obj_flags(); + void get_morph(object_info& object, float_t& weight); + int32_t get_obj_count(ObjType type); + shadow_type_enum get_shadow_type(); + void get_texture_color_coeff(vec4& value); + void get_texture_color_offset(vec4& value); + void get_texture_pattern(int32_t& count, texture_pattern_struct*& value); + void get_texture_specular_coeff(vec4& value); + void get_texture_specular_offset(vec4& value); + void get_texture_transform(int32_t& count, texture_transform_struct*& value); + float_t get_wet_param(); + void obj_sort(mat4* view, ObjType type, int32_t compare_func); + void refresh(); + void set_chara_color(bool value = false); + void set_culling_finc(bool(FASTCALL* func)(obj_bounding_sphere*) = 0); + void set_obj_flags(ObjFlags flags = (ObjFlags)0); + void set_morph(object_info object = {}, float_t weight = 0.0f); + void set_shadow_type(shadow_type_enum type = SHADOW_CHARA); + void set_texture_color_coefficients(vec4& value); + void set_texture_color_offset(vec4& value); + void set_texture_pattern(int32_t count = 0, texture_pattern_struct* value = 0); + void set_texture_specular_coefficients(vec4& value); + void set_texture_specular_offset(vec4& value); + void set_texture_transform(int32_t count = 0, texture_transform_struct* value = 0); + void set_wet_param(float_t value = 0.0f); + }; + + static_assert(sizeof(mdl::DispManager) == 0x9D0, "\"mdl::DispManager\" struct should have a size of 0x9D0"); + + extern void disp_manager_patch(); +} + +extern mdl::DispManager* disp_manager; diff --git a/src/DivaGL/mdl/draw_object.cpp b/src/DivaGL/mdl/draw_object.cpp new file mode 100644 index 0000000..c9101e2 --- /dev/null +++ b/src/DivaGL/mdl/draw_object.cpp @@ -0,0 +1,1145 @@ +/* + by korenkonder + GitHub/GitLab: korenkonder +*/ + +#include "draw_object.hpp" +#include "../light_param/light.hpp" +#include "../shader_glsl_ft.hpp" +#include "../texture.hpp" + +static bool draw_object_blend_set( + const mdl::ObjSubMeshArgs* args, obj_material_shader_lighting_type lighting_type); +static bool draw_object_blend_set_check_use_default_blend(int32_t index); +static void draw_object_chara_color_fog_set( + const mdl::ObjSubMeshArgs* args, bool disable_fog); +static void draw_object_material_reset_default(const obj_material_data* mat_data); +static void draw_object_material_reset_reflect(); +static void draw_object_material_set_default( + const mdl::ObjSubMeshArgs* args, bool use_shader); +static void draw_object_material_set_parameter( + const obj_material_data* mat_data); +static void draw_object_material_set_reflect(const mdl::ObjSubMeshArgs* args); +static void draw_object_material_set_uniform(const obj_material_data* mat_data, bool disable_color_l); +static void draw_object_vertex_attrib_reset_default(const mdl::ObjSubMeshArgs* args); +static void draw_object_vertex_attrib_reset_reflect(const mdl::ObjSubMeshArgs* args); +static void draw_object_vertex_attrib_set_default(const mdl::ObjSubMeshArgs* args); +static void draw_object_vertex_attrib_set_reflect(const mdl::ObjSubMeshArgs* args); + +static bool(FASTCALL* use_shader_get)() = (bool(FASTCALL*)())0x0000000140440E30; + +namespace mdl { + void draw(obj_primitive_type primitive_type, uint32_t count, + uint16_t start, uint16_t end, obj_index_format index_format, size_t indices) { + GLenum mesh_draw_mode[] = { + GL_ZERO, //GL_POINTS, + GL_LINES, + GL_LINE_STRIP, + GL_LINE_LOOP, + GL_TRIANGLES, + GL_TRIANGLE_STRIP, + GL_TRIANGLE_FAN, + GL_ZERO, //GL_QUADS, + GL_ZERO, //GL_QUAD_STRIP, + GL_ZERO, //GL_POLYGON, + }; + + GLenum mesh_indices_type[] = { + GL_ZERO, + GL_UNSIGNED_SHORT, + GL_UNSIGNED_INT, + }; + + rctx->obj_batch_ubo.WriteMemory(rctx->obj_batch); + if (primitive_type == OBJ_PRIMITIVE_TRIANGLE_STRIP && index_format == OBJ_INDEX_U16) + shaders_ft.draw_range_elements(GL_TRIANGLE_STRIP, + start, end, count, GL_UNSIGNED_SHORT, (void*)indices); + else + shaders_ft.draw_elements(mesh_draw_mode[primitive_type], + count, mesh_indices_type[index_format], (void*)indices); + + draw_state->stats.draw_count += count; + if (primitive_type == OBJ_PRIMITIVE_TRIANGLES) + draw_state->stats.draw_triangle_count += count / 3; + else if (primitive_type == OBJ_PRIMITIVE_TRIANGLE_STRIP) + draw_state->stats.draw_triangle_count += count - 2; + } + + void draw_etc_obj(mdl::EtcObj* etc) { + switch (etc->type) { + case mdl::ETC_OBJ_TEAPOT: + case mdl::ETC_OBJ_GRID: + case mdl::ETC_OBJ_CUBE: + case mdl::ETC_OBJ_SPHERE: + case mdl::ETC_OBJ_PLANE: + case mdl::ETC_OBJ_CONE: + case mdl::ETC_OBJ_LINE: + case mdl::ETC_OBJ_CROSS: + break; + default: + return; + } + + if (!etc->count) + return; + + GLuint vao = disp_manager->get_vertex_array(etc); + if (!vao) + return; + + vec4 g_material_state_diffuse = rctx->obj_batch.g_material_state_diffuse; + vec4 g_material_state_ambient = rctx->obj_batch.g_material_state_ambient; + vec4 g_material_state_specular = rctx->obj_batch.g_material_state_specular; + vec4 g_material_state_emission = rctx->obj_batch.g_material_state_emission; + vec4 g_material_state_shininess = rctx->obj_batch.g_material_state_shininess; + + vec4 color = etc->color; + + vec4 ambient; + *(vec3*)&ambient = *(vec3*)&color * 0.5f; + ambient.w = color.w; + + rctx->obj_batch.g_material_state_diffuse = color; + rctx->obj_batch.g_material_state_ambient = ambient; + rctx->obj_batch.g_material_state_specular = { 0.0f, 0.0f, 0.0f, 1.0f }; + rctx->obj_batch.g_material_state_emission = { 0.0f, 0.0f, 0.0f, 1.0f }; + rctx->obj_batch.g_material_state_shininess = { 0.0f, 0.0f, 0.0f, 1.0f }; + + rctx->obj_batch.g_blend_color = color; + + gl_state_bind_vertex_array(vao); + rctx->obj_batch_ubo.WriteMemory(rctx->obj_batch); + + shaders_ft.set(SHADER_FT_SIMPLE); + switch (etc->type) { + case mdl::ETC_OBJ_TEAPOT: + shaders_ft.draw_elements(GL_TRIANGLES, etc->count, GL_UNSIGNED_INT, 0); + break; + case mdl::ETC_OBJ_GRID: + shaders_ft.draw_arrays(GL_LINES, 0, etc->count); + break; + case mdl::ETC_OBJ_CUBE: + if (etc->data.sphere.wire) + shaders_ft.draw_elements(GL_LINES, etc->count, GL_UNSIGNED_INT, (void*)etc->offset); + else + shaders_ft.draw_elements(GL_TRIANGLES, etc->count, GL_UNSIGNED_INT, (void*)etc->offset); + break; + case mdl::ETC_OBJ_SPHERE: + if (etc->data.sphere.wire) + shaders_ft.draw_elements(GL_LINES, etc->count, GL_UNSIGNED_INT, (void*)etc->offset); + else + shaders_ft.draw_elements(GL_TRIANGLES, etc->count, GL_UNSIGNED_INT, (void*)etc->offset); + break; + case mdl::ETC_OBJ_PLANE: + shaders_ft.draw_arrays(GL_TRIANGLES, 0, etc->count); + break; + case mdl::ETC_OBJ_CONE: + if (etc->data.cone.wire) + shaders_ft.draw_elements(GL_LINES, etc->count, GL_UNSIGNED_INT, (void*)etc->offset); + else + shaders_ft.draw_elements(GL_TRIANGLES, etc->count, GL_UNSIGNED_INT, (void*)etc->offset); + break; + case mdl::ETC_OBJ_LINE: + shaders_ft.draw_arrays(GL_LINES, 0, etc->count); + break; + case mdl::ETC_OBJ_CROSS: + shaders_ft.draw_arrays(GL_LINES, 0, etc->count); + break; + } + shader_glsl::unbind(); + uniform_value_reset(); + + rctx->obj_batch.g_material_state_diffuse = g_material_state_diffuse; + rctx->obj_batch.g_material_state_ambient = g_material_state_ambient; + rctx->obj_batch.g_material_state_specular = g_material_state_specular; + rctx->obj_batch.g_material_state_emission = g_material_state_emission; + rctx->obj_batch.g_material_state_shininess = g_material_state_shininess; + + rctx->obj_batch.g_blend_color = 1.0f; + } + + void draw_sub_mesh(const ObjSubMeshArgs* args, const mat4* model, + void(*func)(const ObjSubMeshArgs* args)) { + GLuint vao = disp_manager->get_vertex_array(args); + if (!vao) + return; + + if (args->mats) { + const mat4* mats = args->mats; + rctx->obj_batch.set_g_joint(mats[0]); + + vec4* g_joint_transforms = rctx->obj_skinning.g_joint_transforms; + + mat4 mat; + for (int32_t i = 0; i < args->mat_count; i++, mats++, g_joint_transforms += 3) { + mat4_transpose(mats, &mat); + g_joint_transforms[0] = mat.row0; + g_joint_transforms[1] = mat.row1; + g_joint_transforms[2] = mat.row2; + } + + rctx->obj_skinning_ubo.WriteMemory(rctx->obj_skinning); + + rctx->obj_batch.set_transforms(mat4_identity, rctx->view_mat, rctx->proj_mat); + + uniform->arr[U_BONE_MAT] = 1; + gl_state_bind_vertex_array(vao); + func(args); + uniform->arr[U_BONE_MAT] = 0; + } + else { + mat4 mat; + if (args->mesh->attrib.m.billboard) + model_mat_face_camera_view(&rctx->view_mat, model, &mat); + else if (args->mesh->attrib.m.billboard_y_axis) + model_mat_face_camera_position(&rctx->view_mat, model, &mat); + else + mat = *model; + + uniform->arr[U_BONE_MAT] = 0; + gl_state_bind_vertex_array(vao); + if (func != draw_sub_mesh_default || !args->instances_count) { + draw_object_model_mat_load(mat); + func(args); + } + else + draw_sub_mesh_default_instanced(args, &mat); + uniform->arr[U_BONE_MAT] = 0; + } + } + + /*void draw_sub_mesh_show_vector( + const ObjSubMeshArgs* args, mat4* model, int32_t show_vector) { + return; + }*/ + + void draw_sub_mesh_default(const ObjSubMeshArgs* args) { + if (args->set_blend_color) { + rctx->obj_batch.g_blend_color = args->blend_color; + rctx->obj_batch.g_offset_color = 0.0f; + } + + if (!args->func) + draw_object_vertex_attrib_set_default(args); + + draw_object_material_set_default(args, use_shader_get()); + + const obj_sub_mesh* sub_mesh = args->sub_mesh; + draw( + sub_mesh->primitive_type, + sub_mesh->num_index, + sub_mesh->first_index, + sub_mesh->last_index, + sub_mesh->index_format, + sub_mesh->index_offset); + + draw_object_material_reset_default(args->material); + if (!args->func) + draw_object_vertex_attrib_reset_default(args); + + if (args->set_blend_color) { + rctx->obj_batch.g_blend_color = 1.0f; + rctx->obj_batch.g_offset_color = 0.0f; + } + + draw_state->stats.object_draw_count++; + } + + void draw_sub_mesh_default_instanced( + const ObjSubMeshArgs* args, const mat4* mat) { + if (args->set_blend_color) { + rctx->obj_batch.g_blend_color = args->blend_color; + rctx->obj_batch.g_offset_color = 0.0f; + } + + if (!args->func) + draw_object_vertex_attrib_set_default(args); + + draw_object_material_set_default(args, use_shader_get()); + + const obj_sub_mesh* sub_mesh = args->sub_mesh; + const mat4* instances_mat = args->instances_mat; + mat4 _mat; + for (int32_t i = args->instances_count; i >= 0; i--, instances_mat++) { + mat4_mul(instances_mat, mat, &_mat); + draw_object_model_mat_load(_mat); + draw( + sub_mesh->primitive_type, + sub_mesh->num_index, + sub_mesh->first_index, + sub_mesh->last_index, + sub_mesh->index_format, + sub_mesh->index_offset); + } + + draw_object_material_reset_default(args->material); + if (!args->func) + draw_object_vertex_attrib_reset_default(args); + + if (args->set_blend_color) { + rctx->obj_batch.g_blend_color = 1.0f; + rctx->obj_batch.g_offset_color = 0.0f; + } + + draw_state->stats.object_draw_count++; + } + + void draw_sub_mesh_sss(const ObjSubMeshArgs* args) { + obj_material_attrib_member attrib = args->material->material.attrib.m; + uniform->arr[U_ALPHA_TEST] = (!attrib.flag_28 && (args->blend_color.w < 1.0f + || (attrib.alpha_texture || attrib.alpha_material) && !attrib.punch_through + || args->sub_mesh->attrib.m.transparent) + || attrib.punch_through) ? 1 : 0; + + uniform->arr[U26] = 1; + bool aniso = false; + const obj_material_data* material = args->material; + switch (material->material.shader.index) { + case SHADER_FT_CLOTH: + if (!render_manager->npr_param && material->material.color.ambient.w < 1.0f + && material->material.shader_info.m.aniso_direction == OBJ_MATERIAL_ANISO_DIRECTION_NORMAL) + aniso = true; + break; + case SHADER_FT_TIGHTS: + if (!render_manager->npr_param) + aniso = true; + break; + //case SHADER_FT_EYEBALL: + case SHADER_FT_GLASEYE: + uniform->arr[U26] = 0; + aniso = true; + break; + case SHADER_FT_SKIN: + aniso = true; + break; + } + + if (aniso) { + rctx->obj_batch.g_sss_param = { 0.0f, 0.0f, 0.0f, 0.5f }; + uniform->arr[U37] = 1; + } + else { + const vec4& sss_param = sss_data_get()->param; + rctx->obj_batch.g_sss_param = { sss_param.x, sss_param.y, sss_param.z, 0.5f }; + uniform->arr[U37] = 0; + } + draw_sub_mesh_default(args); + } + + void draw_sub_mesh_reflect(const ObjSubMeshArgs* args) { + const obj_material_data* material = args->material; + draw_object_vertex_attrib_set_reflect(args); + obj_material_shader_lighting_type lighting_type + = material->material.shader_info.get_lighting_type(); + bool disable_fog = draw_object_blend_set(args, lighting_type); + draw_object_chara_color_fog_set(args, disable_fog); + draw_object_material_set_reflect(args); + + const obj_sub_mesh* sub_mesh = args->sub_mesh; + if (sub_mesh->index_format != OBJ_INDEX_U8) + draw( + sub_mesh->primitive_type, + sub_mesh->num_index, + sub_mesh->first_index, + sub_mesh->last_index, + sub_mesh->index_format, + sub_mesh->index_offset); + + draw_object_material_reset_reflect(); + draw_object_vertex_attrib_reset_reflect(args); + uniform_value_reset(); + + draw_state->stats.object_reflect_draw_count++; + } + + void draw_sub_mesh_reflect_reflect_map(const ObjSubMeshArgs* args) { + draw_object_vertex_attrib_set_reflect(args); + draw_object_material_set_reflect(args); + + const obj_sub_mesh* sub_mesh = args->sub_mesh; + if (sub_mesh->index_format != OBJ_INDEX_U8) + draw( + sub_mesh->primitive_type, + sub_mesh->num_index, + sub_mesh->first_index, + sub_mesh->last_index, + sub_mesh->index_format, + sub_mesh->index_offset); + + draw_object_material_reset_reflect(); + draw_object_vertex_attrib_reset_reflect(args); + + draw_state->stats.object_reflect_draw_count++; + } + + void draw_sub_mesh_shadow(const ObjSubMeshArgs* args) { + obj_material_attrib_member attrib = args->material->material.attrib.m; + if (!attrib.flag_28 && (args->blend_color.w < 1.0f + || (attrib.alpha_texture || attrib.alpha_material) && !attrib.punch_through + || args->sub_mesh->attrib.m.transparent) + || attrib.punch_through) { + uniform->arr[U_ALPHA_TEST] = 1; + draw_sub_mesh_translucent(args); + } + else { + uniform->arr[U_ALPHA_TEST] = 0; + draw_sub_mesh_translucent(args); + } + } + + void draw_sub_mesh_translucent(const ObjSubMeshArgs* args) { + const obj_material_data* material = args->material; + const prj::vector* textures = args->textures; + if (draw_state->shader_index != -1) { + rctx->obj_batch.g_material_state_emission = material->material.color.emission; + draw_object_material_set_uniform(material, false); + if (material->material.attrib.m.alpha_texture) + uniform->arr[U_TEXTURE_COUNT] = 0; + rctx->obj_batch.g_texture_blend = { (float_t)uniform->arr[U_TEXTURE_BLEND], 0.0f, 0.0f, 0.0f }; + shaders_ft.set(draw_state->shader_index); + } + + draw_object_vertex_attrib_set_default(args); + if (args->material->material.attrib.m.double_sided) + gl_state_disable_cull_face(); + + GLuint tex_id = -1; + int32_t tex_index = 0; + if (material->material.attrib.m.alpha_texture) { + const obj_material_texture_data* texdata = material->material.texdata; + uint32_t texture_id = -1; + if (!material->material.shader_compo.m.transparency) { + for (int32_t i = 0; i < 8; i++, texdata++) + if (texdata->shader_info.m.tex_type == OBJ_MATERIAL_TEXTURE_COLOR) { + texture_id = texdata->tex_index; + break; + } + tex_index = 0; + } + else { + for (int32_t i = 0; i < 8; i++, texdata++) + if (texdata->shader_info.m.tex_type == OBJ_MATERIAL_TEXTURE_TRANSPARENCY) { + if (texdata->attrib.m.flag_29) + texture_id = texdata->tex_index; + break; + } + tex_index = 3; + } + + if (texture_id != -1) { + texture_id &= 0xFFFFF; + for (int32_t j = 0; j < args->texture_pattern_count; j++) + if (args->texture_pattern_array[j].src == tex_index) { + texture* tex = texture_handler_get_texture(args->texture_pattern_array[j].dst); + if (tex) + tex_id = tex->tex; + break; + } + + if (tex_id == -1) + tex_id = (*textures)[texdata->tex_index >> 20]; + + if (tex_id == -1) + tex_id = 0; + + gl_state_active_bind_texture_2d(tex_index, tex_id); + + int32_t wrap_s; + if (texdata->attrib.m.mirror_u) + wrap_s = 2; + else if (texdata->attrib.m.repeat_u) + wrap_s = 1; + else + wrap_s = 0; + + int32_t wrap_t; + if (texdata->attrib.m.mirror_v) + wrap_t = 2; + else if (texdata->attrib.m.repeat_v) + wrap_t = 1; + else + wrap_t = 0; + + texture* tex = texture_handler_get_texture(texture_id); + gl_state_bind_sampler(tex_index, rctx->samplers[(wrap_t * 3 + wrap_s) * 2 + + (tex->max_mipmap_level > 0 ? 1 : 0)]); + } + } + + const obj_sub_mesh* sub_mesh = args->sub_mesh; + if (sub_mesh->index_format != OBJ_INDEX_U8) + draw( + sub_mesh->primitive_type, + sub_mesh->num_index, + sub_mesh->first_index, + sub_mesh->last_index, + sub_mesh->index_format, + sub_mesh->index_offset); + + if (tex_id != -1) + gl_state_active_bind_texture_2d(tex_index, rctx->empty_texture_2d); + + gl_state_enable_cull_face(); + draw_object_vertex_attrib_reset_default(args); + + if (draw_state->shader_index != -1) + uniform_value_reset(); + + draw_state->stats.object_translucent_draw_count++; + } +} + +inline void draw_object_model_mat_load(const mat4& mat) { + rctx->obj_batch.set_transforms(mat, rctx->view_mat, rctx->proj_mat); + rctx->obj_batch.set_g_joint(mat); +} + +inline void model_mat_face_camera_position(const mat4* view, const mat4* src, mat4* dst) { + mat4 mat; + mat4_invert_fast(view, &mat); + + vec3 dir = vec3::normalize(*(vec3*)&mat.row3 - *(vec3*)&src->row3); + + vec3 x_rot; + vec3 y_rot; + vec3 z_rot; + + y_rot = *(vec3*)&src->row1; + x_rot = vec3::normalize(vec3::cross(y_rot, dir)); + z_rot = vec3::cross(x_rot, y_rot); + + *(vec3*)&dst->row0 = x_rot; + *(vec3*)&dst->row1 = y_rot; + *(vec3*)&dst->row2 = z_rot; + *(vec3*)&dst->row3 = *(vec3*)&src->row3; + dst->row0.w = 0.0f; + dst->row1.w = 0.0f; + dst->row2.w = 0.0f; + dst->row3.w = 1.0f; +} + +inline void model_mat_face_camera_view(const mat4* view, const mat4* src, mat4* dst) { + mat3 mat; + mat4_to_mat3(view, &mat); + mat3_invert(&mat, &mat); + mat4_from_mat3(&mat, dst); + mat4_mul(dst, src, dst); +} + +static bool draw_object_blend_set( + const mdl::ObjSubMeshArgs* args, obj_material_shader_lighting_type lighting_type) { + static const GLenum blend_factor_table[] = { + GL_ZERO, + GL_ONE, + GL_SRC_COLOR, + GL_ONE_MINUS_SRC_COLOR, + GL_SRC_ALPHA, + GL_ONE_MINUS_SRC_ALPHA, + GL_DST_ALPHA, + GL_ONE_MINUS_DST_ALPHA, + GL_DST_COLOR, + GL_ONE_MINUS_DST_COLOR, + GL_SRC_ALPHA_SATURATE, + GL_ZERO, + GL_ZERO, + GL_ZERO, + GL_ZERO, + GL_ZERO, + }; + + const obj_material_data* material = args->material; + obj_material_attrib_member attrib = material->material.attrib.m; + if ((!attrib.alpha_texture && !attrib.alpha_material) || attrib.punch_through) + return false; + + GLenum src_blend_factor = blend_factor_table[attrib.src_blend_factor]; + GLenum dst_blend_factor = blend_factor_table[attrib.dst_blend_factor]; + if (args->chara_color) { + light_set* set = &light_set_data[LIGHT_SET_MAIN]; + light_data* chara_color = &set->lights[LIGHT_CHARA_COLOR]; + vec4 specular; + chara_color->get_specular(specular); + if (specular.w >= 4.0f && chara_color->get_type() == LIGHT_PARALLEL + && (src_blend_factor != GL_ONE || dst_blend_factor)) { + int32_t shader_index = draw_state->shader_index; + if (shader_index == -1) { + shader_index = material->material.shader.index; + if (shader_index == SHADER_FT_BLINN) { + if (lighting_type == OBJ_MATERIAL_SHADER_LIGHTING_CONSTANT) + shader_index = SHADER_FT_CONSTANT; + if (lighting_type == OBJ_MATERIAL_SHADER_LIGHTING_LAMBERT) + shader_index = SHADER_FT_LAMBERT; + } + } + + if (draw_object_blend_set_check_use_default_blend(shader_index)) { + src_blend_factor = GL_SRC_ALPHA; + dst_blend_factor = GL_ONE_MINUS_SRC_ALPHA; + } + } + } + gl_state_set_blend_func(src_blend_factor, dst_blend_factor); + return dst_blend_factor == GL_ONE; +} + +static bool draw_object_blend_set_check_use_default_blend(int32_t index) { + bool use_default_blend[] = { + false, false, true, false, true, false, false, true, true, true, false, false, + false, true, false, false, false, false, false, false, false, false, false, false, + false, false, false, false, false, false, false, false, false, false, false, false, + false, false, false, false, false, false, false, false, false, false, false, false, + false, false, false, false, false, false, false, false, false, false, false, false, + false, false, false + }; + + if (index >= 0 && index < SHADER_FT_MAX) + return use_default_blend[index]; + return false; +} + +static void draw_object_chara_color_fog_set(const mdl::ObjSubMeshArgs* args, bool disable_fog) { + uniform->arr[U_CHARA_COLOR] = 0; + if (args->chara_color) { + light_set* set = &light_set_data[LIGHT_SET_MAIN]; + light_data* chara_color = &set->lights[LIGHT_CHARA_COLOR]; + vec4 specular; + chara_color->get_specular(specular); + if (specular.w > 0.0f && chara_color->get_type() == LIGHT_PARALLEL) + uniform->arr[U_CHARA_COLOR] = 1; + } + + obj_material_attrib_member attrib = args->material->material.attrib.m; + if (!attrib.no_fog && !disable_fog) { + if (attrib.has_fog_height) + uniform->arr[U_FOG_HEIGHT] = 2 + attrib.fog_height; + else + uniform->arr[U_FOG_HEIGHT] = 1; + uniform->arr[U_FOG] = draw_state->fog_height ? 2 : 1; + } +} + +static void draw_object_material_reset_default(const obj_material_data* mat_data) { + if (mat_data) { + gl_state_enable_cull_face(); + obj_material_attrib_member attrib = mat_data->material.attrib.m; + if ((attrib.alpha_texture || attrib.alpha_material) && !attrib.punch_through) + gl_state_set_blend_func(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + } + uniform_value_reset(); +} + +static void draw_object_material_reset_reflect() { + gl_state_active_bind_texture_2d(0, rctx->empty_texture_2d); + gl_state_enable_cull_face(); + uniform_value_reset(); +} + +static void draw_object_material_set_default(const mdl::ObjSubMeshArgs* args, bool use_shader) { + const prj::vector* textures = args->textures; + const obj_material_data* material = args->material; + obj_material_shader_lighting_type lighting_type = + material->material.shader_info.get_lighting_type(); + bool disable_fog = draw_object_blend_set(args, lighting_type); + draw_object_material_set_uniform(material, false); + if (!draw_state->light) + uniform->arr[U_LIGHT_0] = 0; + else if (args->self_shadow) + uniform->arr[U_LIGHT_0] = 1; + else + uniform->arr[U_LIGHT_0] = args->sub_mesh->attrib.m.recieve_shadow ? 1 : 0; + uniform->arr[U_SHADOW] = 0; + uniform->arr[U_SELF_SHADOW] = draw_state->self_shadow ? 1 : 0; + + const obj_material_texture_data* texdata = material->material.texdata; + uniform->arr[U_SHADOW] = args->shadow > SHADOW_CHARA; + for (int32_t i = 0, j = 0; i < 8; i++, texdata++) { + if (texdata->tex_index == -1) + continue; + + GLuint tex_id = -1; + uint32_t texture_id = texdata->tex_index & 0xFFFFF; + for (int32_t j = 0; j < args->texture_pattern_count; j++) + if (args->texture_pattern_array[j].src == texture_id) { + texture* tex = texture_handler_get_texture(args->texture_pattern_array[j].dst); + if (tex) + tex_id = tex->tex; + break; + } + + if (tex_id == -1) + tex_id = (*textures)[texdata->tex_index >> 20]; + + if (tex_id == -1) + continue; + + int32_t tex_index = obj_material_texture_type_get_texture_index(texdata->shader_info.m.tex_type, j); + if (tex_index < 0) + continue; + + obj_material_texture_type tex_type = texdata->shader_info.m.tex_type; + if (tex_type == OBJ_MATERIAL_TEXTURE_COLOR) + j++; + + if (texdata->attrib.m.flag_29) { + switch (tex_type) { + case OBJ_MATERIAL_TEXTURE_NORMAL: + uniform->arr[U_NORMAL] = 0; + break; + case OBJ_MATERIAL_TEXTURE_SPECULAR: + uniform->arr[U_SPECULAR] = 0; + break; + case OBJ_MATERIAL_TEXTURE_TRANSLUCENCY: + uniform->arr[U_TRANSLUCENCY] = 0; + break; + case OBJ_MATERIAL_TEXTURE_TRANSPARENCY: + uniform->arr[U_TRANSPARENCY] = 0; + break; + } + continue; + } + + if (tex_type == OBJ_MATERIAL_TEXTURE_ENVIRONMENT_CUBE) { + gl_state_active_bind_texture_cube_map(tex_index, tex_id); + gl_state_bind_sampler(tex_index, 0); + } + else { + gl_state_active_bind_texture_2d(tex_index, tex_id); + + int32_t wrap_s; + if (texdata->attrib.m.mirror_u) + wrap_s = 2; + else if (texdata->attrib.m.repeat_u) + wrap_s = 1; + else + wrap_s = 0; + + int32_t wrap_t; + if (texdata->attrib.m.mirror_v) + wrap_t = 2; + else if (texdata->attrib.m.repeat_v) + wrap_t = 1; + else + wrap_t = 0; + + texture* tex = texture_handler_get_texture(texture_id); + gl_state_bind_sampler(tex_index, rctx->samplers[(wrap_t * 3 + wrap_s) * 2 + + (tex->max_mipmap_level > 0 ? 1 : 0)]); + } + + if (material->material.shader.index == SHADER_FT_SKY) { + uniform_name uni_type = U_TEX_0_TYPE; + if (tex_index == 1) + uni_type = U_TEX_1_TYPE; + + texture* tex = texture_handler_get_texture(texture_id); + if (!tex) + uniform->arr[uni_type] = 1; + else if (tex->internal_format == GL_COMPRESSED_RED_RGTC1_EXT) + uniform->arr[uni_type] = 3; + else if (tex->internal_format == GL_COMPRESSED_RED_GREEN_RGTC2_EXT) + uniform->arr[uni_type] = 2; + else + uniform->arr[uni_type] = 1; + } + + if (tex_index >= 0 && tex_index <= 1) + uniform->arr[U_TEXTURE_BLEND] = texdata->attrib.get_blend(); + } + + if (material->material.attrib.m.double_sided) { + gl_state_disable_cull_face(); + if (!material->material.attrib.m.normal_dir_light) + uniform->arr[U0B] = 1; + } + + draw_object_chara_color_fog_set(args, disable_fog); + + rctx->obj_batch.g_material_state_ambient = material->material.color.ambient; + if (!sss_data_get()->enable) + rctx->obj_batch.g_material_state_ambient.w = 1.0f; + rctx->obj_batch.g_material_state_diffuse = material->material.color.diffuse; + rctx->obj_batch.g_material_state_emission = material->material.color.emission; + + float_t line_light; + if (lighting_type == OBJ_MATERIAL_SHADER_LIGHTING_PHONG) { + const vec4& specular = material->material.color.specular; + rctx->obj_batch.g_material_state_specular = specular; + + float_t luma = vec3::dot(*(vec3*)&specular, { 0.30f, 0.59f, 0.11f }); + if (luma >= 0.01f || args->texture_color_coefficients.w >= 0.1f) + uniform->arr[U_SPECULAR_IBL] = 1; + else + uniform->arr[U_SPECULAR_IBL] = 0; + + if (!material->material.shader_info.m.fresnel_type) + uniform->arr[U_TRANSLUCENCY] = 0; + + line_light = (float_t)material->material.shader_info.m.line_light * (float_t)(1.0 / 9.0); + } + else + line_light = 0.0; + + if (!use_shader) + shaders_ft.set(SHADER_FT_SIMPLE); + else if (draw_state->shader_index != -1) + shaders_ft.set(draw_state->shader_index); + else if (material->material.shader.index != -1) { + if (material->material.shader.index != SHADER_FT_BLINN) + shaders_ft.set(material->material.shader.index); + else if (lighting_type == OBJ_MATERIAL_SHADER_LIGHTING_LAMBERT) + shaders_ft.set(SHADER_FT_LAMBERT); + else if (lighting_type == OBJ_MATERIAL_SHADER_LIGHTING_PHONG) + shaders_ft.set(SHADER_FT_BLINN); + else + shaders_ft.set(SHADER_FT_CONSTANT); + } + else + shaders_ft.set(SHADER_FT_CONSTANT); + + rctx->obj_batch.g_texture_blend = { (float_t)uniform->arr[U_TEXTURE_BLEND], 0.0f, 0.0f, 0.0f }; + if (lighting_type != OBJ_MATERIAL_SHADER_LIGHTING_CONSTANT) { + float_t material_shininess; + if (material->material.shader.index == SHADER_FT_GLASEYE/*SHADER_FT_EYEBALL*/) + material_shininess = 10.0f; + else { + material_shininess = (material->material.color.shininess - 16.0f) * (float_t)(1.0 / 112.0); + material_shininess = max_def(material_shininess, 0.0f); + } + rctx->obj_batch.g_material_state_shininess = { material_shininess, 0.0f, 0.0f, 1.0f }; + + float_t fresnel = (float_t)material->material.shader_info.m.fresnel_type; + if (fresnel > 9.0f) + fresnel = 9.0f; + else if (fresnel == 0.0f) + fresnel = draw_state->fresnel; + fresnel = (fresnel - 1.0f) * 0.12f * 0.82f; + + rctx->obj_batch.g_fresnel_coefficients = { fresnel, 0.18f, line_light, 0.0f }; + + float_t shininess = max_def(material->material.color.shininess, 1.0f); + rctx->obj_batch.g_shininess = { shininess, 0.0f, 0.0f, 0.0f }; + + switch (material->material.shader.index) { + case SHADER_FT_SKIN: { + vec4 texture_color_coefficients = args->texture_color_coefficients; + vec4 texture_color_offset = args->texture_color_offset; + vec4 texture_specular_coefficients = args->texture_specular_coefficients; + vec4 texture_specular_offset = args->texture_specular_offset; + + texture_color_coefficients.w *= 0.015f; + texture_specular_coefficients.w *= 0.015f; + + rctx->obj_batch.g_texture_color_coefficients = texture_color_coefficients; + rctx->obj_batch.g_texture_color_offset = texture_color_offset; + rctx->obj_batch.g_texture_specular_coefficients = texture_specular_coefficients; + rctx->obj_batch.g_texture_specular_offset = texture_specular_offset; + } break; + case SHADER_FT_HAIR: + case SHADER_FT_CLOTH: + case SHADER_FT_TIGHTS: + rctx->obj_batch.g_texture_color_coefficients = { + 1.0f - args->texture_color_coefficients.w * 0.4f, + 0.0f, 0.0f, args->texture_color_coefficients.w * 0.02f }; + break; + } + } + + draw_object_material_set_parameter(material); +} + +static void draw_object_material_set_parameter(const obj_material_data* mat_data) { + float_t bump_depth; + float_t intensity; + float_t reflect_uv_scale; + float_t refract_uv_scale; + float_t inv_bump_depth; + if (draw_state->use_global_material) { + bump_depth = draw_state->bump_depth; + intensity = draw_state->intensity; + reflect_uv_scale = draw_state->reflect_uv_scale; + refract_uv_scale = draw_state->refract_uv_scale; + inv_bump_depth = (1.0f - draw_state->bump_depth) * 64.0f + 1.0f; + + vec4 specular = mat_data->material.color.specular; + specular.w = draw_state->reflectivity; + rctx->obj_batch.g_material_state_specular = specular; + } + else { + bump_depth = mat_data->material.bump_depth; + reflect_uv_scale = 0.1f; + intensity = mat_data->material.color.intensity; + refract_uv_scale = 0.1f; + inv_bump_depth = (1.0f - bump_depth) * 256.0f + 1.0f; + } + + rctx->obj_batch.g_bump_depth = { inv_bump_depth, bump_depth, 0.0f, 0.0f }; + rctx->obj_batch.g_intensity = { intensity, max_def(intensity, 1.0f), intensity * 25.5f, 1.0f }; + rctx->obj_batch.g_reflect_uv_scale = { + reflect_uv_scale, reflect_uv_scale, refract_uv_scale, refract_uv_scale }; +} + +static void draw_object_material_set_reflect(const mdl::ObjSubMeshArgs* args) { + const obj_material_data* material = args->material; + const prj::vector* textures = args->textures; + if (material->material.attrib.m.double_sided) + gl_state_disable_cull_face(); + + const obj_material_texture_data* texdata = material->material.texdata; + for (int32_t i = 0; i < 1; i++, texdata++) { + uint32_t texture_id = texdata->tex_index & 0xFFFFF; + if (texdata->tex_index == -1) + break; + + GLuint tex_id = -1; + for (int32_t j = 0; j < args->texture_pattern_count; j++) + if (args->texture_pattern_array[j].src == texture_id) { + texture* tex = texture_handler_get_texture(args->texture_pattern_array[j].dst); + if (tex) + tex_id = tex->tex; + break; + } + + if (tex_id == -1) + tex_id = (*textures)[texdata->tex_index >> 20]; + + if (tex_id == -1) + tex_id = 0; + + gl_state_active_bind_texture_2d(i, tex_id); + + int32_t wrap_s; + if (texdata->attrib.m.mirror_u) + wrap_s = 2; + else if (texdata->attrib.m.repeat_u) + wrap_s = 1; + else + wrap_s = 0; + + int32_t wrap_t; + if (texdata->attrib.m.mirror_v) + wrap_t = 2; + else if (texdata->attrib.m.repeat_v) + wrap_t = 1; + else + wrap_t = 0; + + texture* tex = texture_handler_get_texture(texture_id); + gl_state_bind_sampler(i, rctx->samplers[(wrap_t * 3 + wrap_s) * 2 + + (tex->max_mipmap_level > 0 ? 1 : 0)]); + } + + vec4 ambient; + vec4 diffuse; + vec4 emission; + vec4 specular; + if (material->material.shader.index == -1) { + ambient = 1.0f; + diffuse = material->material.color.diffuse; + emission = 1.0f; + specular = material->material.color.specular; + } + else { + ambient = material->material.color.ambient; + diffuse = material->material.color.diffuse; + emission = material->material.color.emission; + specular = material->material.color.specular; + } + + draw_object_material_set_uniform(material, true); + rctx->obj_batch.g_texture_blend = { (float_t)uniform->arr[U_TEXTURE_BLEND], 0.0f, 0.0f, 0.0f }; + shaders_ft.set(draw_state->shader_index); + rctx->obj_batch.g_material_state_ambient = ambient; + rctx->obj_batch.g_material_state_diffuse = diffuse; + rctx->obj_batch.g_material_state_emission = emission; + rctx->obj_batch.g_material_state_specular = specular; + draw_object_material_set_parameter(args->material); +} + +static void draw_object_material_set_uniform(const obj_material_data* mat_data, bool disable_color_l) { + obj_shader_compo_member shader_compo = mat_data->material.shader_compo.m; + obj_material_shader_attrib_member shader_info = mat_data->material.shader_info.m; + + if (disable_color_l) { + if (shader_compo.color) + shader_compo.color_l1 = 0; + shader_compo.color_l2 = 0; + } + + int32_t v4 = 0; + if (shader_compo.color) { + if (!shader_compo.color_l2) + if (shader_compo.color_l1) { + uniform->arr[U_TEXTURE_COUNT] = 2; + v4 = 3; + } + else { + uniform->arr[U_TEXTURE_COUNT] = 1; + v4 = 1; + } + } + else if (shader_compo.color_l1 && !shader_compo.color_l2) { + uniform->arr[U_TEXTURE_COUNT] = 1; + v4 = 1; + } + else + uniform->arr[U_TEXTURE_COUNT] = 0; + + if (shader_compo.normal_01) + uniform->arr[U_NORMAL] = 1; + if (shader_compo.specular) + uniform->arr[U_SPECULAR] = 1; + if (shader_compo.transparency) { + uniform->arr[U_TRANSPARENCY] = 1; + v4 |= 2; + } + if (shader_compo.translucency) { + uniform->arr[U_TRANSLUCENCY] = 1; + v4 |= 2; + } + if (shader_compo.override_ibl) + uniform->arr[U_ENV_MAP] = 1; + + if (shader_info.aniso_direction != OBJ_MATERIAL_ANISO_DIRECTION_NORMAL) + uniform->arr[U_ANISO] = shader_info.aniso_direction; + + if (v4 == 1) + uniform->arr[U45] = 0; + else if (v4 == 2 || v4 == 3) + uniform->arr[U45] = 1; +} + +static void draw_object_vertex_attrib_reset_default(const mdl::ObjSubMeshArgs* args) { + const obj_mesh* mesh = args->mesh; + obj_vertex_format vertex_format = mesh->vertex_format; + + if ((vertex_format & OBJ_VERTEX_BONE_DATA) == OBJ_VERTEX_BONE_DATA) + uniform->arr[U_BONE_MAT] = 0; + + if (args->morph_vertex_buffer) { + uniform->arr[U_MORPH] = 0; + uniform->arr[U_MORPH_COLOR] = 0; + } + + /*if (args->instances_count) + uniform->arr[U_INSTANCE] = 0;*/ + + gl_state_active_texture(0); +} + +static void draw_object_vertex_attrib_reset_reflect(const mdl::ObjSubMeshArgs* args) { + const obj_mesh* mesh = args->mesh; + obj_vertex_format vertex_format = mesh->vertex_format; + + if ((vertex_format & OBJ_VERTEX_BONE_DATA) == OBJ_VERTEX_BONE_DATA) + uniform->arr[U_BONE_MAT] = 0; + + if (args->morph_vertex_buffer) { + uniform->arr[U_MORPH] = 0; + uniform->arr[U_MORPH_COLOR] = 0; + } + + gl_state_active_texture(0); +} + +static void draw_object_vertex_attrib_set_default(const mdl::ObjSubMeshArgs* args) { + const obj_mesh* mesh = args->mesh; + obj_vertex_format vertex_format = mesh->vertex_format; + + bool texcoord_mat_set[4] = { false }; + const obj_material_data* material = args->material; + for (int32_t i = 0, j = 0, l = 0; i < 4; i++) { + if (material->material.texdata[i].tex_index == -1) + continue; + + int32_t texcoord_index = obj_material_texture_type_get_texcoord_index( + material->material.texdata[i].shader_info.m.tex_type, j); + if (texcoord_index < 0) + continue; + + if (material->material.texdata[i].shader_info.m.tex_type == OBJ_MATERIAL_TEXTURE_COLOR) + j++; + + l++; + + if (texcoord_mat_set[texcoord_index]) + continue; + + uint32_t texture_id = material->material.texdata[i].tex_index & 0xFFFFF; + + rctx->obj_batch.set_g_texcoord_transforms(texcoord_index, + material->material.texdata[i].tex_coord_mat); + if (material->material.texdata[i].shader_info.m.tex_type == OBJ_MATERIAL_TEXTURE_COLOR) + for (int32_t k = 0; k < args->texture_transform_count; k++) + if (args->texture_transform_array[k].id == texture_id) { + rctx->obj_batch.set_g_texcoord_transforms(texcoord_index, + args->texture_transform_array[k].mat); + texcoord_mat_set[texcoord_index] = true; + break; + } + } + + if (vertex_format & OBJ_VERTEX_BONE_DATA) + uniform->arr[U_BONE_MAT] = 1; + else + uniform->arr[U_BONE_MAT] = 0; + + if (args->morph_vertex_buffer) { + uniform->arr[U_MORPH] = 1; + + if (vertex_format & OBJ_VERTEX_COLOR0) + uniform->arr[U_MORPH_COLOR] = 1; + else + uniform->arr[U_MORPH_COLOR] = 0; + + rctx->obj_batch.g_morph_weight = { args->morph_weight, 1.0f - args->morph_weight, 0.0f, 0.0f }; + } + else { + uniform->arr[U_MORPH] = 0; + uniform->arr[U_MORPH_COLOR] = 0; + } + + /*if (args->instances_count) + uniform->arr[U_INSTANCE] = 1; + else + uniform->arr[U_INSTANCE] = 0;*/ +} + +static void draw_object_vertex_attrib_set_reflect(const mdl::ObjSubMeshArgs* args) { + const obj_mesh* mesh = args->mesh; + obj_vertex_format vertex_format = mesh->vertex_format; + + const obj_material_data* material = args->material; + if (material->material.texdata[0].tex_index != -1) { + uint32_t texture_id = material->material.texdata[0].tex_index & 0xFFFFF; + + rctx->obj_batch.set_g_texcoord_transforms(0, + material->material.texdata[0].tex_coord_mat); + if (material->material.texdata[0].shader_info.m.tex_type == OBJ_MATERIAL_TEXTURE_COLOR) + for (int32_t j = 0; j < args->texture_transform_count; j++) + if (args->texture_transform_array[j].id == texture_id) { + rctx->obj_batch.set_g_texcoord_transforms(0, + args->texture_transform_array[j].mat); + break; + } + } + + if (vertex_format & OBJ_VERTEX_BONE_DATA) + uniform->arr[U_BONE_MAT] = 1; + else + uniform->arr[U_BONE_MAT] = 0; + + if (args->morph_vertex_buffer) { + uniform->arr[U_MORPH] = 1; + + if (vertex_format & OBJ_VERTEX_COLOR0) + uniform->arr[U_MORPH_COLOR] = 1; + else + uniform->arr[U_MORPH_COLOR] = 0; + + rctx->obj_batch.g_morph_weight = { args->morph_weight, 1.0f - args->morph_weight, 0.0f, 0.0f }; + } + else { + uniform->arr[U_MORPH] = 0; + uniform->arr[U_MORPH_COLOR] = 0; + } +} diff --git a/src/DivaGL/mdl/draw_object.hpp b/src/DivaGL/mdl/draw_object.hpp new file mode 100644 index 0000000..d71fc1b --- /dev/null +++ b/src/DivaGL/mdl/draw_object.hpp @@ -0,0 +1,32 @@ +/* + by korenkonder + GitHub/GitLab: korenkonder +*/ + +#pragma once + +#include "../../KKdLib/default.hpp" +#include "../../KKdLib/mat.hpp" +#include "../../KKdLib/vec.hpp" +#include "../object.hpp" +#include "../render_context.hpp" + +namespace mdl { + extern void draw(obj_primitive_type primitive_type, uint32_t count, + uint16_t start, uint16_t end, obj_index_format index_format, size_t indices); + extern void draw_etc_obj(mdl::EtcObj* etc); + extern void draw_sub_mesh(const ObjSubMeshArgs* args, const mat4* model, + void(*func)(const ObjSubMeshArgs* args)); + extern void draw_sub_mesh_show_vector(const ObjSubMeshArgs* args, const mat4* model, int32_t show_vector); + extern void draw_sub_mesh_default(const ObjSubMeshArgs* args); + extern void draw_sub_mesh_default_instanced(const ObjSubMeshArgs* args, const mat4* mat); + extern void draw_sub_mesh_sss(const ObjSubMeshArgs* args); + extern void draw_sub_mesh_reflect(const ObjSubMeshArgs* args); + extern void draw_sub_mesh_reflect_reflect_map(const ObjSubMeshArgs* args); + extern void draw_sub_mesh_shadow(const ObjSubMeshArgs* args); + extern void draw_sub_mesh_translucent(const ObjSubMeshArgs* args); +}; + +extern void draw_object_model_mat_load(const mat4& mat); +extern void model_mat_face_camera_position(const mat4* view, const mat4* src, mat4* dst); +extern void model_mat_face_camera_view(const mat4* view, const mat4* src, mat4* dst); diff --git a/src/DivaGL/object.cpp b/src/DivaGL/object.cpp new file mode 100644 index 0000000..20abfed --- /dev/null +++ b/src/DivaGL/object.cpp @@ -0,0 +1,116 @@ +/* + by korenkonder + GitHub/GitLab: korenkonder +*/ + +#include "object.hpp" +#include "gl_state.hpp" +#include "wrap.hpp" +#include + +uint32_t(FASTCALL* obj_database_get_object_info)(const char* name) + = (uint32_t(FASTCALL*)(const char* name))0x0000000140459F80; +obj* (FASTCALL* object_info_get_object)(object_info obj_info) + = (obj * (FASTCALL*)(object_info obj_info))0x000000014045A140; +obj_mesh_index_buffer* (FASTCALL* object_info_get_mesh_index_buffer)(object_info obj_info, int32_t a2) + = (obj_mesh_index_buffer * (FASTCALL*)(object_info obj_info, int32_t a2))0x000000014045A250; +obj_skin* (FASTCALL* obj_database_get_object_skin)(object_info obj_info) + = (obj_skin * (FASTCALL*)(object_info obj_info))0x000000014045A3E0; +obj_mesh_vertex_buffer* (FASTCALL* object_info_get_mesh_vertex_buffer)(object_info obj_info, int32_t a2) + = (obj_mesh_vertex_buffer * (FASTCALL*)(object_info obj_info, int32_t a2))0x000000014045A480; +GLuint(FASTCALL* obj_database_get_obj_set_texture)(int32_t set, int32_t tex_id) + = (GLuint(FASTCALL*)(int32_t set, int32_t tex_id))0x000000014045A8F0; +prj::vector* (FASTCALL* obj_database_get_obj_set_textures)(int32_t set) + = (prj::vector * (FASTCALL*)(int32_t set))0x000000014045A9E0; + +void obj_mesh_vertex_buffer::cycle_index() { + if (++index >= count) + index = 0; +} + +GLuint obj_mesh_vertex_buffer::get_buffer() { + if (index < count) + return buffers[index]; + return 0; +} + +GLsizeiptr obj_mesh_vertex_buffer::get_size() { + if (buffers[0]) { + GLint buffer; + GLint size; + glGetIntegervDLL(GL_ARRAY_BUFFER_BINDING, &buffer); + glBindBuffer(target, buffers[0]); + glGetBufferParameterivARB(target, GL_BUFFER_SIZE, &size); + glBindBuffer(target, buffer); + return size; + } + return 0; +} + +inline int32_t obj_material_texture_type_get_texcoord_index( + obj_material_texture_type type, int32_t index) { + switch (type) { + case OBJ_MATERIAL_TEXTURE_COLOR: + if (index < 2) + return index; + case OBJ_MATERIAL_TEXTURE_NORMAL: + case OBJ_MATERIAL_TEXTURE_SPECULAR: + return 0; + case OBJ_MATERIAL_TEXTURE_TRANSLUCENCY: + case OBJ_MATERIAL_TEXTURE_TRANSPARENCY: + return 1; + } + return -1; +} + +inline int32_t obj_material_texture_type_get_texture_index( + obj_material_texture_type type, int32_t base_index) { + switch (type) { + case OBJ_MATERIAL_TEXTURE_COLOR: + if (base_index < 2) + return base_index; + case OBJ_MATERIAL_TEXTURE_NORMAL: + return 2; + case OBJ_MATERIAL_TEXTURE_SPECULAR: + return 3; + case OBJ_MATERIAL_TEXTURE_TRANSLUCENCY: + return 1; + case OBJ_MATERIAL_TEXTURE_TRANSPARENCY: + return 4; + case OBJ_MATERIAL_TEXTURE_ENVIRONMENT_SPHERE: // AFT + case OBJ_MATERIAL_TEXTURE_ENVIRONMENT_CUBE: + return 5; + } + return -1; +} + +void obj_skin_set_matrix_buffer(obj_skin* s, mat4* matrices, + mat4* ex_data_matrices, mat4* matrix_buffer, const mat4* mat, const mat4* global_mat) { + if (!s->num_bone) + return; + + if (mat) + for (uint32_t i = 0; i < s->num_bone; i++) { + mat4 temp; + int32_t bone_id = s->bone_id_array[i]; + if (bone_id & 0x8000) + mat4_mul(&ex_data_matrices[bone_id & 0x7FFF], mat, &temp); + else + mat4_mul(&matrices[bone_id], mat, &temp); + + mat4_mul(global_mat, &temp, &temp); + mat4_mul(&temp, &s->bone_matrix_array[i], &matrix_buffer[i]); + } + else + for (uint32_t i = 0; i < s->num_bone; i++) { + mat4 temp; + int32_t bone_id = s->bone_id_array[i]; + if (bone_id & 0x8000) + temp = ex_data_matrices[bone_id & 0x7FFF]; + else + temp = matrices[bone_id]; + + mat4_mul(global_mat, &temp, &temp); + mat4_mul(&temp, &s->bone_matrix_array[i], &matrix_buffer[i]); + } +} diff --git a/src/DivaGL/object.hpp b/src/DivaGL/object.hpp new file mode 100644 index 0000000..9642347 --- /dev/null +++ b/src/DivaGL/object.hpp @@ -0,0 +1,529 @@ +/* + by korenkonder + GitHub/GitLab: korenkonder +*/ + +#pragma once + +#include "../KKdLib/default.hpp" +#include "../KKdLib/mat.hpp" +#include "../KKdLib/vec.hpp" +#include "texture.hpp" +#include "types.hpp" + +enum obj_index_format : uint32_t { + OBJ_INDEX_U8 = 0x00, + OBJ_INDEX_U16 = 0x01, + OBJ_INDEX_U32 = 0x02, +}; + +enum obj_material_aniso_direction : uint32_t { + OBJ_MATERIAL_ANISO_DIRECTION_NORMAL = 0, + OBJ_MATERIAL_ANISO_DIRECTION_U = 1, + OBJ_MATERIAL_ANISO_DIRECTION_V = 2, + OBJ_MATERIAL_ANISO_DIRECTION_RADIAL = 3, +}; + +enum obj_material_blend_factor : uint32_t { + OBJ_MATERIAL_BLEND_ZERO = 0, + OBJ_MATERIAL_BLEND_ONE = 1, + OBJ_MATERIAL_BLEND_SRC_COLOR = 2, + OBJ_MATERIAL_BLEND_INVERSE_SRC_COLOR = 3, + OBJ_MATERIAL_BLEND_SRC_ALPHA = 4, + OBJ_MATERIAL_BLEND_INVERSE_SRC_ALPHA = 5, + OBJ_MATERIAL_BLEND_DST_ALPHA = 6, + OBJ_MATERIAL_BLEND_INVERSE_DST_ALPHA = 7, + OBJ_MATERIAL_BLEND_DST_COLOR = 8, + OBJ_MATERIAL_BLEND_INVERSE_DST_COLOR = 9, + OBJ_MATERIAL_BLEND_ALPHA_SATURATE = 10, +}; + +enum obj_material_bump_map_type : uint32_t { + OBJ_MATERIAL_BUMP_MAP_NONE = 0, + OBJ_MATERIAL_BUMP_MAP_DOT = 1, + OBJ_MATERIAL_BUMP_MAP_ENV = 2, +}; + +enum obj_material_color_source_type : uint32_t { + OBJ_MATERIAL_COLOR_SOURCE_MATERIAL_COLOR = 0, + OBJ_MATERIAL_COLOR_SOURCE_VERTEX_COLOR = 1, + OBJ_MATERIAL_COLOR_SOURCE_VERTEX_MORPH = 2, +}; + +enum obj_material_shader_lighting_type : uint32_t { + OBJ_MATERIAL_SHADER_LIGHTING_LAMBERT = 0x00, + OBJ_MATERIAL_SHADER_LIGHTING_CONSTANT = 0x01, + OBJ_MATERIAL_SHADER_LIGHTING_PHONG = 0x02, +}; + +enum obj_material_specular_quality : uint32_t { + OBJ_MATERIAL_SPECULAR_QUALITY_LOW = 0, + OBJ_MATERIAL_SPECULAR_QUALITY_HIGH = 1, +}; + +enum obj_material_texture_type : uint32_t { + OBJ_MATERIAL_TEXTURE_NONE = 0x00, + OBJ_MATERIAL_TEXTURE_COLOR = 0x01, + OBJ_MATERIAL_TEXTURE_NORMAL = 0x02, + OBJ_MATERIAL_TEXTURE_SPECULAR = 0x03, + OBJ_MATERIAL_TEXTURE_HEIGHT = 0x04, + OBJ_MATERIAL_TEXTURE_REFLECTION = 0x05, + OBJ_MATERIAL_TEXTURE_TRANSLUCENCY = 0x06, + OBJ_MATERIAL_TEXTURE_TRANSPARENCY = 0x07, + OBJ_MATERIAL_TEXTURE_ENVIRONMENT_SPHERE = 0x08, + OBJ_MATERIAL_TEXTURE_ENVIRONMENT_CUBE = 0x09, +}; + +enum obj_material_texture_coordinate_translation_type : uint32_t { + OBJ_MATERIAL_TEXTURE_COORDINATE_TRANSLATION_NONE = 0x00, + OBJ_MATERIAL_TEXTURE_COORDINATE_TRANSLATION_UV = 0x01, + OBJ_MATERIAL_TEXTURE_COORDINATE_TRANSLATION_SPHERE = 0x02, + OBJ_MATERIAL_TEXTURE_COORDINATE_TRANSLATION_CUBE = 0x03, +}; + +enum obj_material_vertex_translation_type : uint32_t { + OBJ_MATERIAL_VERTEX_TRANSLATION_DEFAULT = 0, + OBJ_MATERIAL_VERTEX_TRANSLATION_ENVELOPE = 1, + OBJ_MATERIAL_VERTEX_TRANSLATION_MORPHING = 2, +}; + +enum obj_primitive_type : uint32_t { + OBJ_PRIMITIVE_POINTS = 0x00, + OBJ_PRIMITIVE_LINES = 0x01, + OBJ_PRIMITIVE_LINE_STRIP = 0x02, + OBJ_PRIMITIVE_LINE_LOOP = 0x03, + OBJ_PRIMITIVE_TRIANGLES = 0x04, + OBJ_PRIMITIVE_TRIANGLE_STRIP = 0x05, + OBJ_PRIMITIVE_TRIANGLE_FAN = 0x06, + OBJ_PRIMITIVE_QUADS = 0x07, + OBJ_PRIMITIVE_QUAD_STRIP = 0x08, + OBJ_PRIMITIVE_POLYGON = 0x09, +}; + +enum obj_vertex_format : uint32_t { + OBJ_VERTEX_NONE = 0x0000, + OBJ_VERTEX_POSITION = 0x0001, + OBJ_VERTEX_NORMAL = 0x0002, + OBJ_VERTEX_TANGENT = 0x0004, + OBJ_VERTEX_BINORMAL = 0x0008, + OBJ_VERTEX_TEXCOORD0 = 0x0010, + OBJ_VERTEX_TEXCOORD1 = 0x0020, + OBJ_VERTEX_TEXCOORD2 = 0x0040, + OBJ_VERTEX_TEXCOORD3 = 0x0080, + OBJ_VERTEX_COLOR0 = 0x0100, + OBJ_VERTEX_COLOR1 = 0x0200, + OBJ_VERTEX_BONE_WEIGHT = 0x0400, + OBJ_VERTEX_BONE_INDEX = 0x0800, + OBJ_VERTEX_BONE_DATA = 0x0C00, + OBJ_VERTEX_UNKNOWN = 0x1000, +}; + +struct obj_axis_aligned_bounding_box { + vec3 center; + vec3 size; +}; + +struct obj_bounding_box { + vec3 center; + vec3 size; +}; + +struct obj_bounding_sphere { + vec3 center; + float_t radius; +}; + +struct obj_shader_compo_member { + uint32_t color : 1; + uint32_t color_a : 1; + uint32_t color_l1 : 1; + uint32_t color_l1_a : 1; + uint32_t color_l2 : 1; + uint32_t color_l2_a : 1; + uint32_t transparency : 1; + uint32_t specular : 1; + uint32_t normal_01 : 1; + uint32_t normal_02 : 1; + uint32_t envmap : 1; + uint32_t color_l3 : 1; + uint32_t color_l3_a : 1; + uint32_t translucency : 1; + uint32_t flag_14 : 1; + uint32_t override_ibl : 1; + uint32_t dummy : 16; +}; + +union obj_shader_compo { + obj_shader_compo_member m; + uint32_t w; +}; + +struct obj_material_shader_attrib_member { + obj_material_vertex_translation_type vtx_trans_type : 2; + obj_material_color_source_type col_src : 2; + uint32_t is_lgt_diffuse : 1; + uint32_t is_lgt_specular : 1; + uint32_t is_lgt_per_pixel : 1; + uint32_t is_lgt_double : 1; + obj_material_bump_map_type bump_map_type : 2; + uint32_t fresnel_type : 4; + uint32_t line_light : 4; + uint32_t recieve_shadow : 1; + uint32_t cast_shadow : 1; + obj_material_specular_quality specular_quality : 1; + obj_material_aniso_direction aniso_direction : 2; + uint32_t dummy : 9; +}; + +union obj_material_shader_attrib { + obj_material_shader_attrib_member m; + uint32_t w; + + obj_material_shader_lighting_type get_lighting_type() const; +}; + +struct obj_texture_attrib_member { + uint32_t repeat_u : 1; + uint32_t repeat_v : 1; + uint32_t mirror_u : 1; + uint32_t mirror_v : 1; + uint32_t ignore_alpha : 1; + uint32_t blend : 5; + uint32_t alpha_blend : 5; + uint32_t border : 1; + uint32_t clamp2edge : 1; + uint32_t filter : 3; + uint32_t mipmap : 2; + uint32_t mipmap_bias : 7; + uint32_t flag_29 : 1; + uint32_t anisotropic_filter : 2; +}; + +union obj_texture_attrib { + obj_texture_attrib_member m; + uint32_t w; + + int32_t get_blend() const; +}; + +struct obj_texture_shader_attrib_member { + obj_material_texture_type tex_type : 4; + int32_t uv_idx : 4; + obj_material_texture_coordinate_translation_type texcoord_trans : 3; + uint32_t dummy : 21; +}; + +union obj_texture_shader_attrib { + obj_texture_shader_attrib_member m; + uint32_t w; +}; + +struct obj_material_texture_data { + obj_texture_attrib attrib; + uint32_t tex_index; + obj_texture_shader_attrib shader_info; + char ex_shader[8]; + float_t weight; + mat4 tex_coord_mat; + uint32_t reserved[8]; +}; + +struct obj_material_attrib_member { + uint32_t alpha_texture : 1; + uint32_t alpha_material : 1; + uint32_t punch_through : 1; + uint32_t double_sided : 1; + uint32_t normal_dir_light : 1; + obj_material_blend_factor src_blend_factor : 4; + obj_material_blend_factor dst_blend_factor : 4; + uint32_t blend_operation : 3; + uint32_t zbias : 4; + uint32_t no_fog : 1; + uint32_t translucent_priority : 6; + uint32_t has_fog_height : 1; + uint32_t flag_28 : 1; + uint32_t fog_height : 1; + uint32_t flag_30 : 1; + uint32_t flag_31 : 1; +}; + +union obj_material_attrib { + obj_material_attrib_member m; + uint32_t w; +}; + +struct obj_material_color { + vec4 diffuse; + vec4 ambient; + vec4 specular; + vec4 emission; + float_t shininess; + float_t intensity; +}; + +struct obj_material { + obj_shader_compo shader_compo; + union { + char name[8]; + int32_t index; + } shader; + obj_material_shader_attrib shader_info; + obj_material_texture_data texdata[8]; + obj_material_attrib attrib; + obj_material_color color; + vec3 center; + float_t radius; + char name[64]; + float_t bump_depth; + uint32_t reserved[15]; +}; + +struct obj_material_data { + uint32_t num_of_textures; + obj_material material; +}; + +struct obj_sub_mesh_attrib_member { + uint32_t recieve_shadow : 1; + uint32_t cast_shadow : 1; + uint32_t transparent : 1; + uint32_t cloth : 1; + uint32_t dummy : 28; +}; + +union obj_sub_mesh_attrib { + obj_sub_mesh_attrib_member m; + uint32_t w; +}; + +struct obj_sub_mesh { + uint32_t flags; + obj_bounding_sphere bounding_sphere; + uint32_t material_index; + uint8_t uv_index[8]; + uint32_t num_bone_index; + uint16_t* bone_index_array; + uint32_t bones_per_vertex; + obj_primitive_type primitive_type; + obj_index_format index_format; + uint32_t num_index; + uint16_t* index_array; + obj_sub_mesh_attrib attrib; + uint32_t reserved[4]; + obj_axis_aligned_bounding_box* axis_aligned_bounding_box; + uint16_t first_index; + uint16_t last_index; + uint32_t index_offset; +}; + +static_assert(sizeof(obj_sub_mesh) == 0x70, "\"obj_sub_mesh\" struct should have a size of 0x70"); + +struct obj_vertex_data { + vec3 position; + vec3 normal; + vec4 tangent; + vec3 binormal; + vec2 texcoord0; + vec2 texcoord1; + vec2 texcoord2; + vec2 texcoord3; + vec4 color0; + vec4 color1; + vec4 bone_weight; + vec4i16 bone_index; + vec4 unknown; +}; + +struct obj_mesh_attrib_member { + uint32_t double_buffer : 1; + uint32_t billboard_y_axis : 1; + uint32_t translucent_no_shadow : 1; + uint32_t billboard : 1; + uint32_t dummy : 28; +}; + +union obj_mesh_attrib { + obj_mesh_attrib_member m; + uint32_t w; +}; + +struct obj_mesh_vertex_array { + vec3* position; + vec3* normal; + vec4* tangent; + vec3* binormal; + vec2* texcoord0; + vec2* texcoord1; + vec2* texcoord2; + vec2* texcoord3; + vec4* color0; + vec4* color1; + vec4* bone_weight; + vec4* bone_index; + void* field_60; + void* field_68; + void* field_70; + void* field_78; + void* field_80; + void* field_88; + void* field_90; + void* field_98; +}; + +struct obj_mesh { + uint32_t flags; + obj_bounding_sphere bounding_sphere; + uint32_t num_submesh; + obj_sub_mesh* submesh_array; + obj_vertex_format vertex_format; + uint32_t size_vertex; + uint32_t num_vertex; + union { + obj_mesh_vertex_array vertex_array; + void* vertex_array_ptr[20]; + }; + obj_mesh_attrib attrib; + uint32_t vertex_flags; + uint32_t reserved[6]; + char name[0x40]; +}; + +static_assert(sizeof(obj_mesh) == 0x130, "\"obj_mesh\" struct should have a size of 0x130"); + +struct obj { + uint32_t version; + uint32_t flags; + obj_bounding_sphere bounding_sphere; + uint32_t num_mesh; + obj_mesh* mesh_array; + uint32_t num_material; + obj_material_data* material_array; + uint32_t reserved[10]; +}; + +struct obj_skin_ex_data { + uint32_t num_osage_name; + uint32_t num_osage_node; + const char** field_8; + struct obj_skin_osage_node* osage_node_array; + const char** osage_name_array; + struct obj_skin_block* block_array; + uint32_t num_bone_name; + const char** bone_name_array; + struct obj_skin_osage_sibling_info* osage_sibling_infos; + uint32_t cloth_count; + uint32_t reserved[7]; +}; + +struct obj_skin { + uint32_t* bone_id_array; + mat4* bone_matrix_array; + const char** bone_name_array; + obj_skin_ex_data* ex_data; + uint32_t num_bone; + int32_t bone_parent_ids_offset; + int32_t field_28; + int32_t field_2C; + int32_t field_30; +}; + +struct object_info { + uint16_t id; + uint16_t set_id; + + inline object_info() { + this->id = (uint16_t)-1; + this->set_id = (uint16_t)-1; + } + + inline object_info(uint16_t id, uint16_t set_id) { + this->id = id; + this->set_id = set_id; + } + + inline object_info(uint32_t data) { + this->id = (uint16_t)data; + this->set_id = (uint16_t)(data >> 16); + } + + inline bool is_null() const { + return id == (uint16_t)-1 && set_id == (uint16_t)-1; + } + + inline bool not_null() const { + return id != (uint16_t)-1 || set_id != (uint16_t)-1; + } +}; + +inline bool operator >(const object_info& left, const object_info& right) { + return *(uint32_t*)&left > *(uint32_t*)&right; +} + +inline bool operator <(const object_info& left, const object_info& right) { + return *(uint32_t*)&left < *(uint32_t*)&right; +} + +inline bool operator >=(const object_info& left, const object_info& right) { + return *(uint32_t*)&left >= *(uint32_t*)&right; +} + +inline bool operator <=(const object_info& left, const object_info& right) { + return *(uint32_t*)&left <= *(uint32_t*)&right; +} + +inline bool operator ==(const object_info& left, const object_info& right) { + return *(uint32_t*)&left == *(uint32_t*)&right; +} + +inline bool operator !=(const object_info& left, const object_info& right) { + return *(uint32_t*)&left != *(uint32_t*)&right; +} + +struct obj_mesh_index_buffer { + GLuint buffer; +}; + +static_assert(sizeof(obj_mesh_index_buffer) == 0x04, "\"obj_mesh_index_buffer\" struct should have a size of 0x04"); + +struct obj_mesh_vertex_buffer { + int32_t count; + GLuint buffers[3]; + int32_t index; + GLenum target; + + void cycle_index(); + GLuint get_buffer(); + GLsizeiptr get_size(); +}; + +static_assert(sizeof(obj_mesh_vertex_buffer) == 0x18, "\"obj_mesh_vertex_buffer\" struct should have a size of 0x18"); + +struct obj_index_buffer { + uint32_t mesh_num; + obj_mesh_index_buffer* mesh_data; +}; + +static_assert(sizeof(obj_index_buffer) == 0x10, "\"obj_index_buffer\" struct should have a size of 0x10"); + +struct obj_vertex_buffer { + uint32_t mesh_num; + obj_mesh_vertex_buffer* mesh_data; +}; + +static_assert(sizeof(obj_vertex_buffer) == 0x10, "\"obj_vertex_buffer\" struct should have a size of 0x10"); + +extern uint32_t(FASTCALL* obj_database_get_object_info)(const char* name); +extern obj* (FASTCALL* object_info_get_object)(object_info obj_info); +extern obj_mesh_index_buffer* (FASTCALL* object_info_get_mesh_index_buffer)(object_info obj_info, int32_t a2); +extern obj_skin* (FASTCALL* obj_database_get_object_skin)(object_info obj_info); +extern obj_mesh_vertex_buffer* (FASTCALL* object_info_get_mesh_vertex_buffer)(object_info obj_info, int32_t a2); +extern GLuint(FASTCALL* obj_database_get_obj_set_texture)(int32_t set, int32_t tex_id); +extern prj::vector* (FASTCALL* obj_database_get_obj_set_textures)(int32_t set); + +extern int32_t obj_material_texture_type_get_texcoord_index( + obj_material_texture_type type, int32_t index); +extern int32_t obj_material_texture_type_get_texture_index( + obj_material_texture_type type, int32_t base_index); + +extern void obj_skin_set_matrix_buffer(obj_skin* s, mat4* matrices, + mat4* ex_data_matrices, mat4* matrix_buffer, const mat4* mat, const mat4* global_mat); diff --git a/src/DivaGL/print.cpp b/src/DivaGL/print.cpp new file mode 100644 index 0000000..145b2f6 --- /dev/null +++ b/src/DivaGL/print.cpp @@ -0,0 +1,22 @@ +/* + by korenkonder + GitHub/GitLab: korenkonder +*/ + +#include "print.hpp" + +void printf_divagl(const char* fmt, ...) { + printf("[DivaGL] "); + va_list args; + va_start(args, fmt); + vprintf(fmt, args); + va_end(args); + printf("\n"); +} + +void printf_proxy(const char* fmt, ...) { + va_list args; + va_start(args, fmt); + vprintf(fmt, args); + va_end(args); +} diff --git a/src/DivaGL/print.hpp b/src/DivaGL/print.hpp new file mode 100644 index 0000000..cfd4939 --- /dev/null +++ b/src/DivaGL/print.hpp @@ -0,0 +1,11 @@ +/* + by korenkonder + GitHub/GitLab: korenkonder +*/ + +#pragma once + +#include "../KKdLib/default.hpp" + +extern void printf_divagl(const char* fmt, ...); +extern void printf_proxy(const char* fmt, ...); diff --git a/src/DivaGL/render.cpp b/src/DivaGL/render.cpp new file mode 100644 index 0000000..2c3247b --- /dev/null +++ b/src/DivaGL/render.cpp @@ -0,0 +1,1763 @@ +/* + by korenkonder + GitHub/GitLab: korenkonder +*/ + +#include "render.hpp" +#include "rob/rob.hpp" +#include "gl_state.hpp" +#include "render_context.hpp" +#include "render_context.hpp" +#include "shader_glsl_ft.hpp" +#include "texture.hpp" + +extern bool task_stage_is_modern; + +extern render_context* rctx; + +rndr::Render* render = (rndr::Render*)0x00000001411AB670; + +#define MLAA_MAX_EDGE_DETECTION_LEN (3) +#define MLAA_GRID_SIDE_LEN (2 * MLAA_MAX_EDGE_DETECTION_LEN + 1) +#define MLAA_SIDE_LEN (5 * MLAA_GRID_SIDE_LEN) + +#define TONE_MAP_SAT_GAMMA_SAMPLES 32 + +namespace rndr { + static void generate_mlaa_area_texture(Render* rend); + static void calculate_mlaa_area_texture_data(uint8_t* data, int32_t cross1, int32_t cross2); + static void calculate_mlaa_area_texture_data_inner(float_t* val_left, + float_t* val_right, int32_t cross1, int32_t cross2, int32_t dleft, int32_t dright); + + void Render::ExposureCharaData::reset() { + for (GLuint& i : query_data) + i = -1; + spot_weight = 0.0f; + } + + void Render::apply_post_process() { + for (int32_t i = 0; i < 8; i++) + gl_state_bind_sampler(i, 0); + + gl_state_disable_depth_test(); + gl_state_disable_blend(); + + dof->apply(&rend_texture[0]); + + draw_lens_ghost(); + + downsample(); + + reduce_tex_draw = 0; + get_blur(); + + calc_exposure(); + apply_tone_map(); + + if (mlaa) + apply_mlaa(ss_alpha_mask); + + for (int32_t i = 0; i < 16; i++) { + if (!render_textures_data[i]) + continue; + + render_textures[i].Bind(); + + texture* t = render_textures_data[i]; + if (render_width[0] > t->width * 2 || render_height[0] > t->height * 2) + uniform->arr[U_REDUCE] = 1; + else + uniform->arr[U_REDUCE] = 0; + + glViewportDLL(0, 0, t->width, t->height); + gl_state_active_bind_texture_2d(0, taa_tex[2]->tex); + gl_state_bind_sampler(0, rctx->render_samplers[0]); + shaders_ft.set(SHADER_FT_REDUCE); + draw_quad(render_post_width[0], render_post_height[0], + render_post_width_scale, render_post_height_scale, + 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f); + } + + copy_to_frame_texture(rend_texture[0].GetColorTex(), + render_width[0], render_height[0], taa_tex[taa_texture_selector]->tex); + + rctx->screen_buffer.Bind(); + glViewportDLL(0, 0, rctx->sprite_width, rctx->sprite_height); + if (ssaa) { + gl_state_active_bind_texture_2d(0, taa_tex[2]->tex); + gl_state_bind_sampler(0, rctx->render_samplers[0]); + uniform->arr[U_ALPHA_MASK] = ss_alpha_mask ? 1 : 0; + uniform->arr[U_REDUCE] = 0; + shaders_ft.set(SHADER_FT_REDUCE); + draw_quad(render_post_width[0], render_post_height[0], + render_post_width_scale, render_post_height_scale, + 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f); + uniform->arr[U_ALPHA_MASK] = 0; + } + else { + gl_state_active_bind_texture_2d(0, taa_tex[2]->tex); + if (mag_filter == MAG_FILTER_NEAREST) + gl_state_bind_sampler(0, rctx->render_samplers[1]); + else + gl_state_bind_sampler(0, rctx->render_samplers[0]); + + switch (mag_filter) { + case MAG_FILTER_NEAREST: + case MAG_FILTER_BILINEAR: + default: + uniform->arr[U_MAGNIFY] = 0; + break; + case MAG_FILTER_SHARPEN_5_TAP: + uniform->arr[U_MAGNIFY] = 2; + break; + case MAG_FILTER_SHARPEN_4_TAP: + uniform->arr[U_MAGNIFY] = 3; + break; + case MAG_FILTER_CONE_4_TAP: + uniform->arr[U_MAGNIFY] = 4; + break; + case MAG_FILTER_CONE_2_TAP: + uniform->arr[U_MAGNIFY] = 5; + break; + } + + shaders_ft.set(SHADER_FT_MAGNIFY); + draw_quad(render_post_width[0], render_post_height[0], + render_post_width_scale, render_post_height_scale, + 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f); + } + shader_glsl::unbind(); + + for (int32_t i = 0; i < 8; i++) + gl_state_bind_sampler(i, 0); + + gl_state_bind_framebuffer(0); + } + + void Render::bind_render_texture(bool aet_back) { + if (aet_back) { + aet_back_texture.Bind(); + this->aet_back = 1; + } + else + rend_texture[0].Bind(); + glViewportDLL(0, 0, render_width[0], render_height[0]); + } + + void Render::calc_exposure_chara_data() { + shader_glsl::unbind(); + + gl_state_set_color_mask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE); + gl_state_set_depth_mask(GL_FALSE); + gl_state_disable_cull_face(); + + shaders_ft.set(SHADER_FT_SUN_NO_TEXTURED); + gl_state_bind_vertex_array(rctx->common_vao); + rctx->sun_quad_ubo.Bind(0); + + mat4 view_matrix; + mat4_transpose(&camera_data->view_matrix, &view_matrix); + mat4 projection_matrix; + mat4_transpose(&camera_data->projection_matrix, &projection_matrix); + + ExposureCharaData* chara_data = exposure_chara_data; + int32_t query_index = (this->exposure_query_index + 1) % 3; + this->exposure_query_index = query_index; + int32_t next_query_index = (query_index + 2) % 3; + size_t rob_chara_smth = get_rob_chara_smth(); + for (int32_t i = 0; i < ROB_CHARA_COUNT; i++, chara_data++) { + size_t rob_chr = rob_chara_array_get(rob_chara_smth, i); + if (!rob_chr || !(*(uint8_t*)(rob_chara_smth + 0x440) & 1)) + continue; + + float_t max_face_depth = rob_chara_get_max_face_depth(rob_chr); + + mat4 mat = mat4_identity; + sub_1405163C0(rob_chr, 4, &mat); + mat4_mul(&mat, &view_matrix, &mat); + mat4_mul_translate(&mat, max_face_depth + 0.1f, 0.0f, -0.06f, &mat); + mat4_clear_rot(&mat, &mat); + mat4_scale_rot(&mat, 0.0035f, &mat); + mat4_mul(&mat, &projection_matrix, &mat); + + sun_quad_shader_data shader_data = {}; + mat4_transpose(&mat, &mat); + shader_data.g_transform[0] = mat.row0; + shader_data.g_transform[1] = mat.row1; + shader_data.g_transform[2] = mat.row2; + shader_data.g_transform[3] = mat.row3; + shader_data.g_emission = 0.0f; + rctx->sun_quad_ubo.WriteMemory(shader_data); + + glBeginQuery(GL_SAMPLES_PASSED, chara_data->query[next_query_index]); + shaders_ft.draw_arrays(GL_TRIANGLE_STRIP, 0, 4); + glEndQuery(GL_SAMPLES_PASSED); + + if (chara_data->query_data[next_query_index] == -1) + chara_data->query_data[next_query_index] = 0; + + if (chara_data->query_data[query_index] != -1) { + int32_t res = 0; + glGetQueryObjectiv(chara_data->query[query_index], + GL_QUERY_RESULT_AVAILABLE, &res); + if (res) + glGetQueryObjectuiv(chara_data->query[query_index], + GL_QUERY_RESULT, chara_data->query_data); + else + chara_data->query_data[query_index] = 0; + } + } + + gl_state_bind_vertex_array(0); + + gl_state_set_color_mask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); + gl_state_set_depth_mask(GL_TRUE); + gl_state_enable_cull_face(); + } + + void Render::calc_projection_matrix(mat4* mat, double_t fov, double_t aspect, double_t z_near, double_t z_far, + double_t left_scale, double_t right_scale, double_t bottom_scale, double_t top_scale) { + double_t tan_fov = tan(fov * DEG_TO_RAD * 0.5) * z_near; + double_t left = -tan_fov * aspect + tan_fov * aspect * left_scale; + double_t right = tan_fov * aspect + tan_fov * aspect * right_scale; + double_t bottom = -tan_fov + tan_fov * bottom_scale; + double_t top = tan_fov + tan_fov * top_scale; + + if (taa) { + double_t offset = taa_texture_selector == 1 ? -0.25 : 0.25; + double_t left_right_offset = (right - left) * offset / (double_t)render_width[0]; + double_t bottom_top_offset = (top - bottom) * offset / (double_t)render_height[0]; + left += left_right_offset; + right += left_right_offset; + bottom += bottom_top_offset; + top += bottom_top_offset; + } + + mat4_frustrum(left, right, bottom, top, z_near, z_far, mat); + mat4_transpose(mat, mat); + } + + void Render::ctrl() { + static int32_t(FASTCALL * task_stage_get_current_stage_index)() + = (int32_t(FASTCALL*)())0x000000014064ADA0; + + view_point_prev = view_point; + interest_prev = interest; + view_point = camera_data->view_point; + interest = camera_data->interest; + + stage_index_prev = stage_index; + stage_index = task_stage_get_current_stage_index(); + + cam_view_projection_prev = cam_view_projection; + cam_view_projection = camera_data->view_projection_matrix; + + reset_exposure = camera_data->fast_change_hist1 && !camera_data->fast_change_hist0; + if (reset_exposure) { + float_t view_point_dist = vec3::distance(view_point, view_point_prev); + + vec3 dir = vec3::normalize(interest - view_point); + vec3 dir_prev = vec3::normalize(interest_prev - view_point_prev); + + float_t dir_diff_angle = vec3::dot(dir, dir_prev); + if (dir_diff_angle < 0.5f) + dir_diff_angle = 0.0f; + if (view_point_dist < dir_diff_angle * 0.4f) + reset_exposure = false; + } + else if (stage_index != stage_index_prev) + reset_exposure = true; + + if (movie_textures_data[0]) { + static size_t(FASTCALL * task_movie_get)(int32_t index) + = (size_t(FASTCALL*)(int32_t index))0x000000014041ED30; + size_t task_movie = task_movie_get(0); + if (task_movie) { + static texture*(FASTCALL * sub_14041ED80)(size_t task_movie) + = (texture*(FASTCALL*)(size_t task_movie))0x000000014041ED80; + texture* movie_texture = sub_14041ED80(task_movie); + if (movie_texture) { + movie_textures[0].Bind(); + glViewportDLL(0, 0, movie_textures_data[0]->width, movie_textures_data[0]->height); + gl_state_active_bind_texture_2d(0, movie_texture->tex); + uniform->arr[U_REDUCE] = 0; + shaders_ft.set(SHADER_FT_REDUCE); + draw_quad(movie_texture->width, movie_texture->height, + 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f); + gl_state_bind_framebuffer(0); + } + } + } + } + void Render::draw_quad(int32_t width, int32_t height, float_t s0, float_t t0, float_t s1, float_t t1, + float_t scale, float_t param_x, float_t param_y, float_t param_z, float_t param_w) { + s0 -= s1; + t0 -= t1; + + float_t w = (float_t)max_def(width, 1); + float_t h = (float_t)max_def(height, 1); + quad_shader_data quad = {}; + quad.g_texcoord_modifier = { 0.5f * s0, 0.5f * t0, 0.5f * s0 + s1, 0.5f * t0 + t1 }; // x * 0.5 * y0 + 0.5 * y0 + y1 + quad.g_texel_size = { scale / w, scale / h, w, h }; + quad.g_color = { param_x, param_y, param_z, param_w }; + quad.g_texture_lod = 0.0f; + + rctx->quad_ubo.WriteMemory(quad); + rctx->quad_ubo.Bind(0); + gl_state_bind_vertex_array(rctx->common_vao); + shaders_ft.draw_arrays(GL_TRIANGLE_STRIP, 0, 4); + } + + void Render::draw_lens_flare() { + static float_t flt_1411ACB84 = sinf(0.01365909819f); + static float_t flt_1411ACB8C = tanf(0.01365909819f) * 2.0f * 0.94f; + + if (!lens_flare_texture) + return; + + GLuint tex = obj_database_get_obj_set_texture(5, 4549); + if (!tex) + return; + + mat4 view_matrix; + mat4_transpose(&camera_data->view_matrix, &view_matrix); + mat4 projection_matrix; + mat4_transpose(&camera_data->projection_matrix, &projection_matrix); + + mat4 view_projection_matrix; + mat4 inverse_view_projection_matrix; + mat4_transpose(&camera_data->view_projection_matrix, &view_projection_matrix); + mat4_invert(&view_projection_matrix, &inverse_view_projection_matrix); + + float_t v5 = tanf(camera_data->fov * 0.5f * DEG_TO_RAD_FLOAT); + light_set* set = &light_set_data[LIGHT_SET_MAIN]; + light_data* data = &set->lights[LIGHT_SUN]; + + vec3 position; + vec4 emission; + if (data->get_type() == LIGHT_PARALLEL) { + data->get_position(position); + data->get_diffuse(emission); + } + else { + set->lights[LIGHT_STAGE].get_position(position); + position = vec3::normalize(position) * 500.0f; + set->lights[LIGHT_STAGE].get_ibl_color0(emission); + data->set_type(LIGHT_PARALLEL); + data->set_position(position); + data->set_diffuse(emission); + } + + vec4 v44; + *(vec3*)&v44 = position; + v44.w = 1.0f; + + mat4_transform_vector(&view_projection_matrix, &v44, &v44); + + float_t v13 = 1.0f / v44.w; + float_t v14 = v44.x * v13; + float_t v15 = v44.y * v13; + float_t v16 = (float_t)width * 0.01f / (float_t)height; + v14 = clamp_def(v14, -0.99f, 0.99f); + v15 = clamp_def(v15, v16 - 1.0f, 1.0f - v16); + v44.x = v14 * v44.w; + v44.y = v15 * v44.w; + + mat4_transform_vector(&inverse_view_projection_matrix, &v44, &v44); + + void (FASTCALL * pos_scale__get_screen_pos_scale)(vec3 * data, vec3 * trans, __int64 r8, bool apply_offset) + = (void(FASTCALL*)(vec3 * data, vec3 * trans, __int64 r8, bool apply_offset))0x00000001401F7EE0; + pos_scale__get_screen_pos_scale(&lens_flare_pos, &position, 0, false); + + float_t v17 = lens_flare_pos.x - (float_t)width * 0.5f; + float_t v19 = v5 / (float_t)height * 0.5f; + float_t v20 = lens_flare_pos.y - (float_t)height * 0.5f; + + float_t v22 = sqrtf(v17 * v19 * v17 * v19 + v20 * v19 * v20 * v19 + 1.0f); + float_t v23 = ((float_t)render_width[0] * (flt_1411ACB8C / v5)) * (v22 * v22 * 0.5f) + * ((float_t)render_height[0] * (flt_1411ACB8C / v5)); + float_t v24 = vec3::distance(position, view_point) * flt_1411ACB84; + emission *= 1.0f / (float_t)(1.0f - cosf((float_t)(3.0 * DEG_TO_RAD))); + + sun_quad_shader_data shader_data = {}; + shader_data.g_emission = emission; + + gl_state_active_bind_texture_2d(0, tex); + shaders_ft.set(SHADER_FT_SUN); + gl_state_bind_vertex_array(rctx->common_vao); + rctx->sun_quad_ubo.Bind(0); + + int32_t query_index = (lens_flare_query_index + 1) % 3; + lens_flare_query_index = query_index; + int32_t next_query_index = (query_index + 2) % 3; + + if (lens_shaft_query_data[next_query_index] == -1) + lens_shaft_query_data[next_query_index] = 0; + + if (lens_flare_query_data[next_query_index] == -1) + lens_flare_query_data[next_query_index] = 0; + + gl_state_set_color_mask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE); + gl_state_set_depth_mask(GL_FALSE); + gl_state_disable_cull_face(); + + mat4 mat; + mat4_mul_translate(&view_matrix, &position, &mat); + mat4_clear_rot(&mat, &mat); + mat4_scale_rot(&mat, v24 * 0.2f, &mat); + mat4_mul(&mat, &projection_matrix, &mat); + + mat4_transpose(&mat, &mat); + shader_data.g_transform[0] = mat.row0; + shader_data.g_transform[1] = mat.row1; + shader_data.g_transform[2] = mat.row2; + shader_data.g_transform[3] = mat.row3; + rctx->sun_quad_ubo.WriteMemory(shader_data); + + glBeginQuery(GL_SAMPLES_PASSED, lens_shaft_query[next_query_index]); + shaders_ft.draw_arrays(GL_TRIANGLE_STRIP, 0, 4); + glEndQuery(GL_SAMPLES_PASSED); + + mat4_mul_translate(&view_matrix, (vec3*)&v44, &mat); + mat4_clear_rot(&mat, &mat); + mat4_scale_rot(&mat, v24 * 2.0f, &mat); + mat4_mul(&mat, &projection_matrix, &mat); + + mat4_transpose(&mat, &mat); + shader_data.g_transform[0] = mat.row0; + shader_data.g_transform[1] = mat.row1; + shader_data.g_transform[2] = mat.row2; + shader_data.g_transform[3] = mat.row3; + rctx->sun_quad_ubo.WriteMemory(shader_data); + + glBeginQuery(GL_SAMPLES_PASSED, lens_flare_query[next_query_index]); + shaders_ft.draw_arrays(GL_TRIANGLE_STRIP, 0, 4); + glEndQuery(GL_SAMPLES_PASSED); + + gl_state_set_color_mask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); + gl_state_set_depth_mask(GL_TRUE); + gl_state_enable_cull_face(); + + if (lens_shaft_query_data[query_index] != -1) { + int32_t res = 0; + glGetQueryObjectiv(lens_shaft_query[query_index], GL_QUERY_RESULT_AVAILABLE, &res); + if (res) + glGetQueryObjectuiv(lens_shaft_query[query_index], GL_QUERY_RESULT, &lens_shaft_query_data[query_index]); + } + + if (lens_flare_query_data[query_index] != -1) { + int32_t res = 0; + glGetQueryObjectiv(lens_flare_query[query_index], GL_QUERY_RESULT_AVAILABLE, &res); + if (res) + glGetQueryObjectuiv(lens_flare_query[query_index], GL_QUERY_RESULT, &lens_flare_query_data[query_index]); + } + + if (emission.x + emission.y + emission.z > 0.0f) { + gl_state_enable_blend(); + gl_state_set_blend_func(GL_ONE, GL_ONE); + gl_state_set_depth_mask(GL_FALSE); + + mat4_mul_translate(&view_matrix, &position, &mat); + mat4_clear_rot(&mat, &mat); + mat4_scale_rot(&mat, v24 * 1.1f, &mat); + mat4_mul(&mat, &projection_matrix, &mat); + + mat4_transpose(&mat, &mat); + shader_data.g_transform[0] = mat.row0; + shader_data.g_transform[1] = mat.row1; + shader_data.g_transform[2] = mat.row2; + shader_data.g_transform[3] = mat.row3; + rctx->sun_quad_ubo.WriteMemory(shader_data); + + shaders_ft.draw_arrays(GL_TRIANGLE_STRIP, 0, 4); + + gl_state_disable_blend(); + gl_state_set_blend_func(GL_ONE, GL_ZERO); + gl_state_set_depth_mask(GL_TRUE); + } + + gl_state_active_bind_texture_2d(0, 0); + gl_state_bind_vertex_array(0); + + if (lens_flare_appear_power <= 0.01f) + lens_flare_appear_power = 0.0; + else + lens_flare_appear_power *= 0.93f; + lens_shaft_scale = 100.0f; + lens_flare_power = 0.0f; + + float_t v34 = lens_flare_pos.x; + float_t v35 = lens_flare_pos.y; + float_t v32 = lens_flare_pos.z; + + float_t v33 = 0.0f; + if (v32 >= 0.0f + || v34 < (float_t)-width || v34 >(float_t)(2 * width) + || v35 < (float_t)-height || v35 >(float_t)(2 * height)) + lens_flare_texture = 0; + else { + for (GLuint& i : lens_flare_query_data) + if (i != -1) + v33 += min_def((float_t)i, v23); + v33 /= (v23 * 3.0f); + lens_flare_power = powf(v33, 0.7f); + + if (v33 > 0.0f && lens_shaft_query_data[query_index]) { + float_t v41 = max_def(v33 - 0.4f, 0.005f); + lens_shaft_scale = ((0.6f / v41) * lens_shaft_inv_scale) * (v5 * 3.4f); + } + } + + if (v32 >= 0.0f + || v34 < -12.0f || v34 >(float_t)(width + 12) + || v35 < -12.0f || v35 >(float_t)(height + 12)) { + field_A10 = 0.0f; + } + else if (v34 > -2.0f && v34 < (float_t)(width + 2) + && v35 > -2.0f && v35 < (float_t)(height + 2)) { + if (v33 > 0.4f && field_A10 == 0.0f && lens_flare_appear_power < 0.02f && !reset_exposure) + lens_flare_appear_power = 8.0f; + field_A10 = 1.0f; + } + } + + void Render::free() { + if (transparency) { + delete transparency; + transparency = 0; + } + + for (int32_t i = 0; i < 1; i++) + if (transparency_tex[i]) { + texture_free(transparency_tex[i]); + transparency_tex[i] = 0; + texture_counter--; + } + + if (dof) { + delete dof; + dof = 0; + } + + if (!texture_counter) + return; + + for (int32_t i = 0; i < downsample_max_count; i++) + rend_texture[i].Free(); + + for (int32_t i = 0; i < 3; i++) { + taa_buffer[i].Free(); + + if (taa_tex[i]) { + texture_free(taa_tex[i]); + taa_tex[i] = 0; + texture_counter--; + } + } + + aet_back_texture.Free(); + + if (aet_back_tex) { + texture_free(aet_back_tex); + aet_back_tex = 0; + texture_counter--; + } + + mlaa_buffer.Free(); + temp_buffer.Free(); + + sss_contour_texture = 0; + + downsample_texture.Free(); + field_3E8.Free(); + + for (int32_t i = 0; i < 5; i++) + reduce_texture->Free(); + + for (int32_t i = 0; i < 5; i++) + if (reduce_tex[i]) { + texture_free(reduce_tex[i]); + reduce_tex[i] = 0; + texture_counter--; + } + + if (exposure_history) { + texture_free(exposure_history); + exposure_history = 0; + texture_counter--; + } + + exposure_texture.Free(); + + if (exposure_tex) { + glDeleteTextures(1, &exposure_tex); + exposure_tex = 0; + } + + if (tonemap_lut_texture) { + glDeleteTextures(1, &tonemap_lut_texture); + tonemap_lut_texture = 0; + } + if (mlaa_area_texture) { + glDeleteTextures(1, &mlaa_area_texture); + mlaa_area_texture = 0; + } + + glDeleteQueries(3, lens_shaft_query); + glDeleteQueries(3, lens_flare_query); + + for (ExposureCharaData& i : exposure_chara_data) { + glDeleteQueries(3, i.query); + i.query[0] = 0; + } + } + + void Render::init_render_buffers(int32_t width, int32_t height, + int32_t ssaa, int32_t hd_res, int32_t ss_alpha_mask) { + this->ssaa = ssaa; + this->hd_res = hd_res; + this->ss_alpha_mask = ss_alpha_mask; + + mlaa = 1; + taa = ssaa || ss_alpha_mask ? 0 : 1; + mag_filter = hd_res ? MAG_FILTER_SHARPEN_4_TAP : MAG_FILTER_BILINEAR; + + this->width = width; + this->height = height; + + if (ssaa) { + inner_width = 2 * width; + inner_height = 2 * height; + } + else { + inner_width = width; + inner_height = height; + } + + screen_x_offset = 0; + screen_y_offset = 0; + + screen_width = width; + screen_height = height; + reduce_width[0] = 256; + reduce_height[0] = 144; + reduce_width[1] = 128; + reduce_height[1] = 72; + reduce_width[2] = 64; + reduce_height[2] = 36; + reduce_width[3] = 32; + reduce_height[3] = 18; + reduce_width[4] = 8; + reduce_height[4] = 8; + + update_res(true, 1); + + rend_texture[0].Init(render_post_width[0], render_post_height[0], 0, GL_RGBA16F, GL_DEPTH_COMPONENT24); + + gl_state_bind_texture_2d(rend_texture[0].GetColorTex()); + glTexParameteriDLL(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + + gl_state_bind_texture_2d(rend_texture[0].GetDepthTex()); + GLint swizzle[] = { GL_RED, GL_RED, GL_RED, GL_ONE }; + glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_RGBA, swizzle); + + for (int32_t i = 0; i < 3; i++) { + taa_tex[i] = texture_load_tex_2d(texture_id(0x25, texture_counter++), + GL_RGBA8, render_post_width[0], render_post_height[0], 0, 0, 0); + taa_buffer[i].SetColorDepthTextures(taa_tex[i]->tex, 0, rend_texture[0].GetDepthTex()); + } + + aet_back_tex = texture_load_tex_2d(texture_id(0x25, texture_counter++), + GL_RGBA8, render_post_width[0], render_post_height[0], 0, 0, 0); + aet_back_texture.SetColorDepthTextures(aet_back_tex->tex, 0, rend_texture[0].GetDepthTex()); + + mlaa_buffer.Init(render_post_width[0], render_post_height[0], 0, GL_RGBA8, GL_DEPTH_COMPONENT24); + temp_buffer.Init(render_post_width[0], render_post_height[0], 0, GL_RGBA8, GL_ZERO); + sss_contour_texture = &mlaa_buffer; + + gl_state_bind_texture_2d(mlaa_buffer.GetDepthTex()); + glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_RGBA, swizzle); + + for (int32_t i = 1; i < downsample_count; i++) { + rend_texture[i].Init(render_post_width[i], render_post_height[i], 0, GL_RGBA16F, GL_ZERO); + + gl_state_bind_texture_2d(rend_texture[i].GetColorTex()); + glTexParameteriDLL(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + } + + downsample_texture.Init(reduce_width[0], reduce_height[0], 0, GL_RGBA16F, GL_ZERO); + + gl_state_bind_texture_2d(downsample_texture.GetColorTex()); + + const vec4 border_color = 0.0f; + glTexParameterfvDLL(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, (GLfloat*)&border_color); + glTexParameteriDLL(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER); + glTexParameteriDLL(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER); + + field_3E8.Init(512, 256, 0, GL_RGBA8, GL_ZERO); + + renderer::DOF3* (FASTCALL * renderer__DOF3__DOF3)(renderer::DOF3 * dof, int32_t width, int32_t height) + = (renderer::DOF3 * (FASTCALL*)(renderer::DOF3 * dof, int32_t width, int32_t height))0x00000001404A81F0; + renderer::DOF3* dof = new renderer::DOF3; + this->dof = renderer__DOF3__DOF3(dof, render_post_width[0], render_post_height[0]); + + transparency_tex[0] = texture_load_tex_2d(texture_id(0x25, texture_counter++), + GL_RGBA16F, render_post_width[0], render_post_height[0], 0, 0, 0); + + renderer::Transparency* (FASTCALL * renderer__Transparency__Transparency)( + renderer::Transparency * transparency, GLuint color_texture, + GLuint depth_texture, int32_t width, int32_t height) + = (renderer::Transparency * (FASTCALL*)(renderer::Transparency * transparency, + GLuint color_texture, GLuint depth_texture, int32_t width, int32_t height))0x00000001404A88F0; + renderer::Transparency* transparency = new renderer::Transparency; + memset(transparency, 0, sizeof(*transparency)); + this->transparency = renderer__Transparency__Transparency(transparency, transparency_tex[0]->tex, + rend_texture[0].GetDepthTex(), render_post_width[0], render_post_height[0]); + } + + void Render::init_tone_map_buffers() { + for (int32_t i = 0; i < 5; i++) { + reduce_tex[i] = texture_load_tex_2d(texture_id(0x25, texture_counter++), + GL_RGBA16F, reduce_width[i], reduce_height[i], 0, 0, 0); + gl_state_bind_texture_2d(reduce_tex[i]->tex); + + const vec4 border_color = 0.0f; + glTexParameterfvDLL(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, (GLfloat*)&border_color); + glTexParameteriDLL(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER); + glTexParameteriDLL(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER); + } + + reduce_texture[0].SetColorDepthTextures(reduce_tex[0]->tex); + + exposure_history = texture_load_tex_2d(texture_id(0x25, texture_counter++), + GL_R32F, 32, 1, 0, 0, 0); + + glGenTextures(1, &exposure_tex); + gl_state_bind_texture_2d(exposure_tex); + glTexImage2DDLL(GL_TEXTURE_2D, 0, GL_R32F, 2, 2, 0, GL_RED, GL_FLOAT, 0); + glTexParameteriDLL(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); + glTexParameteriDLL(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); + glTexParameteriDLL(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); + glTexParameteriDLL(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); + gl_state_bind_texture_2d(0); + + exposure_texture.SetColorDepthTextures(exposure_tex); + + glGenTextures(1, &tonemap_lut_texture); + gl_state_bind_texture_2d(tonemap_lut_texture); + glTexImage2DDLL(GL_TEXTURE_2D, 0, GL_RG16F, 16 * TONE_MAP_SAT_GAMMA_SAMPLES, 1, 0, GL_RG, GL_HALF_FLOAT, 0); + glTexParameteriDLL(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + glTexParameteriDLL(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + glTexParameteriDLL(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); + glTexParameteriDLL(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); + const GLint swizzle[] = { GL_RED, GL_RED, GL_RED, GL_GREEN }; + glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_RGBA, swizzle); + gl_state_bind_texture_2d(0); + + generate_mlaa_area_texture(this); + + glGenQueries(3, lens_shaft_query); + glGenQueries(3, lens_flare_query); + + for (GLuint& i : lens_shaft_query_data) + i = -1; + + for (GLuint& i : lens_flare_query_data) + i = -1; + + for (ExposureCharaData& i : exposure_chara_data) { + glGenQueries(3, i.query); + for (GLuint& j : i.query_data) + j = -1; + } + } + + void Render::resize(int32_t width, int32_t height) { + this->width = width; + this->height = height; + + if (ssaa) { + inner_width = 2 * width; + inner_height = 2 * height; + } + else { + inner_width = width; + inner_height = height; + } + + screen_x_offset = 0; + screen_y_offset = 0; + + screen_width = width; + screen_height = height; + + update_res(true, 1); + + rend_texture[0].Init(render_post_width[0], render_post_height[0], 0, GL_RGBA16F, GL_DEPTH_COMPONENT24); + + gl_state_bind_texture_2d(rend_texture[0].GetColorTex()); + glTexParameteriDLL(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + + gl_state_bind_texture_2d(rend_texture[0].GetDepthTex()); + GLint swizzle[] = { GL_RED, GL_RED, GL_RED, GL_ONE }; + glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_RGBA, swizzle); + + for (int32_t i = 0; i < 3; i++) { + texture_free(taa_tex[i]); + taa_tex[i] = texture_load_tex_2d(texture_id(0x25, texture_counter++), + GL_RGBA8, render_post_width[0], render_post_height[0], 0, 0, 0); + taa_buffer[i].SetColorDepthTextures(taa_tex[i]->tex, 0, rend_texture[0].GetDepthTex()); + } + + texture_free(aet_back_tex); + aet_back_tex = texture_load_tex_2d(texture_id(0x25, texture_counter++), + GL_RGBA8, render_post_width[0], render_post_height[0], 0, 0, 0); + aet_back_texture.SetColorDepthTextures(aet_back_tex->tex, 0, rend_texture[0].GetDepthTex()); + + mlaa_buffer.Init(render_post_width[0], render_post_height[0], 0, GL_RGBA8, GL_DEPTH_COMPONENT24); + temp_buffer.Init(render_post_width[0], render_post_height[0], 0, GL_RGBA8, GL_ZERO); + sss_contour_texture = &mlaa_buffer; + + gl_state_bind_texture_2d(mlaa_buffer.GetDepthTex()); + glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_RGBA, swizzle); + + for (int32_t i = 1; i < downsample_count; i++) { + rend_texture[i].Init(render_post_width[i], render_post_height[i], 0, GL_RGBA16F, GL_ZERO); + + gl_state_bind_texture_2d(rend_texture[i].GetColorTex()); + glTexParameteriDLL(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + } + + dof->resize(render_post_width[0], render_post_height[0]); + + for (int32_t i = 0; i < 1; i++) + if (transparency_tex[i]) { + texture_free(transparency_tex[i]); + transparency_tex[i] = 0; + texture_counter--; + } + + transparency_tex[0] = texture_load_tex_2d(texture_id(0x25, texture_counter++), + GL_RGBA16F, render_post_width[0], render_post_height[0], 0, 0, 0); + transparency->resize(transparency_tex[0]->tex, rend_texture[0].GetDepthTex(), + render_post_width[0], render_post_height[0]); + } + + void Render::downsample() { + uniform->arr[U_REDUCE] = 1; + shaders_ft.set(SHADER_FT_REDUCE); + for (int32_t i = 1; i < downsample_count - 1; i++) { + rend_texture[i].Bind(); + gl_state_active_bind_texture_2d(0, rend_texture[i - 1].GetColorTex()); + glViewportDLL(0, 0, render_width[i], render_height[i]); + draw_quad( + render_post_width[i - 1], render_post_height[i - 1], + render_post_width_scale, render_post_height_scale, + 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f); + } + + uniform->arr[U_REDUCE] = 3; + shaders_ft.set(SHADER_FT_REDUCE); + + int32_t downsample = max_def(downsample_count - 2, 0); + glViewportDLL(0, 0, reduce_width[0], reduce_height[0]); + reduce_texture[0].Bind(); + gl_state_active_bind_texture_2d(0, rend_texture[downsample].GetColorTex()); + draw_quad( + render_post_width[downsample], render_post_height[downsample], + render_post_width_scale, render_post_height_scale, + 0.0f, 0.0f, 1.0f, 1.1f, 1.1f, 1.1f, 0.0f); + + downsample_texture.Bind(); + gl_state_active_bind_texture_2d(0, reduce_tex[0]->tex); + for (int32_t i = 1; i < 5; i++) { + float_t scale; + if (i == 4) { + scale = 1.0f; + uniform->arr[U_EXPOSURE] = 0; + shaders_ft.set(SHADER_FT_EXPOSURE); + } + else + { + scale = 0.75; + uniform->arr[U_REDUCE] = 1; + shaders_ft.set(SHADER_FT_REDUCE); + } + + glViewportDLL(0, 0, reduce_width[i], reduce_height[i]); + draw_quad(reduce_width[i - 1], reduce_height[i - 1], + 1.0f, 1.0f, 0.0f, 0.0f, scale, 1.0f, 1.0f, 1.0f, 1.0f); + gl_state_active_bind_texture_2d(0, reduce_tex[i]->tex); + glCopyTexSubImage2DDLL(GL_TEXTURE_2D, 0, 0, 0, 0, 0, reduce_width[i], reduce_height[i]); + } + } + + void Render::transparency_combine(float_t alpha) { + transparency->combine(rend_texture, alpha); + } + + void Render::transparency_copy() { + transparency->copy(rend_texture[0].GetColorTex()); + } + + void Render::update_res(bool set, int32_t base_downsample) { + int32_t hd_res_widths[4]; + int32_t hd_res_heights[4]; + hd_res_widths[0] = 1280; + hd_res_heights[0] = 720; + hd_res_widths[1] = 1024; + hd_res_heights[1] = 576; + hd_res_widths[2] = 1024; + hd_res_heights[2] = 576; + hd_res_widths[3] = 960; + hd_res_heights[3] = 544; + + base_downsample = min_def(base_downsample, 3); + + if (set) + this->base_downsample = base_downsample; + else + base_downsample = max_def(base_downsample, this->base_downsample); + + base_downsample = clamp_def(base_downsample, 0, 3); + + int32_t hd_res_width = hd_res_widths[base_downsample]; + int32_t hd_res_height = hd_res_heights[base_downsample]; + if (hd_res && (screen_width > hd_res_width || screen_height > hd_res_height)) { + render_width[0] = hd_res_width; + render_height[0] = hd_res_height; + + if (set) { + inner_width = render_width[0]; + inner_height = render_height[0]; + } + } + else { + /*float_t round_val = ssaa ? 1.0f : 16.0f; + render_width[0] = (int32_t)(prj::ceilf((float_t)screen_width + * (float_t)inner_width / (float_t)width * (1.0f / round_val)) * round_val); + render_height[0] = (int32_t)(prj::ceilf((float_t)screen_height + * (float_t)inner_height / (float_t)height * (1.0f / round_val)) * round_val);*/ + + render_width[0] = (int32_t)prj::ceilf((float_t)screen_width + * (float_t)inner_width / (float_t)width); + render_height[0] = (int32_t)prj::ceilf((float_t)screen_height + * (float_t)inner_height / (float_t)height); + } + + int32_t downsample = 1; + for (int32_t i = 0; i < 4; i++) { + int32_t width = (render_width[i] + 1) / 2; + int32_t height = (render_height[i] + 1) / 2; + if (width <= reduce_width[0] && height <= reduce_height[0]) + break; + + render_width[i + 1] = width; + render_height[i + 1] = height; + downsample++; + } + this->downsample_count = downsample; + + if (set) { + downsample_max_count = downsample; + for (int32_t i = 0; i < downsample; i++) { + render_post_width[i] = render_width[i]; + render_post_height[i] = render_height[i]; + } + } + + render_post_width_scale = (float_t)render_width[0] / (float_t)render_post_width[0]; + render_post_height_scale = (float_t)render_height[0] / (float_t)render_post_height[0]; + + taa_blend = -1.0f; + } + + void Render::apply_mlaa(int32_t ss_alpha_mask) { + gl_state_begin_event("PostProcess::mlaa"); + mlaa_buffer.Bind(); + gl_state_active_bind_texture_2d(0, taa_tex[2]->tex); + gl_state_bind_sampler(0, rctx->render_samplers[1]); + uniform->arr[U_MLAA] = 0; + shaders_ft.set(SHADER_FT_MLAA); + draw_quad(render_post_width[0], render_post_height[0], + render_post_width_scale, render_post_height_scale, + 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f); + + temp_buffer.Bind(); + gl_state_active_bind_texture_2d(0, mlaa_buffer.GetColorTex()); + gl_state_active_bind_texture_2d(1, mlaa_area_texture); + gl_state_bind_sampler(0, rctx->render_samplers[0]); + gl_state_bind_sampler(1, rctx->render_samplers[1]); + uniform->arr[U_MLAA] = 1; + uniform->arr[U_MLAA_SEARCH] = 2; + shaders_ft.set(SHADER_FT_MLAA); + draw_quad(render_post_width[0], render_post_height[0], + render_post_width_scale, render_post_height_scale, + 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f); + + RenderTexture& buf_texture = rctx->render_buffer; + buf_texture.Bind(); + gl_state_active_bind_texture_2d(0, taa_tex[2]->tex); + gl_state_active_bind_texture_2d(1, temp_buffer.GetColorTex()); + gl_state_bind_sampler(0, rctx->render_samplers[1]); + uniform->arr[U_MLAA] = 2; + uniform->arr[U_ALPHA_MASK] = ss_alpha_mask ? 1 : 0; + shaders_ft.set(SHADER_FT_MLAA); + draw_quad(render_post_width[0], render_post_height[0], + render_post_width_scale, render_post_height_scale, + 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f); + uniform->arr[U_ALPHA_MASK] = 0; + gl_state_active_bind_texture_2d(0, 0); + gl_state_active_bind_texture_2d(1, 0); + + fbo_blit(buf_texture.fbos[0], taa_buffer[2].fbos[0], + 0, 0, buf_texture.GetWidth(), buf_texture.GetHeight(), + 0, 0, taa_tex[2]->width, taa_tex[2]->height, GL_COLOR_BUFFER_BIT, GL_LINEAR); + gl_state_end_event(); + } + + void Render::apply_tone_map() { + if (!this) + return; + + gl_state_begin_event("PostProcess::tone_map"); + + update_tone_map_lut(); + + uniform->arr[U_TONE_MAP] = (int32_t)tone_map; + uniform->arr[U_FLARE] = 0; + uniform->arr[U_SCENE_FADE] = scene_fade_alpha[scene_fade_index] > 0.01f ? 1 : 0; + uniform->arr[U_AET_BACK] = 0; + uniform->arr[U_LIGHT_PROJ] = 0; + //uniform->arr[U25] = 0; + + gl_state_active_bind_texture_2d(0, rend_texture[0].GetColorTex()); + gl_state_active_bind_texture_2d(1, reduce_tex_draw); + gl_state_active_bind_texture_2d(2, tonemap_lut_texture); + gl_state_active_bind_texture_2d(3, exposure_tex); + gl_state_active_bind_texture_2d(4, rctx->empty_texture_2d); + gl_state_active_bind_texture_2d(5, rctx->empty_texture_2d); + gl_state_active_bind_texture_2d(6, rctx->empty_texture_2d); + + if (aet_back) { + gl_state_active_bind_texture_2d(6, aet_back_tex->tex); + uniform->arr[U_AET_BACK] = 1; + } + + static texture* (FASTCALL * litproj_texture_get)() = (texture * (FASTCALL*)())0x0000000140350600; + texture* light_proj_tex = litproj_texture_get(); + if (light_proj_tex) { + gl_state_active_bind_texture_2d(6, light_proj_tex->tex); + uniform->arr[U_LIGHT_PROJ] = 1; + } + + int32_t scene_fade_blend_func = this->scene_fade_blend_func[scene_fade_index]; + + tone_map_shader_data shader_data; + shader_data.g_exposure.x = exposure * exposure_rate; + shader_data.g_exposure.y = 0.0625f; + shader_data.g_exposure.z = exposure * exposure_rate * 0.5f; + shader_data.g_exposure.w = auto_exposure ? 1.0f : 0.0f; + shader_data.g_flare_coef.x = (lens_flare * 2.0f) * (lens_flare_appear_power + lens_flare_power); + shader_data.g_flare_coef.y = lens_shaft * 2.0f; + shader_data.g_flare_coef.z = 0.0f; + shader_data.g_flare_coef.w = 0.0f; + *(vec3*)&shader_data.g_fade_color = scene_fade_color[scene_fade_index]; + shader_data.g_fade_color.w = scene_fade_alpha[scene_fade_index]; + if (scene_fade_blend_func == 1 || scene_fade_blend_func == 2) + *(vec3*)&shader_data.g_fade_color *= shader_data.g_fade_color.w; + *(vec3*)&shader_data.g_tone_scale = tone_trans_scale[tone_trans_index]; + *(vec3*)&shader_data.g_tone_offset = tone_trans_offset[tone_trans_index]; + shader_data.g_tone_scale.w = (float_t)scene_fade_blend_func; + shader_data.g_tone_offset.w = gamma > 0.0f ? 2.0f / (gamma * 3.0f) : 0.0f; + + shader_data.g_texcoord_transforms[0] = { 1.0f, 0.0f, 0.0f, 0.0f }; + shader_data.g_texcoord_transforms[1] = { 0.0f, 1.0f, 0.0f, 0.0f }; + shader_data.g_texcoord_transforms[2] = { 1.0f, 0.0f, 0.0f, 0.0f }; + shader_data.g_texcoord_transforms[3] = { 0.0f, 1.0f, 0.0f, 0.0f }; + + if (lens_flare_texture) { + static const vec4 border_color = 0.0f; + + const float_t aspect = (float_t)height / (float_t)width; + + uniform->arr[U_FLARE] = 1; + gl_state_active_bind_texture_2d(4, lens_flare_texture); + gl_state_bind_sampler(4, rctx->render_samplers[2]); + mat4 mat; + mat4_translate(0.5f, 0.5f, 0.0f, &mat); + mat4_scale_rot(&mat, 0.75f, 0.75f, 1.0f, &mat); + mat4_mul_rotate_z(&mat, (lens_flare_pos.x / (float_t)width) + * 25.0f * DEG_TO_RAD_FLOAT, &mat); + mat4_mul_translate(&mat, -((1.0f / (float_t)width) * lens_flare_pos.x), + (lens_flare_pos.y - (float_t)height) * (1.0f / (float_t)width), 0.0f, &mat); + mat4_scale_rot(&mat, 1.0f, aspect, 1.0f, &mat); + mat4_transpose(&mat, &mat); + shader_data.g_texcoord_transforms[4] = mat.row0; + shader_data.g_texcoord_transforms[5] = mat.row1; + + if (lens_shaft_scale < 50.0f) { + uniform->arr[U_FLARE] = 2; + gl_state_active_bind_texture_2d(5, lens_shaft_texture); + gl_state_bind_sampler(5, rctx->render_samplers[2]); + mat4_translate(0.5f, 0.5f, 0.0f, &mat); + mat4_scale_rot(&mat, lens_shaft_scale, lens_shaft_scale, 1.0f, &mat); + mat4_mul_rotate_z(&mat, (lens_flare_pos.x / (float_t)width) + * 60.0f * DEG_TO_RAD_FLOAT, &mat); + mat4_mul_translate(&mat, -((1.0f / (float_t)width) * lens_flare_pos.x), + (lens_flare_pos.y - (float_t)height) * (1.0f / (float_t)width), 0.0f, &mat); + mat4_scale_rot(&mat, 1.0f, aspect, 1.0f, &mat); + mat4_transpose(&mat, &mat); + shader_data.g_texcoord_transforms[6] = mat.row0; + shader_data.g_texcoord_transforms[7] = mat.row1; + } + else { + shader_data.g_texcoord_transforms[6] = { 1.0f, 0.0f, 0.0f, 0.0f }; + shader_data.g_texcoord_transforms[7] = { 0.0f, 1.0f, 0.0f, 0.0f }; + } + } + else { + shader_data.g_texcoord_transforms[4] = { 1.0f, 0.0f, 0.0f, 0.0f }; + shader_data.g_texcoord_transforms[5] = { 0.0f, 1.0f, 0.0f, 0.0f }; + shader_data.g_texcoord_transforms[6] = { 1.0f, 0.0f, 0.0f, 0.0f }; + shader_data.g_texcoord_transforms[7] = { 0.0f, 1.0f, 0.0f, 0.0f }; + } + + if (render_manager->npr_param == 1) { + /*gl_state_active_bind_texture_2d(16, sss_contour_texture->GetColorTex()); + gl_state_bind_sampler(16, rctx->render_samplers[1]); + gl_state_active_bind_texture_2d(17, sss_contour_texture->GetDepthTex()); + gl_state_bind_sampler(17, rctx->render_samplers[1]);*/ + gl_state_active_bind_texture_2d(14, rend_texture[0].GetDepthTex()); + gl_state_bind_sampler(14, rctx->render_samplers[1]); + } + + rctx->tone_map_ubo.WriteMemory(shader_data); + + glViewportDLL(0, 0, render_width[0], render_height[0]); + taa_buffer[2].Bind(); + shaders_ft.set(SHADER_FT_TONEMAP); + rctx->tone_map_ubo.Bind(1); + gl_state_bind_vertex_array(rctx->common_vao); + shaders_ft.draw_arrays(GL_TRIANGLE_STRIP, 0, 4); + gl_state_active_bind_texture_2d(2, 0); + gl_state_end_event(); + } + + + void Render::calc_exposure() { + bool v2 = false; + if (!reset_exposure) { + for (int32_t i = 0; i < ROB_CHARA_COUNT; i++) + exposure_chara_data[i].reset(); + + ExposureCharaData* chara_data = exposure_chara_data; + float_t v18 = (float_t)height / (float_t)width; + float_t v20 = powf(tanf(camera_data->fov * 0.5f * DEG_TO_RAD_FLOAT) * 3.4f, 2.0f); + size_t rob_chara_smth = get_rob_chara_smth(); + for (int32_t i = 0; i < ROB_CHARA_COUNT; i++, chara_data++) { + size_t rob_chr = rob_chara_array_get(rob_chara_smth, i); + if (!rob_chr || !(*(uint8_t*)(rob_chara_smth + 0x440) & 1)) + continue; + + vec4 v34 = { 0.05f, 0.0f, -0.04f, 1.0f }; + vec4 v33 = { 1.0f, 0.0f, 0.0f, 0.0f }; + + mat4 v44 = mat4_identity; + sub_1405163C0(rob_chr, 4, &v44); + + mat4 v42; + mat4 v43; + mat4_mul(&camera_data->view_matrix, &v44, &v42); + mat4_mul(&camera_data->projection_matrix, &v42, &v43); + + vec4 v41; + vec4 v40; + mat4_transform_vector(&v42, &v34, &v41); + mat4_transform_vector(&v43, &v34, &v40); + + float_t v12 = 1.0f / v40.w; + float_t v13 = v40.x * v12; + float_t v14 = v40.y * v12; + if (v41.z >= 0.0f || fabsf(v13) >= 1.0f || fabsf(v14) >= 1.0f) + continue; + + float_t v31 = 0.5f - (fabsf(v14) - 1.0f) * 2.5f; + float_t v32 = 0.5f - (fabsf(v13) - 1.0f) * 2.5f; + + float_t v16; + if (v32 <= v31) + v16 = v32; + else + v16 = v31; + + if (v16 > 1.0f) + v16 = 1.0f; + + vec4 v39; + mat4_transform_vector(&v42, &v33, &v39); + + float_t v17 = (v39.z + 1.0f) * 0.5f; + if (v17 > 0.8f) + v17 = 0.8f; + else if (v17 < 0.2f) + v17 = 0.0f; + + float_t v21 = 0.25f / sqrtf(powf(v20 * 3.4f, 2.0f) * (v41.z * v41.z)); + float_t v22; + if (v21 < 0.055f) { + v22 = (v21 - 0.035f) * 50.0f; + if (v22 < 0.0f) + v22 = 0.0f; + } + else if (v21 > 0.5f) { + v22 = 1.0f - (v21 - 0.5f) * 3.3333333f; + if (v22 < 0.0f) + v22 = 0.0f; + } + else + v22 = 1.0f; + + chara_data->spot_coefficients[0].x = (v13 + v21 * 0.0f * v18 + 1.0f) * 0.5f; + chara_data->spot_coefficients[0].y = (v14 + v21 * 0.1f + 1.0f) * 0.5f; + chara_data->spot_coefficients[0].z = 0.0f; + chara_data->spot_coefficients[0].w = 4.0f; + chara_data->spot_coefficients[1].x = (v13 + v21 * 0.0f * v18 + 1.0f) * 0.5f; + chara_data->spot_coefficients[1].y = (v14 - v21 * 0.3f + 1.0f) * 0.5f; + chara_data->spot_coefficients[1].z = 0.0f; + chara_data->spot_coefficients[1].w = 4.0f; + chara_data->spot_coefficients[2].x = (v13 + v21 * -0.5f * v18 + 1.0f) * 0.5f; + chara_data->spot_coefficients[2].y = (v14 + v21 * -0.5f + 1.0f) * 0.5f; + chara_data->spot_coefficients[2].z = 0.0f; + chara_data->spot_coefficients[2].w = 3.0f; + chara_data->spot_coefficients[3].x = (v13 - v21 * 0.6f * v18 + 1.0f) * 0.5f; + chara_data->spot_coefficients[3].y = (v14 - v21 * 0.1f + 1.0f) * 0.5f; + chara_data->spot_coefficients[3].z = 0.0f; + chara_data->spot_coefficients[3].w = 2.0f; + chara_data->spot_coefficients[4].x = (v13 + v21 * 0.6f * v18 + 1.0f) * 0.5f; + chara_data->spot_coefficients[4].y = (v14 - v21 * 0.1f + 1.0f) * 0.5f; + chara_data->spot_coefficients[4].z = 0.0f; + chara_data->spot_coefficients[4].w = 2.0f; + chara_data->spot_coefficients[5].x = (v13 + v21 * 0.5f * v18 + 1.0f) * 0.5f; + chara_data->spot_coefficients[5].y = (v14 + v21 * -0.5f + 1.0f) * 0.5f; + chara_data->spot_coefficients[5].z = 0.0f; + chara_data->spot_coefficients[5].w = 3.0f; + chara_data->spot_coefficients[6].x = (v13 + v21 * 0.0f * v18 + 1.0f) * 0.5f; + chara_data->spot_coefficients[6].y = (v14 - v21 * 0.8f + 1.0f) * 0.5f; + chara_data->spot_coefficients[6].z = 0.0f; + chara_data->spot_coefficients[6].w = 3.0f; + chara_data->spot_weight = v16 * 1.6f * v17 * v22; + if (chara_data->spot_weight > 0.0f && !chara_data->query_data[exposure_query_index]) + v2 = true; + } + } + + if (!v2 || reset_exposure) { + exposure_measure_shader_data exposure_measure = {}; + exposure_measure.g_spot_weight = { + exposure_chara_data[0].spot_weight, + exposure_chara_data[1].spot_weight, + exposure_chara_data[2].spot_weight, + exposure_chara_data[3].spot_weight + }; + + ExposureCharaData* chara_data = exposure_chara_data; + for (int32_t i = 0; i < 4 && i < ROB_CHARA_COUNT; i++, chara_data++) + for (int32_t j = 0; j < 8; j++) + exposure_measure.g_spot_coefficients[i * 8 + j] = chara_data->spot_coefficients[j]; + rctx->exposure_measure_ubo.WriteMemory(exposure_measure); + + glViewportDLL(0, 0, 1, 1); + downsample_texture.Bind(); + + uniform->arr[U_EXPOSURE] = 1; + shaders_ft.set(SHADER_FT_EXPOSURE); + rctx->exposure_measure_ubo.Bind(1); + gl_state_active_bind_texture_2d(0, reduce_tex[4]->tex); + gl_state_active_bind_texture_2d(1, reduce_tex[2]->tex); + draw_quad(1, 1, 1.0f, 1.0f, + 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f); + + gl_state_active_bind_texture_2d(0, exposure_history->tex); + if (reset_exposure) + glCopyTexSubImage2DDLL(GL_TEXTURE_2D, 0, 0, 0, 0, 0, 32, 1); + else + glCopyTexSubImage2DDLL(GL_TEXTURE_2D, 0, exposure_history_counter, 0, 0, 0, 1, 1); + exposure_history_counter = (exposure_history_counter + 1) % 32; + } + + glViewportDLL(0, 0, 1, 1); + exposure_texture.Bind(); + uniform->arr[U_EXPOSURE] = 2; + shaders_ft.set(SHADER_FT_EXPOSURE); + gl_state_active_bind_texture_2d(0, exposure_history->tex); + draw_quad(1, 1, 1.0f, 1.0f, + 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f); + } + + void Render::calc_gaussian_blur(float_t start, float_t step, + int32_t kernel_size, float_t radius_scale, float_t intensity_scale) { + auto calculate_gaussian_kernel = [&](float_t* gaussian_kernel, + float_t radius, int32_t stride, int32_t offset) { + float_t first_val = (start - step * 0.5f) * 2.0f; + for (int32_t i = 0; i < kernel_size; i++) + gaussian_kernel[i * stride + offset] = 0.0f; + + float_t temp_gaussian_kernel[20]; + float_t s = radius * radius_scale; + s = 1.0f / (2.0f * s * s); + + double_t sum = first_val; + temp_gaussian_kernel[0] = first_val; + float_t val = start; + for (size_t i = 1; i < kernel_size; i++) { + sum += temp_gaussian_kernel[i] = expf(-(val * val * s)) * step; + val += step; + } + + sum = 1.0f / sum; + for (size_t i = 0; i < kernel_size; i++) + gaussian_kernel[i * stride + offset] = (float_t)(temp_gaussian_kernel[i] * sum); + }; + + vec3 gauss[20]; + calculate_gaussian_kernel((float_t*)gauss, radius.x, 3, 0); + calculate_gaussian_kernel((float_t*)gauss, radius.y, 3, 1); + calculate_gaussian_kernel((float_t*)gauss, radius.z, 3, 2); + + vec3 intensity = this->intensity * (intensity_scale * 0.5f); + + gaussian_coef_shader_data gaussian_coef = {}; + for (int32_t i = 0; i < kernel_size && i < 8; i++) { + *(vec3*)&gaussian_coef.g_coef[i] = gauss[i] * intensity; + gaussian_coef.g_coef[i].w = 0.0f; + } + rctx->gaussian_coef_ubo.WriteMemory(gaussian_coef); + } + + static void make_ghost_quad(uint8_t flags, float_t opacity, mat4* mat, float_t*& data) { + const float_t x0 = flags & 0x01 ? 0.5f : 0.0f; + const float_t x1 = flags & 0x01 ? 1.0f : 0.5f; + const float_t y0 = flags & 0x02 ? 0.5f : 0.0f; + const float_t y1 = flags & 0x02 ? 1.0f : 0.5f; + + vec4 p0 = { -0.5f, -0.5f, x0, y0 }; + vec4 p1 = { 0.5f, -0.5f, x1, y0 }; + vec4 p2 = { -0.5f, 0.5f, x0, y1 }; + vec4 p3 = { 0.5f, 0.5f, x1, y1 }; + mat4_transform_point(mat, (vec2*)&p0, (vec2*)&p0); + mat4_transform_point(mat, (vec2*)&p1, (vec2*)&p1); + mat4_transform_point(mat, (vec2*)&p2, (vec2*)&p2); + mat4_transform_point(mat, (vec2*)&p3, (vec2*)&p3); + + *(vec4*)&data[0] = p0; + data[4] = opacity; + *(vec4*)&data[5] = p1; + data[9] = opacity; + *(vec4*)&data[10] = p2; + data[14] = opacity; + *(vec4*)&data[15] = p2; + data[19] = opacity; + *(vec4*)&data[20] = p1; + data[24] = opacity; + *(vec4*)&data[25] = p3; + data[29] = opacity; + data += 30; + } + + void Render::copy_to_frame_texture(GLuint pre_pp_tex, int32_t wight, int32_t height, GLuint post_pp_tex) { + for (Render::FrameTexture& i : frame_texture) { + if (!i.capture) + continue; + + for (auto& j : i.data) { + if (!j.texture || j.render_texture.Bind() < 0) + continue; + + texture* dst_tex = j.texture; + + gl_state_active_bind_texture_2d(0, j.type == FRAME_TEXTURE_PRE_PP ? pre_pp_tex : post_pp_tex); + gl_state_bind_sampler(0, rctx->render_samplers[0]); + glViewportDLL(0, 0, dst_tex->width, dst_tex->height); + uniform->arr[U_REDUCE] = 0; + shaders_ft.set(SHADER_FT_REDUCE); + draw_quad(dst_tex->width, dst_tex->height, + 1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f); + gl_state_bind_framebuffer(0); + } + + i.capture = false; + } + } + + void Render::draw_lens_ghost() { + static const float_t v13[16] = { + -0.70f, -0.30f, 0.35f, 0.50f, + -0.45f, -0.80f, 0.20f, 0.41f, + 0.17f, -0.10f, 0.06f, 0.10f, + 0.14f, 0.04f, -0.13f, -0.22f, + }; + + static const float_t v14[16] = { + 0.8f, 1.0f, 1.0f, 1.0f, + 0.4f, 0.5f, 0.8f, 0.8f, + 0.6f, 0.7f, 0.8f, 0.7f, + 0.8f, 0.7f, 0.6f, 0.8f, + }; + + static const float_t v15[16] = { + 1.3f, 1.5f, 1.00f, 1.1f, + 2.5f, 0.8f, 0.50f, 0.5f, + 0.7f, 0.4f, 0.35f, 0.5f, + 0.4f, 0.3f, 0.60f, 0.4f, + }; + + if (!lens_flare_texture || lens_ghost_count <= 0) + return; + + if (lens_ghost_count > 16) + lens_ghost_count = 16; + + const float_t aspect = (float_t)render_width[0] / (float_t)render_height[0]; + + const float_t v7 = (lens_flare_pos.x - (float_t)(width / 2)) / (float_t)width; + const float_t v8 = -((lens_flare_pos.y - (float_t)(height / 2)) / (float_t)height); + const float_t v9 = (float_t)((1.1 - sqrtf(v8 * v8 + v7 * v7)) * lens_flare_power); + if (v9 < 0.001f) + return; + + const float_t v9a = v9 * v9; + + float_t angle = atan2f(v8, v7) - (float_t)M_PI_2; + const float_t angle_sin = sinf(angle); + const float_t angle_cos = cosf(angle); + + float_t* data = (float_t*)rctx->lens_ghost_vbo.MapMemory(); + if (!data) + return; + + const float_t lens_ghost = this->lens_ghost; + const int32_t lens_ghost_count = this->lens_ghost_count; + for (int32_t i = 0; i < lens_ghost_count; i++) { + float_t opacity = v9 * v14[i] * lens_ghost; + + float_t scale = (v9a * 0.03f + 0.02f) * v15[i]; + + mat4 mat; + mat4_translate(v13[i] * v7 + 0.5f, v13[i] * v8 + 0.5f, 0.0f, &mat); + mat4_scale_rot(&mat, scale, scale * aspect, 1.0f, &mat); + mat4_mul_rotate_z(&mat, angle_sin, angle_cos, &mat); + make_ghost_quad((uint8_t)(i & 0x03), opacity, &mat, data); + } + + rctx->lens_ghost_vbo.UnmapMemory(); + + glViewportDLL(0, 0, render_width[0], render_height[0]); + rend_texture[0].Bind(); + gl_state_enable_blend(); + gl_state_set_blend_func(GL_ONE, GL_ONE); + + uniform->arr[U_REDUCE] = 4; + shaders_ft.set(SHADER_FT_REDUCE); + gl_state_active_bind_texture_2d(0, lens_ghost_texture); + gl_state_bind_vertex_array(rctx->lens_ghost_vao); + shaders_ft.draw_arrays(GL_TRIANGLES, 0, (GLsizei)(lens_ghost_count * 6LL)); + gl_state_bind_vertex_array(0); + + gl_state_disable_blend(); + gl_state_set_blend_func(GL_ONE, GL_ZERO); + } + + void Render::get_blur() { + uniform->arr[U_ALPHA_MASK] = 0; + uniform->arr[U_GAUSS] = 0; + shaders_ft.set(SHADER_FT_GAUSS); + calc_gaussian_blur(1.0f, 1.0f, 7, 0.8f, 1.0f); + rctx->gaussian_coef_ubo.Bind(1); + + downsample_texture.Bind(); + for (int32_t i = 1; i < 4; i++) { + glViewportDLL(0, 0, reduce_width[i], reduce_height[i]); + gl_state_active_bind_texture_2d(0, reduce_tex[i]->tex); + draw_quad(reduce_width[i], reduce_height[i], + 1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 1.0f, 0.0f); + glCopyTexSubImage2DDLL(GL_TEXTURE_2D, 0, 0, 0, 0, 0, reduce_width[i], reduce_height[i]); + } + + for (int32_t i = 1; i < 4; i++) { + glViewportDLL(0, 0, reduce_width[i], reduce_height[i]); + gl_state_active_bind_texture_2d(0, reduce_tex[i]->tex); + draw_quad(reduce_width[i], reduce_height[i], + 1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f); + glCopyTexSubImage2DDLL(GL_TEXTURE_2D, 0, 0, 0, 0, 0, reduce_width[i], reduce_height[i]); + } + + uniform->arr[U_GAUSS] = 1; + shaders_ft.set(SHADER_FT_GAUSS); + + glViewportDLL(0, 0, reduce_width[0], reduce_height[0]); + gl_state_active_bind_texture_2d(0, reduce_tex[0]->tex); + draw_quad(reduce_width[0], reduce_height[0], + 1.0f, 1.0f, 0.0f, 0.0f, 1.0f, + intensity.x * 0.5f, intensity.y * 0.5f, intensity.z * 0.5f, 1.0f); + + uniform->arr[U_REDUCE] = 7; + shaders_ft.set(SHADER_FT_REDUCE); + + glViewportDLL(0, 0, reduce_width[0], reduce_height[0]); + reduce_texture[0].Bind(); + gl_state_active_bind_texture_2d(0, downsample_texture.GetColorTex()); + gl_state_active_bind_texture_2d(1, reduce_tex[1]->tex); + gl_state_active_bind_texture_2d(2, reduce_tex[2]->tex); + gl_state_active_bind_texture_2d(3, reduce_tex[3]->tex); + draw_quad(reduce_width[3], reduce_height[3], + 1.0f, 1.0f, 0.0f, 0.0f, 0.25f, 0.15f, 0.25f, 0.25f, 0.25f); + reduce_tex_draw = reduce_tex[0]->tex; + } + + void Render::update_tone_map_lut() { + if (!update_lut) + return; + + update_lut = false; + saturate_lock = false; + + const float_t tone_map_scale = (float_t)(1.0 / (double_t)TONE_MAP_SAT_GAMMA_SAMPLES); + const int32_t tone_map_size = 16 * TONE_MAP_SAT_GAMMA_SAMPLES; + + vec2 tex_data[16 * TONE_MAP_SAT_GAMMA_SAMPLES]; + float_t gamma_power = gamma * gamma_rate * 1.5f; + int32_t saturate_power = this->saturate_power; + float_t saturate_coeff = this->saturate_coeff[saturate_index]; + + tex_data[0].x = 0.0f; + tex_data[0].y = 0.0f; + for (int32_t i = 1; i < tone_map_size; i++) { + float_t gamma = powf(1.0f - expf((float_t)-i * tone_map_scale), gamma_power); + float_t saturation = gamma * 2.0f - 1.0f; + for (int32_t j = 0; j < saturate_power; j++) { + saturation *= saturation; + saturation *= saturation; + saturation *= saturation; + saturation *= saturation; + } + + tex_data[i].x = gamma; + tex_data[i].y = gamma * saturate_coeff + * ((float_t)TONE_MAP_SAT_GAMMA_SAMPLES / (float_t)i) * (1.0f - saturation); + } + + if (GL_VERSION_4_5) + glTextureSubImage2D(tonemap_lut_texture, 0, 0, 0, + 16 * TONE_MAP_SAT_GAMMA_SAMPLES, 1, GL_RG, GL_FLOAT, tex_data); + else { + gl_state_bind_texture_2d(tonemap_lut_texture); + glTexSubImage2DDLL(GL_TEXTURE_2D, 0, 0, 0, + 16 * TONE_MAP_SAT_GAMMA_SAMPLES, 1, GL_RG, GL_FLOAT, tex_data); + } + } + + static void generate_mlaa_area_texture(Render* rend) { + uint8_t* data = (uint8_t*)malloc(MLAA_SIDE_LEN * MLAA_SIDE_LEN * 2); + if (!data) + return; + + for (int32_t cross2 = 0; cross2 < 5; cross2++) + for (int32_t cross1 = 0; cross1 < 5; cross1++) + calculate_mlaa_area_texture_data(data, cross1, cross2); + + glGenTextures(1, &rend->mlaa_area_texture); + gl_state_bind_texture_2d(rend->mlaa_area_texture); + glPixelStoreiDLL(GL_UNPACK_ALIGNMENT, 1); + glTexImage2DDLL(GL_TEXTURE_2D, 0, GL_RG8, MLAA_SIDE_LEN, MLAA_SIDE_LEN, 0, GL_RG, GL_UNSIGNED_BYTE, data); + gl_state_bind_texture_2d(0); + free(data); + } + + static void calculate_mlaa_area_texture_data(uint8_t* data, int32_t cross1, int32_t cross2) { + uint8_t* _data = &data[(MLAA_SIDE_LEN * MLAA_GRID_SIDE_LEN * cross2 + MLAA_GRID_SIDE_LEN * cross1) * 2]; + for (int32_t dright = 0; dright < MLAA_GRID_SIDE_LEN; dright++) { + for (int32_t dleft = 0; dleft < MLAA_GRID_SIDE_LEN; dleft++) { + float_t val_left = 0.0f; + float_t val_right = 0.0f; + calculate_mlaa_area_texture_data_inner(&val_left, &val_right, cross1, cross2, dleft, dright); + _data[0] = (uint8_t)(val_left * 255.9f); + _data[1] = (uint8_t)(val_right * 255.9f); + _data += 2; + } + _data += MLAA_GRID_SIDE_LEN * 4 * 2; + } + } + + static void calculate_mlaa_area_texture_data_inner(float_t* val_left, + float_t* val_right, int32_t cross1, int32_t cross2, int32_t dleft, int32_t dright) { + auto calc_area_tex_val = [&](int32_t a1, int32_t a2) { + float_t v2 = (float_t)(-0.5 / ((float_t)a2 - 0.5)); + float_t v3 = (float_t)a1 * v2 + 0.5f; + if (a1 >= a2 - 1) + return (v3 * 0.5f) * 0.5f; + else + return ((float_t)(a1 + 1) * v2 + 0.5f + v3) * 0.5f; + }; + + int32_t dist = dleft + dright + 1; + float_t _val_left = 0.0f; + float_t _val_right = 0.0f; + switch (cross2) { + case 0: + switch (cross1) { + case 1: + _val_right = calc_area_tex_val(dleft, min_def(dist, MLAA_GRID_SIDE_LEN)); + break; + case 3: + _val_left = calc_area_tex_val(dleft, min_def(dist, MLAA_GRID_SIDE_LEN)); + break; + } + break; + case 1: + switch (cross1) { + case 0: + _val_right = calc_area_tex_val(dright, min_def(dist, MLAA_GRID_SIDE_LEN)); + break; + case 1: + if (dist % 2) { + int32_t v12 = dist / 2 + 1; + int32_t v15 = dist / 2; + if (dleft < v15) + _val_right = calc_area_tex_val(dleft, v12); + else if (dright < v15) + _val_right = calc_area_tex_val(dright, v12); + else + _val_right = calc_area_tex_val(v15, v12) * 2.0f; + } + else { + int32_t v12 = dist / 2; + float_t v14 = -0.5f / (float_t)v12; + if (dleft >= v12) + _val_right = ((float_t)(dright * 2 + 1) * v14 + 1.0f) * 0.5f; + else + _val_right = ((float_t)(dleft * 2 + 1) * v14 + 1.0f) * 0.5f; + } + break; + case 3: + case 4: + if (dist % 2) { + int32_t v12 = dist / 2 + 1; + int32_t v15 = dist / 2; + if (dleft < v15) + _val_left = calc_area_tex_val(dleft, v12); + else if (dright < v15) + _val_right = calc_area_tex_val(dright, v12); + else + _val_left = _val_right = calc_area_tex_val(v15, v12); + } + else { + int32_t v12 = dist / 2; + float_t v14 = -0.5f / (float_t)v12; + if (dleft < v12) + _val_left = ((float_t)(dleft * 2 + 1) * v14 + 1.0f) * 0.5f; + else + _val_right = ((float_t)(dright * 2 + 1) * v14 + 1.0f) * 0.5f; + } + break; + } + break; + case 3: + switch (cross1) { + case 0: + _val_left = calc_area_tex_val(dright, min_def(dist, MLAA_GRID_SIDE_LEN)); + break; + case 1: + case 4: + if (dist % 2) { + int32_t v12 = dist / 2 + 1; + int32_t v15 = dist / 2; + if (dleft < v15) + _val_right = calc_area_tex_val(dleft, v12); + else if (dright < v15) + _val_left = calc_area_tex_val(dright, v12); + else + _val_left = _val_right = calc_area_tex_val(v15, v12); + } + else { + int32_t v12 = dist / 2; + float_t v14 = -0.5f / (float_t)v12; + if (dleft < v12) + _val_right = ((float_t)(dleft * 2 + 1) * v14 + 1.0f) * 0.5f; + else + _val_left = ((float_t)(dright * 2 + 1) * v14 + 1.0f) * 0.5f; + } + break; + case 3: + if (dist % 2) { + int32_t v12 = dist / 2 + 1; + int32_t v15 = dist / 2; + if (dleft < v15) + _val_left = calc_area_tex_val(dleft, v12); + else if (dright < v15) + _val_left = calc_area_tex_val(dright, v12); + else + _val_left = calc_area_tex_val(v15, v12) * 2.0f; + } + else { + int32_t v12 = dist / 2; + float_t v14 = -0.5f / (float_t)v12; + if (dleft < v12) + _val_left = ((float_t)(dleft * 2 + 1) * v14 + 1.0f) * 0.5f; + else + _val_left = ((float_t)(dright * 2 + 1) * v14 + 1.0f) * 0.5f; + } + break; + } + break; + case 4: + switch (cross1) { + case 1: + if (dist % 2) { + int32_t v12 = dist / 2 + 1; + int32_t v15 = dist / 2; + if (dleft < v15) + _val_right = calc_area_tex_val(dleft, v12); + else if (dright < v15) + _val_left = calc_area_tex_val(dright, v12); + else + _val_left = _val_right = calc_area_tex_val(v15, v12); + } + else { + int32_t v12 = dist / 2; + float_t v14 = -0.5f / (float_t)v12; + if (dleft < v12) + _val_right = ((float_t)(dleft * 2 + 1) * v14 + 1.0f) * 0.5f; + else + _val_left = ((float_t)(dright * 2 + 1) * v14 + 1.0f) * 0.5f; + } + break; + case 3: + if (dist % 2) { + int32_t v12 = dist / 2 + 1; + int32_t v15 = dist / 2; + if (dleft < v15) + _val_left = calc_area_tex_val(dleft, v12); + else if (dright < v15) + _val_right = calc_area_tex_val(dright, v12); + else + _val_left = _val_right = calc_area_tex_val(v15, v12); + } + else { + int32_t v12 = dist / 2; + float_t v14 = -0.5f / (float_t)v12; + if (dleft < v12) + _val_left = ((float_t)(dleft * 2 + 1) * v14 + 1.0f) * 0.5f; + else + _val_right = ((float_t)(dright * 2 + 1) * v14 + 1.0f) * 0.5f; + } + break; + } + break; + } + + *val_left = _val_left; + *val_right = _val_right; + return; + } +} diff --git a/src/DivaGL/render.hpp b/src/DivaGL/render.hpp new file mode 100644 index 0000000..b86a6c6 --- /dev/null +++ b/src/DivaGL/render.hpp @@ -0,0 +1,204 @@ +/* + by korenkonder + GitHub/GitLab: korenkonder +*/ + +#pragma once + +#include "../KKdLib/default.hpp" +#include "../KKdLib/light_param/glow.hpp" +#include "../KKdLib/vec.hpp" +#include "renderer/dof.hpp" +#include "renderer/transparency.hpp" +#include "camera.hpp" +#include "gl_uniform_buffer.hpp" + +namespace rndr { + struct Render { + enum MagFilterType { + MAG_FILTER_NEAREST = 0, + MAG_FILTER_BILINEAR, + MAG_FILTER_SHARPEN_5_TAP, + MAG_FILTER_SHARPEN_4_TAP, + MAG_FILTER_CONE_4_TAP, + MAG_FILTER_CONE_2_TAP, + MAG_FILTER_MAX, + }; + + enum FrameTextureType { + FRAME_TEXTURE_PRE_PP = 0, + FRAME_TEXTURE_POST_PP, + FRAME_TEXTURE_FB, + FRAME_TEXTURE_MAX, + }; + + struct ExposureCharaData { + vec4 spot_coefficients[8]; + float_t spot_weight; + GLuint query[3]; + GLuint query_data[3]; + + void reset(); + }; + + struct FrameTextureData { + texture* texture; + RenderTexture render_texture; + FrameTextureType type; + }; + + struct FrameTexture { + FrameTextureData data[4]; + bool capture; + }; + + int32_t downsample_count; + int32_t downsample_max_count; + int32_t ssaa; + int32_t taa; + int32_t mlaa; + int32_t cam_blur; + int32_t hd_res; + int32_t base_downsample; + int32_t ss_alpha_mask; + RenderTexture rend_texture[5]; + RenderTexture taa_buffer[3]; + texture* taa_tex[3]; + RenderTexture aet_back_texture; + texture* aet_back_tex; + RenderTexture downsample_texture; + RenderTexture reduce_texture[5]; + texture* reduce_tex[5]; + RenderTexture field_340; + GLuint reduce_tex_draw; + RenderTexture exposure_texture; + GLuint exposure_tex; + texture* exposure_history; + RenderTexture field_3B8; + RenderTexture field_3E8; + GLuint tonemap_lut_texture; + RenderTexture mlaa_buffer; + RenderTexture temp_buffer; + GLuint mlaa_area_texture; + RenderTexture* sss_contour_texture; + int32_t texture_counter; + GLuint lens_shaft_query[3]; + GLuint lens_flare_query[3]; + GLuint lens_shaft_query_data[3]; + GLuint lens_flare_query_data[3]; + int32_t lens_flare_query_index; + GLuint lens_flare_texture; + GLuint lens_shaft_texture; + GLuint lens_ghost_texture; + int32_t lens_ghost_count; + int32_t width; + int32_t height; + int32_t inner_width; + int32_t inner_height; + int32_t render_width[5]; + int32_t render_height[5]; + int32_t render_post_width[5]; + int32_t render_post_height[5]; + float_t render_post_width_scale; + float_t render_post_height_scale; + int32_t reduce_width[5]; + int32_t reduce_height[5]; + int32_t taa_texture_selector; + int32_t taa_texture; + float_t taa_blend; + vec3 view_point; + vec3 interest; + vec3 view_point_prev; + vec3 interest_prev; + mat4 cam_view_projection; + mat4 cam_view_projection_prev; + int32_t stage_index; + int32_t stage_index_prev; + bool reset_exposure; + int32_t screen_x_offset; + int32_t screen_y_offset; + int32_t screen_width; + int32_t screen_height; + int32_t update_lut; + int32_t saturate_lock; + ExposureCharaData exposure_chara_data[6]; + int32_t exposure_history_counter; + int32_t exposure_query_index; + vec3 lens_flare_pos; + float_t lens_shaft_scale; + float_t lens_shaft_inv_scale; + float_t lens_flare_power; + float_t field_A10; + float_t lens_flare_appear_power; + texture* render_textures_data[16]; + RenderTexture render_textures[16]; + texture* movie_textures_data[1]; + RenderTexture movie_textures[1]; + int32_t aet_back; + renderer::DOF3* dof; + texture* transparency_tex[1]; + renderer::Transparency* transparency; + int32_t saturate_index; + int32_t scene_fade_index; + int32_t tone_trans_index; + float_t saturate_coeff[2]; + vec3 scene_fade_color[2]; + float_t scene_fade_alpha[2]; + int32_t scene_fade_blend_func[2]; + vec3 tone_trans_scale[2]; + vec3 tone_trans_offset[2]; + vec3 tone_trans_start[2]; + vec3 tone_trans_end[2]; + tone_map_method tone_map; + float_t exposure; + float_t exposure_rate; + int32_t auto_exposure; + float_t gamma; + float_t gamma_rate; + int32_t saturate_power; + MagFilterType mag_filter; + float_t fade_alpha; + int32_t fade; + float_t lens_flare; + float_t lens_shaft; + float_t lens_ghost; + vec3 radius; + vec3 intensity; + int32_t update; + FrameTexture frame_texture[6]; + + void apply_post_process(); + void bind_render_texture(bool aet_back = false); + void calc_exposure_chara_data(); + void calc_projection_matrix(mat4* mat, double_t fov, double_t aspect, double_t z_near, double_t z_far, + double_t left_scale, double_t right_scale, double_t bottom_scale, double_t top_scale); + void ctrl(); + void draw_quad(int32_t width, int32_t height, float_t s0, float_t t0, float_t s1, float_t t1, + float_t scale, float_t param_x, float_t param_y, float_t param_z, float_t param_w); + void draw_lens_flare(); + void free(); + void init_render_buffers(int32_t width, int32_t height, + int32_t ssaa, int32_t hd_res, int32_t ss_alpha_mask); + void init_tone_map_buffers(); + void resize(int32_t width, int32_t height); + void transparency_combine(float_t alpha); + void transparency_copy(); + void update_res(bool set, int32_t base_downsample); + + private: + void apply_mlaa(int32_t ss_alpha_mask); + void apply_tone_map(); + void calc_exposure(); + void calc_gaussian_blur(float_t start, float_t step, + int32_t kernel_size, float_t radius_scale, float_t intensity_scale); + void copy_to_frame_texture(GLuint pre_pp_tex, int32_t wight, int32_t height, GLuint post_pp_tex); + void draw_lens_ghost(); + void downsample(); + void get_blur(); + void update_tone_map_lut(); + }; + + static_assert(sizeof(rndr::Render) == 0x1510, "\"rndr::Render\" struct should have a size of 0x1510"); +} + +extern rndr::Render* render; diff --git a/src/DivaGL/render_context.cpp b/src/DivaGL/render_context.cpp new file mode 100644 index 0000000..9082bb4 --- /dev/null +++ b/src/DivaGL/render_context.cpp @@ -0,0 +1,516 @@ +/* + by korenkonder + GitHub/GitLab: korenkonder +*/ + +#include "render_context.hpp" +#include "render_manager.hpp" + +void draw_state_stats::reset() { + object_draw_count = 0; + object_translucent_draw_count = 0; + object_reflect_draw_count = 0; + field_C = 0; + field_10 = 0; + draw_count = 0; + draw_triangle_count = 0; + field_1C = 0; +} + +draw_state_struct* draw_state = (draw_state_struct*)0x00000001411A32B0; + +render_context* rctx; + +sss_data* (FASTCALL* sss_data_get)() + = (sss_data * (FASTCALL*)())0x0000000140641B70; + +void obj_scene_shader_data::set_g_irradiance_r_transforms(const mat4& mat) { + mat4 temp; + mat4_transpose(&mat, &temp); + g_irradiance_r_transforms[0] = temp.row0; + g_irradiance_r_transforms[1] = temp.row1; + g_irradiance_r_transforms[2] = temp.row2; + g_irradiance_r_transforms[3] = temp.row3; +} + +void obj_scene_shader_data::set_g_irradiance_g_transforms(const mat4& mat) { + mat4 temp; + mat4_transpose(&mat, &temp); + g_irradiance_g_transforms[0] = temp.row0; + g_irradiance_g_transforms[1] = temp.row1; + g_irradiance_g_transforms[2] = temp.row2; + g_irradiance_g_transforms[3] = temp.row3; +} + +void obj_scene_shader_data::set_g_irradiance_b_transforms(const mat4& mat) { + mat4 temp; + mat4_transpose(&mat, &temp); + g_irradiance_b_transforms[0] = temp.row0; + g_irradiance_b_transforms[1] = temp.row1; + g_irradiance_b_transforms[2] = temp.row2; + g_irradiance_b_transforms[3] = temp.row3; +} + +void obj_scene_shader_data::set_g_normal_tangent_transforms(const mat4& mat) { + mat4 temp; + mat4_transpose(&mat, &temp); + g_normal_tangent_transforms[0] = temp.row0; + g_normal_tangent_transforms[1] = temp.row1; + g_normal_tangent_transforms[2] = temp.row2; +} + +void obj_scene_shader_data::set_g_self_shadow_receivers(int32_t index, const mat4& mat) { + size_t _index = index * 3LL; + + mat4 temp; + mat4_transpose(&mat, &temp); + g_self_shadow_receivers[_index + 0] = temp.row0; + g_self_shadow_receivers[_index + 1] = temp.row1; + g_self_shadow_receivers[_index + 2] = temp.row2; +} + +void obj_scene_shader_data::set_g_light_projection(const mat4& mat) { + mat4 temp; + mat4_transpose(&mat, &temp); + g_light_projection[0] = temp.row0; + g_light_projection[1] = temp.row1; + g_light_projection[2] = temp.row2; + g_light_projection[3] = temp.row3; +} + +void obj_scene_shader_data::set_projection_view(const mat4& view, const mat4& proj) { + mat4 temp; + mat4_transpose(&view, &temp); + g_view[0] = temp.row0; + g_view[1] = temp.row1; + g_view[2] = temp.row2; + + mat4_invert(&view, &temp); + mat4_transpose(&temp, &temp); + g_view_inverse[0] = temp.row0; + g_view_inverse[1] = temp.row1; + g_view_inverse[2] = temp.row2; + + mat4_mul(&view, &proj, &temp); + mat4_transpose(&temp, &temp); + g_projection_view[0] = temp.row0; + g_projection_view[1] = temp.row1; + g_projection_view[2] = temp.row2; + g_projection_view[3] = temp.row3; +} + +void obj_batch_shader_data::set_g_joint(const mat4& mat) { + mat4 temp; + mat4_transpose(&mat, &temp); + g_joint[0] = temp.row0; + g_joint[1] = temp.row1; + g_joint[2] = temp.row2; + + mat4_invert(&mat, &temp); + mat4_transpose(&temp, &temp); + g_joint_inverse[0] = temp.row0; + g_joint_inverse[1] = temp.row1; + g_joint_inverse[2] = temp.row2; +} + +void obj_batch_shader_data::set_g_texcoord_transforms(int32_t index, const mat4& mat) { + size_t _index = index * 2LL; + + mat4 temp; + mat4_transpose(&mat, &temp); + g_texcoord_transforms[_index + 0] = temp.row0; + g_texcoord_transforms[_index + 1] = temp.row1; +} + +void obj_batch_shader_data::set_transforms(const mat4& model, const mat4& view, const mat4& proj) { + mat4 temp; + mat4_transpose(&model, &temp); + g_worlds[0] = temp.row0; + g_worlds[1] = temp.row1; + g_worlds[2] = temp.row2; + + mat4_invert(&model, &temp); + g_worlds_invtrans[0] = temp.row0; + g_worlds_invtrans[1] = temp.row1; + g_worlds_invtrans[2] = temp.row2; + + mat4 mv; + mat4_mul(&model, &view, &mv); + + mat4_transpose(&mv, &temp); + g_worldview[0] = temp.row0; + g_worldview[1] = temp.row1; + g_worldview[2] = temp.row2; + + mat4_invert(&mv, &temp); + mat4_transpose(&temp, &temp); + g_worldview_inverse[0] = temp.row0; + g_worldview_inverse[1] = temp.row1; + g_worldview_inverse[2] = temp.row2; + + mat4_mul(&mv, &proj, &temp); + mat4_transpose(&temp, &temp); + g_transforms[0] = temp.row0; + g_transforms[1] = temp.row1; + g_transforms[2] = temp.row2; + g_transforms[3] = temp.row3; +} + +render_context::render_context() : box_vao(), lens_ghost_vao(), common_vao(), +reflect_buffer(), render_buffer(), screen_buffer(), shadow_buffer(), empty_texture_2d(), +empty_texture_cube_map(), samplers(), render_samplers(), sprite_samplers(), sprite_width(), +sprite_height(), screen_x_offset(), screen_y_offset(), screen_width(), screen_height() { + static const float_t box_texcoords[] = { + 1.0f, 0.0f, 0.0f, 1.0f, -1.0f, 0.0f, 0.0f, -1.0f, + 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, + 1.0f, 0.0f, 0.0f, 1.0f, -1.0f, 0.0f, 0.0f, -1.0f, + 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, + 1.0f, 0.0f, 0.0f, 1.0f, -1.0f, 0.0f, 0.0f, -1.0f, + 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, + 1.0f, 0.0f, 0.0f, 1.0f, -1.0f, 0.0f, 0.0f, -1.0f, + 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, + -0.5f, 0.5f, 0.5f, 0.5f, -0.5f, -0.5f, 0.5f, -0.5f, + 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, + -0.5f, 0.5f, 0.5f, 0.5f, -0.5f, -0.5f, 0.5f, -0.5f, + 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, + -0.5f, 0.5f, 0.5f, 0.5f, -0.5f, -0.5f, 0.5f, -0.5f, + 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, + -0.5f, 0.5f, 0.5f, 0.5f, -0.5f, -0.5f, 0.5f, -0.5f, + 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, + 0.5f, -1.5f, -1.5f, 0.5f, 1.5f, -0.5f, -0.5f, 1.5f, + 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, + 0.5f, -1.5f, -1.5f, 0.5f, 1.5f, -0.5f, -0.5f, 1.5f, + 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, + 0.5f, -1.5f, -1.5f, 0.5f, 1.5f, -0.5f, -0.5f, 1.5f, + 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, + 0.5f, -1.5f, -1.5f, 0.5f, 1.5f, -0.5f, -0.5f, 1.5f, + 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, + 3.5f, -3.5f, -1.5f, -3.5f, 1.5f, -1.5f, -3.5f, -1.5f, + 3.5f, 1.5f, -1.5f, 1.5f, 1.5f, 3.5f, -3.5f, 3.5f, + 3.5f, -3.5f, -1.5f, -3.5f, 1.5f, -1.5f, -3.5f, -1.5f, + 3.5f, 1.5f, -1.5f, 1.5f, 1.5f, 3.5f, -3.5f, 3.5f, + 3.5f, -3.5f, -1.5f, -3.5f, 1.5f, -1.5f, -3.5f, -1.5f, + 3.5f, 1.5f, -1.5f, 1.5f, 1.5f, 3.5f, -3.5f, 3.5f, + 3.5f, -3.5f, -1.5f, -3.5f, 1.5f, -1.5f, -3.5f, -1.5f, + 3.5f, 1.5f, -1.5f, 1.5f, 1.5f, 3.5f, -3.5f, 3.5f, + }; + + glGenVertexArrays(1, &box_vao); + gl_state_bind_vertex_array(box_vao); + + box_vbo.Create(sizeof(box_texcoords), box_texcoords); + box_vbo.Bind(); + + glEnableVertexAttribArray(0); + glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, sizeof(float_t) * 16, (void*)0); + glEnableVertexAttribArray(1); + glVertexAttribPointer(1, 4, GL_FLOAT, GL_FALSE, sizeof(float_t) * 16, (void*)(sizeof(float_t) * 4)); + glEnableVertexAttribArray(2); + glVertexAttribPointer(2, 4, GL_FLOAT, GL_FALSE, sizeof(float_t) * 16, (void*)(sizeof(float_t) * 8)); + glEnableVertexAttribArray(3); + glVertexAttribPointer(3, 4, GL_FLOAT, GL_FALSE, sizeof(float_t) * 16, (void*)(sizeof(float_t) * 12)); + + glGenVertexArrays(1, &lens_ghost_vao); + gl_state_bind_vertex_array(lens_ghost_vao); + + lens_ghost_vbo.Create(sizeof(float_t) * 5 * (6 * 16)); + lens_ghost_vbo.Bind(); + + glEnableVertexAttribArray(0); + glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(float_t) * 5, (void*)0); + glEnableVertexAttribArray(1); + glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(float_t) * 5, (void*)(sizeof(float_t) * 2)); + gl_state_bind_array_buffer(0); + gl_state_bind_vertex_array(0); + + glGenVertexArrays(1, &common_vao); + + contour_coef_ubo.Create(sizeof(contour_coef_shader_data)); + contour_params_ubo.Create(sizeof(contour_params_shader_data)); + filter_scene_ubo.Create(sizeof(filter_scene_shader_data)); + esm_filter_batch_ubo.Create(sizeof(esm_filter_batch_shader_data)); + imgfilter_batch_ubo.Create(sizeof(imgfilter_batch_shader_data)); + exposure_measure_ubo.Create(sizeof(exposure_measure_shader_data)); + gaussian_coef_ubo.Create(sizeof(gaussian_coef_shader_data)); + glass_eye_batch_ubo.Create(sizeof(glass_eye_batch_shader_data)); + glitter_batch_ubo.Create(sizeof(glitter_batch_shader_data)); + quad_ubo.Create(sizeof(quad_shader_data)); + sprite_scene_ubo.Create(sizeof(sprite_scene_shader_data)); + sss_filter_gaussian_coef_ubo.Create(sizeof(sss_filter_gaussian_coef_shader_data)); + sun_quad_ubo.Create(sizeof(sun_quad_shader_data)); + tone_map_ubo.Create(sizeof(tone_map_shader_data)); + + obj_scene = {}; + obj_batch = {}; + obj_skinning = {}; + obj_scene_ubo.Create(sizeof(obj_scene_shader_data)); + obj_batch_ubo.Create(sizeof(obj_batch_shader_data)); + obj_skinning_ubo.Create(sizeof(obj_skinning_shader_data)); + + static const uint8_t empty_texture_data[] = { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + }; + + static const GLenum target_cube_map_array[] = { + GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_TEXTURE_CUBE_MAP_NEGATIVE_X, + GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, + GL_TEXTURE_CUBE_MAP_POSITIVE_Z, GL_TEXTURE_CUBE_MAP_NEGATIVE_Z + }; + + glGenTextures(1, &empty_texture_2d); + gl_state_bind_texture_2d(empty_texture_2d); + texture_set_params(GL_TEXTURE_2D, 0, false); + glCompressedTexImage2D(GL_TEXTURE_2D, 0, + GL_COMPRESSED_RGBA_S3TC_DXT1_EXT, 4, 4, 0, 8, empty_texture_data); + gl_state_bind_texture_2d(0); + + glGenTextures(1, &empty_texture_cube_map); + gl_state_bind_texture_cube_map(empty_texture_cube_map); + texture_set_params(GL_TEXTURE_CUBE_MAP, 0, false); + for (int32_t side = 0; side < 6; side++) + glCompressedTexImage2D(target_cube_map_array[side], 0, + GL_COMPRESSED_RGBA_S3TC_DXT1_EXT, 4, 4, 0, 8, empty_texture_data); + gl_state_bind_texture_cube_map(0); + + static const vec4 border_color = 0.0f; + + glGenSamplers(18, samplers); + for (int32_t i = 0; i < 18; i++) { + GLuint sampler = samplers[i]; + + glSamplerParameterfv(sampler, GL_TEXTURE_BORDER_COLOR, (GLfloat*)&border_color); + glSamplerParameteri(sampler, GL_TEXTURE_MIN_FILTER, + i % 2 ? GL_LINEAR_MIPMAP_LINEAR : GL_LINEAR); + glSamplerParameteri(sampler, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + glSamplerParameterf(sampler, GL_TEXTURE_MAX_ANISOTROPY_EXT, 16.0f); + + GLuint wrap_s; + switch (i / 2 % 3) { + case 0: + wrap_s = GL_CLAMP_TO_EDGE; + break; + case 1: + wrap_s = GL_REPEAT; + break; + case 2: + wrap_s = GL_MIRRORED_REPEAT; + break; + } + glSamplerParameteri(sampler, GL_TEXTURE_WRAP_S, wrap_s); + + GLenum wrap_t; + switch (i / 6 % 3) { + case 0: + wrap_t = GL_CLAMP_TO_EDGE; + break; + case 1: + wrap_t = GL_REPEAT; + break; + case 2: + wrap_t = GL_MIRRORED_REPEAT; + break; + } + glSamplerParameteri(sampler, GL_TEXTURE_WRAP_T, wrap_t); + } + + GLuint sampler; + glGenSamplers(3, render_samplers); + sampler = render_samplers[0]; + glSamplerParameteri(sampler, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + glSamplerParameteri(sampler, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + glSamplerParameteri(sampler, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); + glSamplerParameteri(sampler, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); + + sampler = render_samplers[1]; + glSamplerParameteri(sampler, GL_TEXTURE_MAG_FILTER, GL_NEAREST); + glSamplerParameteri(sampler, GL_TEXTURE_MIN_FILTER, GL_NEAREST); + glSamplerParameteri(sampler, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); + glSamplerParameteri(sampler, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); + + sampler = render_samplers[2]; + glSamplerParameteri(sampler, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + glSamplerParameteri(sampler, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + glSamplerParameteri(sampler, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER); + glSamplerParameteri(sampler, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER); + glSamplerParameterfv(sampler, GL_TEXTURE_BORDER_COLOR, (GLfloat*)&border_color); + + glGenSamplers(3, sprite_samplers); + sampler = sprite_samplers[0]; + glSamplerParameteri(sampler, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST); + glSamplerParameteri(sampler, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + glSamplerParameteri(sampler, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); + glSamplerParameteri(sampler, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); + glSamplerParameterf(sampler, GL_TEXTURE_MAX_ANISOTROPY_EXT, 16.0f); + + sampler = sprite_samplers[1]; + glSamplerParameteri(sampler, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST); + glSamplerParameteri(sampler, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + glSamplerParameteri(sampler, GL_TEXTURE_WRAP_S, GL_REPEAT); + glSamplerParameteri(sampler, GL_TEXTURE_WRAP_T, GL_REPEAT); + glSamplerParameterf(sampler, GL_TEXTURE_MAX_ANISOTROPY_EXT, 16.0f); + + sampler = sprite_samplers[2]; + glSamplerParameterfv(sampler, GL_TEXTURE_BORDER_COLOR, (GLfloat*)&border_color); + glSamplerParameteri(sampler, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST); + glSamplerParameteri(sampler, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + glSamplerParameteri(sampler, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER); + glSamplerParameteri(sampler, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER); + glSamplerParameterf(sampler, GL_TEXTURE_MAX_ANISOTROPY_EXT, 16.0f); +} + +render_context::~render_context() { + glDeleteSamplers(3, sprite_samplers); + glDeleteSamplers(3, render_samplers); + glDeleteSamplers(18, samplers); + + glDeleteTextures(1, &empty_texture_cube_map); + glDeleteTextures(1, &empty_texture_2d); + + obj_skinning_ubo.Destroy(); + obj_batch_ubo.Destroy(); + obj_scene_ubo.Destroy(); + + tone_map_ubo.Destroy(); + transparency_batch_ubo.Destroy(); + sun_quad_ubo.Destroy(); + sss_filter_gaussian_coef_ubo.Destroy(); + sprite_scene_ubo.Destroy(); + quad_ubo.Destroy(); + glitter_batch_ubo.Destroy(); + glass_eye_batch_ubo.Destroy(); + gaussian_coef_ubo.Destroy(); + exposure_measure_ubo.Destroy(); + imgfilter_batch_ubo.Destroy(); + esm_filter_batch_ubo.Destroy(); + filter_scene_ubo.Destroy(); + contour_params_ubo.Destroy(); + contour_coef_ubo.Destroy(); + + if (common_vao) { + glDeleteVertexArrays(1, &common_vao); + common_vao = 0; + } + + if (lens_ghost_vao) { + glDeleteVertexArrays(1, &lens_ghost_vao); + lens_ghost_vao = 0; + } + + lens_ghost_vbo.Destroy(); + + if (box_vao) { + glDeleteVertexArrays(1, &box_vao); + box_vao = 0; + } + + box_vbo.Destroy(); +} + +void render_context::ctrl(bool change_res) { + RECT rect; + extern size_t diva_handle; + GetClientRect((HWND)diva_handle, &rect); + + int32_t width = rect.right - rect.left; + int32_t height = rect.bottom - rect.top; + if (screen_width == width && screen_height == height) + return; + + static const double_t aspect = 16.0 / 9.0; + + double_t res_width = (double_t)width; + double_t res_height = (double_t)height; + double_t view_aspect = res_width / res_height; + if (view_aspect < aspect) + res_height = round(res_width / aspect); + else if (view_aspect > aspect) + res_width = round(res_height * aspect); + + int32_t render_width = (int32_t)res_width; + int32_t render_height = (int32_t)res_height; + int32_t sprite_width = (int32_t)res_width; + int32_t sprite_height = (int32_t)res_height; + int32_t screen_width = width; + int32_t screen_height = height; + + //bool render_res_change = render->inner_width != render_width || render->inner_height != render_height; + bool sprite_res_change = this->sprite_width != sprite_width || this->sprite_height != sprite_height; + bool screen_res_change = this->screen_width != screen_width || this->screen_height != screen_height; + + this->sprite_width = sprite_width; + this->sprite_height = sprite_height; + + screen_x_offset = (screen_width - sprite_width) / 2 + (screen_width - sprite_width) % 2; + screen_y_offset = (screen_height - sprite_height) / 2 + (screen_height - sprite_height) % 2; + + this->screen_width = screen_width; + this->screen_height = screen_height; + + if (!change_res || /*!render_res_change && */!sprite_res_change && !screen_res_change) + return; + + /*if (render_res_change) + render.resize(render_width, render_height);*/ + + if (sprite_res_change) + render_manager->resize(sprite_width, sprite_height); + + /*if (render_res_change) + litproj_texture->Init(render_width, render_height, 0, GL_RGBA8, GL_DEPTH_COMPONENT32F);*/ + + /*sprite_manager_set_res((double_t)sprite_width / (double_t)sprite_height, + sprite_width, sprite_height);*/ + + /*if (render_res_change) { + auto init_copy_buffer = [&](RenderTexture& src, RenderTexture& dst) { + dst.Init(src.GetWidth(), + src.GetHeight(), 0, src.color_texture->internal_format, + src.depth_texture ? src.depth_texture->internal_format : GL_ZERO); + }; + + RenderTexture& render_buffer = render->rend_texture[0]; + RenderTexture& reflect_buffer = render_manager->get_render_texture(1); + RenderTexture& shadow_buffer = shadow_ptr_get()->render_textures[1]; + init_copy_buffer(reflect_buffer, this->reflect_buffer); + init_copy_buffer(render_buffer, this->render_buffer); + init_copy_buffer(shadow_buffer, this->shadow_buffer); + }*/ + + if (sprite_res_change) + screen_buffer.Init(sprite_width, sprite_height, 0, GL_RGBA16F, 0); // Was GL_R11F_G11F_B10F +} + +void render_context::free() { + shadow_buffer.Free(); + screen_buffer.Free(); + render_buffer.Free(); + reflect_buffer.Free(); +} + +void render_context::init() { + ctrl(false); + + auto init_copy_buffer = [&](RenderTexture& src, RenderTexture& dst) { + dst.Init(src.GetWidth(), + src.GetHeight(), 0, src.color_texture->internal_format, + src.depth_texture ? src.depth_texture->internal_format : GL_ZERO); + }; + + RenderTexture& render_buffer = render->rend_texture[0]; + RenderTexture& reflect_buffer = render_manager->get_render_texture(1); + RenderTexture& shadow_buffer = shadow_ptr_get()->render_textures[1]; + init_copy_buffer(reflect_buffer, this->reflect_buffer); + init_copy_buffer(render_buffer, this->render_buffer); + init_copy_buffer(shadow_buffer, this->shadow_buffer); + + screen_buffer.Init(sprite_width, sprite_height, 0, GL_RGBA16F, 0); // Was GL_R11F_G11F_B10F +} + +void fbo_blit(GLuint src_fbo, GLuint dst_fbo, + GLint src_x, GLint src_y, GLint src_width, GLint src_height, + GLint dst_x, GLint dst_y, GLint dst_width, GLint dst_height, GLbitfield mask, GLenum filter) { + gl_state_bind_read_framebuffer(src_fbo); + gl_state_bind_draw_framebuffer(dst_fbo); + glBlitFramebuffer(src_x, src_y, src_x + src_width, src_y + src_height, + dst_x, dst_y, dst_x + dst_width, dst_y + dst_height, mask, filter); +} diff --git a/src/DivaGL/render_context.hpp b/src/DivaGL/render_context.hpp new file mode 100644 index 0000000..8aea63c --- /dev/null +++ b/src/DivaGL/render_context.hpp @@ -0,0 +1,331 @@ +/* + by korenkonder + GitHub/GitLab: korenkonder +*/ + +#pragma once + +#include "../KKdLib/default.hpp" +#include "../KKdLib/mat.hpp" +#include "../KKdLib/vec.hpp" +#include "light_param/fog.hpp" +#include "light_param/light.hpp" +#include "mdl/disp_manager.hpp" +#include "camera.hpp" +#include "gl_array_buffer.hpp" +#include "gl_element_array_buffer.hpp" +#include "gl_uniform_buffer.hpp" +#include "render.hpp" +#include "render_manager.hpp" +#include "render_texture.hpp" + +#define TEXTURE_PATTERN_COUNT 24 +#define TEXTURE_TRANSFORM_COUNT 24 + +struct draw_state_stats { + int32_t object_draw_count; + int32_t object_translucent_draw_count; + int32_t object_reflect_draw_count; + int32_t field_C; + int32_t field_10; + int32_t draw_count; + int32_t draw_triangle_count; + int32_t field_1C; + + void reset(); +}; + +struct sss_data { + bool init; + bool enable; + bool npr_contour; + RenderTexture textures[4]; + vec4 param; +}; + +struct draw_state_struct { + draw_state_stats stats; + draw_state_stats stats_prev; + bool vertex_buffer; + bool wireframe; + bool wireframe_overlay; + bool light; + bool self_shadow; + bool shader_debug_flag; + bool use_global_material; + bool fog_height; + bool back_display; + int32_t shader_index; + int32_t show; + float_t bump_depth; + float_t intensity; + float_t reflectivity; + float_t reflect_uv_scale; + float_t refract_uv_scale; + int32_t field_68; + void* curr_obj_sub_mesh_args; + float_t fresnel; + GLuint program_buffer_index; + void* program_buffer_matrix_data; +}; + +struct contour_coef_shader_data { + vec4 g_contour; + vec4 g_near_far; +}; + +struct contour_params_shader_data { + vec4 g_near_far; +}; + +struct filter_scene_shader_data { + vec4 g_transform; + vec4 g_texcoord; +}; + +struct exposure_measure_shader_data { + vec4 g_spot_weight; + vec4 g_spot_coefficients[32]; +}; + +struct gaussian_coef_shader_data { + vec4 g_coef[8]; +}; + +struct esm_filter_batch_shader_data { + vec4 g_params; + vec4 g_gauss[2]; +}; + +struct imgfilter_batch_shader_data { + vec4 g_texture_lod; + vec4 g_color_scale; + vec4 g_color_offset; +}; + +struct glass_eye_batch_shader_data { + vec4 g_ellipsoid_radius; + vec4 g_ellipsoid_scale; + vec4 g_tex_model_param; + vec4 g_tex_offset; + vec4 g_eb_radius; + vec4 g_eb_tex_model_param; + vec4 g_fresnel; + vec4 g_refract1; + vec4 g_refract2; + vec4 g_iris_radius; + vec4 g_cornea_radius; + vec4 g_pupil_radius; + vec4 g_tex_scale; +}; + +struct glitter_batch_shader_data { + vec4 g_mvp[4]; + vec4 g_glitter_blend_color; + vec4 g_state_material_diffuse; + vec4 g_state_material_emission; +}; + +struct obj_scene_shader_data { + vec4 g_irradiance_r_transforms[4]; + vec4 g_irradiance_g_transforms[4]; + vec4 g_irradiance_b_transforms[4]; + vec4 g_light_env_stage_diffuse; + vec4 g_light_env_stage_specular; + vec4 g_light_env_chara_diffuse; + vec4 g_light_env_chara_ambient; + vec4 g_light_env_chara_specular; + vec4 g_light_env_reflect_diffuse; + vec4 g_light_env_reflect_ambient; + vec4 g_light_env_proj_diffuse; + vec4 g_light_env_proj_specular; + vec4 g_light_env_proj_position; + vec4 g_light_stage_dir; + vec4 g_light_stage_diff; + vec4 g_light_stage_spec; + vec4 g_light_chara_dir; + vec4 g_light_chara_spec; + vec4 g_light_chara_luce; + vec4 g_light_chara_back; + vec4 g_light_face_diff; + vec4 g_chara_color_rim; + vec4 g_chara_color0; + vec4 g_chara_color1; + vec4 g_chara_f_dir; + vec4 g_chara_f_ambient; + vec4 g_chara_f_diffuse; + vec4 g_chara_tc_param; + vec4 g_fog_depth_color; + vec4 g_fog_height_params; //x=density, y=start, z=end, w=1/(end-start) + vec4 g_fog_height_color; + vec4 g_fog_bump_params; //x=density, y=start, z=end, w=1/(end-start) + vec4 g_fog_state_params; //x=density, y=start, z=end, w=1/(end-start) + vec4 g_normal_tangent_transforms[3]; + vec4 g_esm_param; + vec4 g_self_shadow_receivers[6]; + vec4 g_shadow_ambient; + vec4 g_shadow_ambient1; + vec4 g_framebuffer_size; + vec4 g_light_reflect_dir; + vec4 g_clip_plane; + vec4 g_npr_cloth_spec_color; + vec4 g_view[3]; + vec4 g_view_inverse[3]; + vec4 g_projection_view[4]; + vec4 g_view_position; + vec4 g_light_projection[4]; + + void set_g_irradiance_r_transforms(const mat4& mat); + void set_g_irradiance_g_transforms(const mat4& mat); + void set_g_irradiance_b_transforms(const mat4& mat); + void set_g_normal_tangent_transforms(const mat4& mat); + void set_g_self_shadow_receivers(int32_t index, const mat4& mat); + void set_g_light_projection(const mat4& mat); + + void set_projection_view(const mat4& view, const mat4& proj); +}; + +struct obj_batch_shader_data { + vec4 g_transforms[4]; + vec4 g_worlds[3]; + vec4 g_worlds_invtrans[3]; + vec4 g_worldview[3]; + vec4 g_worldview_inverse[3]; + vec4 g_joint[3]; + vec4 g_joint_inverse[3]; + vec4 g_texcoord_transforms[4]; + vec4 g_blend_color; + vec4 g_offset_color; + vec4 g_material_state_diffuse; + vec4 g_material_state_ambient; + vec4 g_material_state_emission; + vec4 g_material_state_shininess; + vec4 g_material_state_specular; + vec4 g_fresnel_coefficients; + vec4 g_texture_color_coefficients; + vec4 g_texture_color_offset; + vec4 g_texture_specular_coefficients; + vec4 g_texture_specular_offset; + vec4 g_shininess; + vec4 g_max_alpha; + vec4 g_morph_weight; + vec4 g_sss_param; + vec4 g_bump_depth; + vec4 g_intensity; + vec4 g_reflect_uv_scale; + vec4 g_texture_blend; + + void set_g_joint(const mat4& mat); + void set_g_texcoord_transforms(int32_t index, const mat4& mat); + + void set_transforms(const mat4& model, const mat4& view, const mat4& proj); +}; + +struct obj_skinning_shader_data { + vec4 g_joint_transforms[768]; +}; + +struct quad_shader_data { + vec4 g_texcoord_modifier; + vec4 g_texel_size; + vec4 g_color; + vec4 g_texture_lod; +}; + +struct sprite_scene_shader_data { + mat4 g_transform; + vec4 g_framebuffer_size; +}; + +struct sss_filter_gaussian_coef_shader_data { + vec4 g_param; + vec4 g_coef[64]; +}; + +struct sun_quad_shader_data { + vec4 g_transform[4]; + vec4 g_emission; +}; + +struct tone_map_shader_data { + vec4 g_exposure; + vec4 g_flare_coef; + vec4 g_fade_color; + vec4 g_tone_scale; //xyz=tone_scale, w=fade_func + vec4 g_tone_offset; //xyz=tone_offset, w=inv_tone + vec4 g_texcoord_transforms[8]; +}; + +struct render_context { + mat4 view_mat; + mat4 proj_mat; + mat4 vp_mat; + vec4 g_near_far; + + GLuint box_vao; + GLArrayBuffer box_vbo; + + GLuint lens_ghost_vao; + GLArrayBuffer lens_ghost_vbo; + + GLuint common_vao; + + RenderTexture reflect_buffer; + RenderTexture render_buffer; + RenderTexture screen_buffer; + RenderTexture shadow_buffer; + + GLUniformBuffer contour_coef_ubo; + GLUniformBuffer contour_params_ubo; + GLUniformBuffer filter_scene_ubo; + GLUniformBuffer esm_filter_batch_ubo; + GLUniformBuffer imgfilter_batch_ubo; + GLUniformBuffer exposure_measure_ubo; + GLUniformBuffer gaussian_coef_ubo; + GLUniformBuffer glass_eye_batch_ubo; + GLUniformBuffer glitter_batch_ubo; + GLUniformBuffer quad_ubo; + GLUniformBuffer sprite_scene_ubo; + GLUniformBuffer sss_filter_gaussian_coef_ubo; + GLUniformBuffer sun_quad_ubo; + GLUniformBuffer transparency_batch_ubo; + GLUniformBuffer tone_map_ubo; + + obj_scene_shader_data obj_scene; + obj_batch_shader_data obj_batch; + obj_skinning_shader_data obj_skinning; + GLUniformBuffer obj_scene_ubo; + GLUniformBuffer obj_batch_ubo; + GLUniformBuffer obj_skinning_ubo; + + GLuint empty_texture_2d; + GLuint empty_texture_cube_map; + + GLuint samplers[18]; + GLuint render_samplers[3]; + GLuint sprite_samplers[3]; + + int32_t sprite_width; + int32_t sprite_height; + int32_t screen_x_offset; + int32_t screen_y_offset; + int32_t screen_width; + int32_t screen_height; + + render_context(); + ~render_context(); + + void ctrl(bool change_res = true); + void free(); + void init(); +}; + +extern draw_state_struct* draw_state; + +extern render_context* rctx; + +extern sss_data* (FASTCALL* sss_data_get)(); + +void fbo_blit(GLuint src_fbo, GLuint dst_fbo, + GLint src_x, GLint src_y, GLint src_width, GLint src_height, + GLint dst_x, GLint dst_y, GLint dst_width, GLint dst_height, GLbitfield mask, GLenum filter); diff --git a/src/DivaGL/render_manager.cpp b/src/DivaGL/render_manager.cpp new file mode 100644 index 0000000..b49137c --- /dev/null +++ b/src/DivaGL/render_manager.cpp @@ -0,0 +1,1781 @@ +/* + by korenkonder + GitHub/GitLab: korenkonder +*/ + +#include "render_manager.hpp" +#include "../KKdLib/mat.hpp" +#include "Glitter/glitter.hpp" +#include "light_param/fog.hpp" +#include "light_param/light.hpp" +#include "mdl/disp_manager.hpp" +#include "rob/rob.hpp" +#include "gl_state.hpp" +#include "render.hpp" +#include "render_context.hpp" +#include "render_texture.hpp" +#include "shader_glsl_ft.hpp" +#include "sprite.hpp" +#include "stage_param.hpp" +#include "texture.hpp" +#include + +static void draw_pass_shadow_begin_make_shadowmap(Shadow* shad, int32_t index, int32_t a3); +static void draw_pass_shadow_end_make_shadowmap(Shadow* shad, int32_t index, int32_t a3); +static void draw_pass_shadow_filter(RenderTexture* a1, RenderTexture* a2, + RenderTexture* a3, float_t sigma, float_t far_texel_offset, bool enable_lit_proj); +static void draw_pass_shadow_esm_filter(RenderTexture* dst, RenderTexture* buf, RenderTexture* src); +static bool draw_pass_shadow_litproj(); +static bool draw_pass_shadow_litproj_set(); +static bool draw_pass_shadow_litproj_set_mat(bool set_mat); +static void draw_pass_sss_contour(rndr::Render* rend); +static void draw_pass_sss_filter(sss_data* sss); +static int32_t draw_pass_3d_get_translucent_count(); +static void draw_pass_3d_shadow_reset(); +static void draw_pass_3d_shadow_set(Shadow* shad); +extern void draw_pass_3d_translucent(bool opaque_enable, + bool transparent_enable, bool translucent_enable, mdl::ObjType opaque, + mdl::ObjType transparent, mdl::ObjType translucent); +static int32_t draw_pass_3d_translucent_count_layers(int32_t* alpha_array, + mdl::ObjType opaque, mdl::ObjType transparent, mdl::ObjType translucent); +static void draw_pass_3d_translucent_has_objects(bool* arr, mdl::ObjType type); + +static void blur_filter_apply(RenderTexture* dst, RenderTexture* src, + blur_filter_mode filter, const vec2 res_scale, const vec4 scale, const vec4 offset); + +extern render_context* rctx; + +RenderTexture* litproj_shadow = (RenderTexture*)0x0000000141194DA0; +RenderTexture* litproj_texture = (RenderTexture*)0x0000000141194E00; +rndr::RenderManager* render_manager = (rndr::RenderManager*)0x00000001411AD320; + +namespace rndr { + static const int32_t render_manager_render_texture_index_array[][3] = { + { 1, 1, 1 }, + { 0, 0, 0 }, + { 6, 6, 6 }, + { 6, 6, 6 }, + { 6, 6, 6 }, + { 2, 2, 2 }, + { 3, 3, 3 }, + { 4, 4, 4 }, + { 5, 5, 5 }, + { 6, 6, 6 }, + { 7, 7, 7 }, + }; + + void RenderManager::add_pre_process(int32_t type, void(*func)(void*), void* data) { + pre_process.push_back({ type, func, data }); + } + + void RenderManager::clear_pre_process(int32_t type) { + for (std::list::iterator i = pre_process.begin(); i != pre_process.end(); i++) + if (i->type == type) { + pre_process.erase(i); + break; + } + } + + RenderTexture& RenderManager::get_render_texture(int32_t index) { + return render_textures[render_manager_render_texture_index_array[index][tex_index[index]]]; + } + + void RenderManager::resize(int32_t width, int32_t height) { + if (this->width == width && this->height == height) + return; + + this->width = width; + this->height = height; + + if (!multisample_framebuffer) + glGenFramebuffers(1, &multisample_framebuffer); + + if (!multisample_renderbuffer) + glGenRenderbuffers(1, &multisample_renderbuffer); + + glBindFramebuffer(GL_FRAMEBUFFER, multisample_framebuffer); + glBindRenderbuffer(GL_RENDERBUFFER, multisample_renderbuffer); + glRenderbufferStorageMultisample(GL_RENDERBUFFER, 8, GL_RGBA8, width, height); + glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, multisample_renderbuffer); + glDrawBufferDLL(GL_COLOR_ATTACHMENT0); + glReadBufferDLL(GL_COLOR_ATTACHMENT0); + glBindFramebuffer(GL_FRAMEBUFFER, 0); + glBindRenderbuffer(GL_RENDERBUFFER, 0); + } + + void RenderManager::set_effect_texture(texture* value) { + effect_texture = value; + } + + void RenderManager::set_multisample(bool value) { + multisample = value; + } + + void RenderManager::set_npr_param(int32_t value) { + npr_param = value; + } + + void RenderManager::set_pass_sw(RenderPassID id, bool value) { + pass_sw[id] = value; + } + + void RenderManager::set_reflect(bool value) { + reflect = value; + } + + void RenderManager::set_reflect_blur(int32_t reflect_blur_num, blur_filter_mode reflect_blur_filter) { + this->reflect_blur_num = reflect_blur_num; + this->reflect_blur_filter = reflect_blur_filter; + } + + void RenderManager::set_reflect_resolution_mode(reflect_refract_resolution_mode mode) { + tex_index[0] = mode; + } + + void RenderManager::set_reflect_type(stage_data_reflect_type type) { + reflect_type = type; + } + + void RenderManager::set_refract(bool value) { + refract = value; + } + + void RenderManager::set_refract_resolution_mode(reflect_refract_resolution_mode mode) { + tex_index[1] = mode; + } + + void RenderManager::set_shadow_false() { + shadow = false; + } + + void RenderManager::set_shadow_true() { + shadow = true; + } + + void RenderManager::render_all() { + static const int32_t ibl_texture_index[] = { + 9, 10, 11, 12, 13 + }; + + rctx->obj_scene.g_framebuffer_size = { + 1.0f / (float_t)render->render_width[0], + 1.0f / (float_t)render->render_height[0], + (float_t)render->render_width[0], + (float_t)render->render_height[0] + }; + + gl_state_set_color_mask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); + gl_state_enable_depth_test(); + gl_state_set_depth_func(GL_LEQUAL); + gl_state_set_depth_mask(GL_TRUE); + + gl_state_begin_event("rndpass_render_all_pass::Caller::execute_pre3d"); + for (int32_t i = RND_PASSID_SHADOW; i <= RND_PASSID_CLEAR; i++) + RenderManager::render_single_pass((RenderPassID)i); + gl_state_end_event(); + + gl_state_begin_event("rndpass_render_all_pass::Caller::execute_3d"); + for (int32_t i = RND_PASSID_PRE_SPRITE; i <= RND_PASSID_3D; i++) + RenderManager::render_single_pass((RenderPassID)i); + gl_state_end_event(); + + gl_state_begin_event("rndpass_render_all_pass::Caller::execute_2d"); + for (int32_t i = RND_PASSID_SHOW_VECTOR; i <= RND_PASSID_12; i++) + RenderManager::render_single_pass((RenderPassID)i); + gl_state_end_event(); + + disp_manager->check_vertex_arrays(); + gl_state_bind_vertex_array(0); + gl_state_disable_primitive_restart(); + gl_state_bind_uniform_buffer_base(0, 0); + gl_state_bind_uniform_buffer_base(1, 0); + gl_state_bind_uniform_buffer_base(2, 0); + gl_state_bind_uniform_buffer_base(3, 0); + gl_state_bind_uniform_buffer_base(4, 0); + } + + void RenderManager::render_single_pass(RenderPassID id) { + cpu_time[id] = 0.0; + gpu_time[id] = 0.0; + if (!pass_sw[id]) { + gl_state_get_error(); + return; + } + + render_pass_begin(); + switch (id) { + case RND_PASSID_SHADOW: + pass_shadow(); + break; + case RND_PASSID_SS_SSS: + pass_ss_sss(); + break; + case RND_PASSID_REFLECT: + pass_reflect(); + break; + case RND_PASSID_REFRACT: + pass_refract(); + break; + case RND_PASSID_PRE_PROCESS: + pass_pre_process(); + break; + case RND_PASSID_CLEAR: + pass_clear(); + break; + case RND_PASSID_PRE_SPRITE: + pass_pre_sprite(); + break; + case RND_PASSID_3D: + pass_3d(); + break; + case RND_PASSID_SHOW_VECTOR: + pass_show_vector(); + break; + case RND_PASSID_POST_PROCESS: + pass_post_process(); + break; + case RND_PASSID_SPRITE: + pass_sprite(); + break; + } + render_pass_end(id); + gl_state_get_error(); + } + + void RenderManager::render_pass_begin() { + if (sync_gpu) + glFinishDLL(); + time.get_timestamp(); + } + + void RenderManager::render_pass_end(RenderPassID id) { + cpu_time[id] = time.calc_time(); + if (sync_gpu) { + time_struct t; + glFinishDLL(); + gpu_time[id] = t.calc_time(); + } + else + gpu_time[id] = 0; + } + + void RenderManager::pass_shadow() { + gl_state_begin_event("pass_shadow"); + if (draw_pass_shadow_litproj_set()) { + rctx->obj_scene_ubo.WriteMemory(rctx->obj_scene); + + disp_manager->draw(mdl::OBJ_TYPE_OPAQUE); + disp_manager->draw(mdl::OBJ_TYPE_TRANSPARENT); + disp_manager->draw(mdl::OBJ_TYPE_TRANSLUCENT); + + draw_state->shader_index = -1; + uniform->arr[U0A] = 0; + draw_pass_shadow_filter(&litproj_shadow[0], &litproj_shadow[1], 0, 1.5f, 0.01f, true); + + if (draw_pass_shadow_litproj()) { + draw_pass_set_camera(); + + for (int32_t i = LIGHT_SET_MAIN; i < LIGHT_SET_MAX; i++) + light_set_data[i].data_set((light_set_id)i); + + rctx->obj_scene_ubo.WriteMemory(rctx->obj_scene); + + disp_manager->draw(mdl::OBJ_TYPE_OPAQUE); + disp_manager->draw(mdl::OBJ_TYPE_TRANSPARENT); + disp_manager->obj_sort(&rctx->view_mat, mdl::OBJ_TYPE_TRANSLUCENT, 1); + gl_state_set_blend_func(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + gl_state_enable_blend(); + disp_manager->draw(mdl::OBJ_TYPE_TRANSLUCENT); + gl_state_disable_blend(); + draw_state->shader_index = -1; + gl_state_bind_framebuffer(0); + } + } + + rctx->obj_scene_ubo.WriteMemory(rctx->obj_scene); + + bool v3 = false; + int32_t v10[2]; + for (int32_t i = 0; i < 2; i++) { + v10[i] = disp_manager->get_obj_count((mdl::ObjType)(mdl::OBJ_TYPE_SHADOW_CHARA + i)); + if (v10[i]) + v3 = true; + } + + Shadow* shad = shadow_ptr; + if (shadow && v3) { + int32_t v11[2]; + v11[0] = shad->field_200[0]; + v11[1] = shad->field_200[1]; + shad->curr_render_textures[0] = &shad->render_textures[0]; + shad->curr_render_textures[1] = &shad->render_textures[1]; + shad->curr_render_textures[2] = &shad->render_textures[2]; + + for (int32_t i = 0, j = 0; i < 2; i++) { + if (!v10[i]) + continue; + + draw_pass_shadow_begin_make_shadowmap(shad, v11[i], j); + disp_manager->draw((mdl::ObjType)(mdl::OBJ_TYPE_SHADOW_CHARA + v11[i])); + if (disp_manager->get_obj_count((mdl::ObjType)(mdl::OBJ_TYPE_SHADOW_OBJECT_CHARA + v11[i])) > 0) { + gl_state_set_color_mask(field_2F8 ? GL_TRUE : GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE); + disp_manager->draw((mdl::ObjType)(mdl::OBJ_TYPE_SHADOW_OBJECT_CHARA + i)); + gl_state_set_color_mask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); + } + draw_pass_shadow_end_make_shadowmap(shad, v11[i], j); + j++; + } + } + else { + shad->curr_render_textures[0] = &shad->render_textures[0]; + shad->curr_render_textures[1] = &shad->render_textures[1]; + shad->curr_render_textures[2] = &shad->render_textures[2]; + + for (int32_t i = 1; i < 3; i++) + for (int32_t j = 0; j < 4; j++) { + shad->curr_render_textures[i]->Bind(j); + glClearColorDLL(1.0f, 1.0f, 1.0f, 1.0f); + glClearDLL(GL_COLOR_BUFFER_BIT); + } + } + shader_glsl::unbind(); + gl_state_bind_framebuffer(0); + gl_state_end_event(); + } + + void RenderManager::pass_ss_sss() { + ::sss_data* sss = sss_data_get(); + if (!sss->init || !sss->enable) + return; + + gl_state_begin_event("pass_ss_sss"); + rndr::Render* rend = render; + //if (rend->render_width > 1280.0) + // sss->npr_contour = false; + + //if (sss->npr_contour) { + rend->rend_texture[0].Bind(); + rend->rend_texture[0].SetViewport(); + //} + //else { + // sss->textures[0].Bind(); + // glViewportDLL(0, 0, 640, 360); + //} + + glClearColorDLL(sss->param.x, sss->param.y, sss->param.z, 0.0f); + glClearDLL(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + + draw_pass_set_camera(); + for (int32_t i = LIGHT_SET_MAIN; i < LIGHT_SET_MAX; i++) + light_set_data[i].data_set((light_set_id)i); + + if (shadow) + draw_pass_3d_shadow_set(shadow_ptr); + else + draw_pass_3d_shadow_reset(); + + rctx->obj_scene_ubo.WriteMemory(rctx->obj_scene); + + draw_state->shader_index = SHADER_FT_SSS_SKIN; + gl_state_enable_depth_test(); + gl_state_set_depth_func(GL_LEQUAL); + gl_state_set_depth_mask(GL_TRUE); + disp_manager->draw(mdl::OBJ_TYPE_SSS); + gl_state_disable_depth_test(); + draw_state->shader_index = -1; + draw_pass_3d_shadow_reset(); + uniform->arr[U_NPR] = 0; + + if (npr_param == 1) { + if (sss->enable && sss->npr_contour) { + uniform->arr[U_NPR] = 1; + draw_pass_sss_contour(rend); + } + else if (npr) { + rctx->obj_scene_ubo.WriteMemory(rctx->obj_scene); + + rend->rend_texture[0].Bind(); + rend->rend_texture[0].SetViewport(); + glClearDLL(GL_DEPTH_BUFFER_BIT); + draw_state->shader_index = SHADER_FT_SSS_SKIN; + gl_state_enable_depth_test(); + gl_state_set_depth_mask(GL_TRUE); + disp_manager->draw(mdl::OBJ_TYPE_SSS); + gl_state_disable_depth_test(); + draw_state->shader_index = -1; + gl_state_bind_framebuffer(0); + uniform->arr[U_NPR] = 1; + draw_pass_sss_contour(rend); + } + } + + if (!sss->npr_contour) { + sss->textures[0].Bind(); + glViewportDLL(0, 0, 640, 360); + + filter_scene_shader_data filter_scene = {}; + filter_scene.g_transform = { 1.0f, 1.0f, 0.0f, 0.0f }; + filter_scene.g_texcoord = { 1.0f, 1.0f, 0.0f, 0.0f }; + rctx->filter_scene_ubo.WriteMemory(filter_scene); + + imgfilter_batch_shader_data imgfilter_batch = {}; + imgfilter_batch.g_color_scale = 1.0f; + imgfilter_batch.g_color_offset = 0.0f; + imgfilter_batch.g_texture_lod = 0.0f; + rctx->imgfilter_batch_ubo.WriteMemory(imgfilter_batch); + + uniform->arr[U_IMAGE_FILTER] = 5; + shaders_ft.set(SHADER_FT_IMGFILT); + rctx->filter_scene_ubo.Bind(0); + rctx->imgfilter_batch_ubo.Bind(1); + gl_state_active_bind_texture_2d(0, rend->rend_texture[0].GetColorTex()); + gl_state_bind_vertex_array(rctx->common_vao); + shaders_ft.draw_arrays(GL_TRIANGLE_STRIP, 0, 4); + } + + draw_pass_sss_filter(sss); + shader_glsl::unbind(); + gl_state_bind_framebuffer(0); + gl_state_end_event(); + } + + void RenderManager::pass_reflect() { + gl_state_begin_event("pass_reflect"); + RenderTexture& refl_tex = render_manager->get_render_texture(0); + RenderTexture& refl_buf_tex = rctx->reflect_buffer; + refl_tex.Bind(); + if (disp_manager->get_obj_count(mdl::OBJ_TYPE_REFLECT_OPAQUE) + || disp_manager->get_obj_count(mdl::OBJ_TYPE_REFLECT_TRANSPARENT) + || disp_manager->get_obj_count(mdl::OBJ_TYPE_REFLECT_TRANSLUCENT) + || disp_manager->get_obj_count(mdl::OBJ_TYPE_REFLECT_CHARA_OPAQUE) + || disp_manager->get_obj_count(mdl::OBJ_TYPE_REFLECT_CHARA_TRANSPARENT) + || disp_manager->get_obj_count(mdl::OBJ_TYPE_REFLECT_CHARA_TRANSLUCENT)) { + refl_tex.SetViewport(); + + draw_pass_set_camera(); + + for (int32_t i = LIGHT_SET_MAIN; i < LIGHT_SET_MAX; i++) + light_set_data[i].data_set((light_set_id)i); + for (int32_t i = FOG_DEPTH; i < FOG_BUMP; i++) + fog_data[i].data_set((fog_id)i); + + rctx->obj_scene_ubo.WriteMemory(rctx->obj_scene); + + glClearColorDLL(0.0f, 0.0f, 0.0f, 0.0f); + glClearDLL(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + + draw_state->shader_index = SHADER_FT_S_REFL; + + light_set* set = &light_set_data[LIGHT_SET_MAIN]; + light_clip_plane clip_plane; + set->lights[LIGHT_SPOT].get_clip_plane(clip_plane); + uniform->arr[U_REFLECT] = 2; + uniform->arr[U_CLIP_PLANE] = clip_plane.data[1]; + + gl_state_enable_depth_test(); + gl_state_set_depth_func(GL_LEQUAL); + gl_state_set_depth_mask(GL_TRUE); + disp_manager->draw(mdl::OBJ_TYPE_REFLECT_OPAQUE, 0, field_31D); + if (reflect_type == STAGE_DATA_REFLECT_REFLECT_MAP) { + gl_state_enable_blend(); + gl_state_set_blend_func(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + gl_state_set_blend_equation(GL_FUNC_ADD); + disp_manager->draw(mdl::OBJ_TYPE_REFLECT_TRANSLUCENT); + gl_state_disable_blend(); + } + + if (reflect_type == STAGE_DATA_REFLECT_REFLECT_MAP) { + uniform->arr[U_REFLECT] = field_31E; + uniform->arr[U_CLIP_PLANE] = clip_plane.data[0]; + disp_manager->draw(mdl::OBJ_TYPE_REFLECT_CHARA_OPAQUE); + } + gl_state_disable_depth_test(); + uniform->arr[U_REFLECT] = 0; + draw_state->shader_index = -1; + + refl_buf_tex.Bind(); + for (int32_t i = reflect_blur_num, j = 0; i > 0; i--, j++) { + blur_filter_apply(&refl_buf_tex, &refl_tex, + reflect_blur_filter, 1.0f, 1.0f, 0.0f); + glCopyTexSubImage2DDLL(GL_TEXTURE_2D, 0, 0, 0, 0, 0, refl_tex.GetWidth(), refl_tex.GetHeight()); + } + } + else { + vec4 clear_color; + glGetFloatvDLL(GL_COLOR_CLEAR_VALUE, (GLfloat*)&clear_color); + glClearColorDLL(0.0f, 0.0f, 0.0f, 0.0f); + glClearDLL(GL_COLOR_BUFFER_BIT); + glClearColorDLL(clear_color.x, clear_color.y, clear_color.z, clear_color.w); + } + shader_glsl::unbind(); + gl_state_bind_framebuffer(0); + gl_state_end_event(); + } + + void RenderManager::pass_refract() { + gl_state_begin_event("pass_refract"); + RenderTexture& refract_texture = render_manager->get_render_texture(1); + refract_texture.Bind(); + if (disp_manager->get_obj_count(mdl::OBJ_TYPE_REFRACT_OPAQUE) + || disp_manager->get_obj_count(mdl::OBJ_TYPE_REFRACT_TRANSPARENT) + || disp_manager->get_obj_count(mdl::OBJ_TYPE_REFRACT_TRANSLUCENT)) { + texture* refr_tex = refract_texture.color_texture; + glViewportDLL(0, 0, refr_tex->width, refr_tex->height); + + draw_pass_set_camera(); + + for (int32_t i = LIGHT_SET_MAIN; i < LIGHT_SET_MAX; i++) + light_set_data[i].data_set((light_set_id)i); + for (int32_t i = FOG_DEPTH; i < FOG_BUMP; i++) + fog_data[i].data_set((fog_id)i); + + rctx->obj_scene_ubo.WriteMemory(rctx->obj_scene); + + vec4 clear_color; + glGetFloatvDLL(GL_COLOR_CLEAR_VALUE, (GLfloat*)&clear_color); + glClearColorDLL(0.0f, 0.0f, 0.0f, 0.0f); + glClearDLL(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + glClearColorDLL(clear_color.x, clear_color.y, clear_color.z, clear_color.w); + + draw_state->shader_index = SHADER_FT_S_REFR; + gl_state_enable_depth_test(); + gl_state_set_depth_func(GL_LEQUAL); + gl_state_set_depth_mask(GL_TRUE); + disp_manager->draw(mdl::OBJ_TYPE_REFRACT_OPAQUE); + disp_manager->draw(mdl::OBJ_TYPE_REFRACT_TRANSPARENT); + disp_manager->draw(mdl::OBJ_TYPE_REFRACT_TRANSLUCENT); + gl_state_disable_depth_test(); + draw_state->shader_index = -1; + } + else { + vec4 clear_color; + glGetFloatvDLL(GL_COLOR_CLEAR_VALUE, (GLfloat*)&clear_color); + glClearColorDLL(0.0f, 0.0f, 0.0f, 0.0f); + glClearDLL(GL_COLOR_BUFFER_BIT); + glClearColorDLL(clear_color.x, clear_color.y, clear_color.z, clear_color.w); + } + shader_glsl::unbind(); + gl_state_bind_framebuffer(0); + gl_state_end_event(); + } + + void RenderManager::pass_pre_process() { + return; + gl_state_begin_event("pass_pre_process"); + for (draw_pre_process& i : pre_process) + if (i.func) + i.func(i.data); + shader_glsl::unbind(); + gl_state_bind_framebuffer(0); + gl_state_end_event(); + } + + void RenderManager::pass_clear() { + void(FASTCALL * clear_color_set_gl)() = (void(FASTCALL*)())0x00000001405022A0; + + gl_state_begin_event("pass_clear"); + if (clear) { + rctx->screen_buffer.Bind(); + clear_color_set_gl(); + //glClearDLL(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + glClearDLL(GL_COLOR_BUFFER_BIT); + gl_state_bind_framebuffer(0); + } + + rndr::Render* rend = render; + if (!sss_data_get()->enable || !sss_data_get()->npr_contour) { + rend->bind_render_texture(); + if (sprite_manager_get_reqlist_count(2)) { + glClearColorDLL(0.0f, 0.0f, 0.0f, 0.0f); + glClearDepthf(1.0f); + glClearDLL(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + gl_state_bind_framebuffer(0); + } + else { + clear_color_set_gl(); + glClearDepthf(1.0f); + if (clear) + glClearDLL(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + else + glClearDLL(GL_DEPTH_BUFFER_BIT); + gl_state_bind_framebuffer(0); + } + } + else { + if (sprite_manager_get_reqlist_count(2)) { + rend->bind_render_texture(); + glClearColorDLL(0.0f, 0.0f, 0.0f, 0.0f); + glClearDLL(GL_COLOR_BUFFER_BIT); + gl_state_bind_framebuffer(0); + } + else if (clear) { + rend->bind_render_texture(); + clear_color_set_gl(); + glClearDLL(GL_COLOR_BUFFER_BIT); + gl_state_bind_framebuffer(0); + } + } + + gl_state_get_error(); + gl_state_end_event(); + } + + void RenderManager::pass_pre_sprite() { + if (!sprite_manager_get_reqlist_count(2)) + return; + + gl_state_begin_event("pass_pre_sprite"); + rndr::Render* rend = render; + rend->bind_render_texture(true); + glClearColorDLL(0.0f, 0.0f, 0.0f, 0.0f); + glClearDLL(GL_COLOR_BUFFER_BIT); + gl_state_set_depth_mask(GL_FALSE); + gl_state_disable_depth_test(); + gl_state_enable_blend(); + gl_state_disable_cull_face(); + sprite_manager_draw(2, true, + rend->temp_buffer.color_texture); + gl_state_enable_cull_face(); + gl_state_disable_blend(); + gl_state_enable_depth_test(); + gl_state_set_depth_mask(GL_TRUE); + shader_glsl::unbind(); + gl_state_bind_framebuffer(0); + gl_state_get_error(); + gl_state_end_event(); + } + + void RenderManager::pass_3d() { + render->bind_render_texture(); + draw_pass_set_camera(); + if (!sss_data_get()->enable || !sss_data_get()->npr_contour + || draw_pass_3d_get_translucent_count()) + glClearDLL(GL_DEPTH_BUFFER_BIT); + + gl_state_set_depth_func(GL_LEQUAL); + + for (int32_t i = LIGHT_SET_MAIN; i < LIGHT_SET_MAX; i++) + light_set_data[i].data_set((light_set_id)i); + for (int32_t i = FOG_DEPTH; i < FOG_MAX; i++) + fog_data[i].data_set((fog_id)i); + + if (shadow) + draw_pass_3d_shadow_set(shadow_ptr); + else + draw_pass_3d_shadow_reset(); + + rctx->obj_scene_ubo.WriteMemory(rctx->obj_scene); + + if (pass_sw[RND_PASSID_REFLECT] && reflect) { + RenderTexture& refl_tex = get_render_texture(0); + gl_state_active_bind_texture_2d(15, refl_tex.GetColorTex()); + uniform->arr[U_WATER_REFLECT] = 1; + } + else { + gl_state_active_bind_texture_2d(15, rctx->empty_texture_2d); + uniform->arr[U_WATER_REFLECT] = 0; + } + + uniform->arr[U12] = field_320 ? 1 : 0; + + if (effect_texture) + gl_state_active_bind_texture_2d(14, effect_texture->tex); + else + gl_state_active_bind_texture_2d(14, rctx->empty_texture_2d); + + gl_state_active_bind_texture_2d(16, sss_data_get()->textures[1].GetColorTex()); + gl_state_active_texture(0); + + if (alpha_z_sort) { + disp_manager->obj_sort(&rctx->view_mat, mdl::OBJ_TYPE_TRANSLUCENT, 1); + disp_manager->obj_sort(&rctx->view_mat, mdl::OBJ_TYPE_TRANSLUCENT_NO_SHADOW, 2); + disp_manager->obj_sort(&rctx->view_mat, mdl::OBJ_TYPE_TRANSLUCENT_ALPHA_ORDER_1, 1); + disp_manager->obj_sort(&rctx->view_mat, mdl::OBJ_TYPE_TRANSLUCENT_ALPHA_ORDER_2, 1); + disp_manager->obj_sort(&rctx->view_mat, mdl::OBJ_TYPE_TRANSLUCENT_ALPHA_ORDER_3, 1); + //disp_manager->obj_sort(&rctx->view_mat, mdl::OBJ_TYPE_TRANSLUCENT_ALPHA_ORDER_2_LOCAL, 1); + } + + if (opaque_z_sort) + disp_manager->obj_sort(&rctx->view_mat, mdl::OBJ_TYPE_OPAQUE, 0); + + if (draw_pass_3d[DRAW_PASS_3D_OPAQUE]) { + gl_state_enable_depth_test(); + gl_state_set_depth_mask(GL_TRUE); + disp_manager->draw(mdl::OBJ_TYPE_OPAQUE); + gl_state_disable_depth_test(); + } + + Glitter::GltParticleManager__DispScenes(Glitter::glt_particle_manager, Glitter::DISP_OPAQUE); + + gl_state_enable_depth_test(); + gl_state_set_depth_mask(GL_TRUE); + if (draw_pass_3d[DRAW_PASS_3D_TRANSPARENT]) + disp_manager->draw(mdl::OBJ_TYPE_TRANSPARENT); + if (render_manager->field_120) + disp_manager->draw(mdl::OBJ_TYPE_TYPE_7); + + render->calc_exposure_chara_data(); + + if (npr_param == 1) + pass_3d_contour(); + + render->draw_lens_flare(); + //star_catalog_draw(); + + draw_pass_3d_translucent( + draw_pass_3d[DRAW_PASS_3D_OPAQUE], + draw_pass_3d[DRAW_PASS_3D_TRANSPARENT], + draw_pass_3d[DRAW_PASS_3D_TRANSLUCENT], + mdl::OBJ_TYPE_OPAQUE_ALPHA_ORDER_3, + mdl::OBJ_TYPE_TRANSPARENT_ALPHA_ORDER_3, + mdl::OBJ_TYPE_TRANSLUCENT_ALPHA_ORDER_3); + + //snow_particle_draw(); + //rain_particle_draw(); + //leaf_particle_draw(); + //particle_draw(); + gl_state_disable_depth_test(); + + gl_state_set_color_mask(GL_TRUE, GL_TRUE, GL_TRUE, GL_FALSE); + Glitter::GltParticleManager__DispScenes(Glitter::glt_particle_manager, Glitter::DISP_ALPHA); + gl_state_set_color_mask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); + + /*if (npr_param == 1) { + gl_state_set_color_mask(GL_FALSE, GL_FALSE, GL_FALSE, GL_TRUE); + glClearColorDLL(0.0f, 0.0f, 0.0f, 0.0f); + glClearDLL(GL_COLOR_BUFFER_BIT); + gl_state_set_color_mask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); + }*/ + + gl_state_enable_depth_test(); + + if (draw_pass_3d[DRAW_PASS_3D_TRANSLUCENT]) { + gl_state_enable_blend(); + gl_state_set_blend_func(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + gl_state_set_depth_mask(GL_FALSE); + disp_manager->draw(mdl::OBJ_TYPE_TRANSLUCENT_NO_SHADOW); + disp_manager->draw(mdl::OBJ_TYPE_TRANSLUCENT); + gl_state_disable_blend(); + } + + //gl_state_set_color_mask(GL_TRUE, GL_TRUE, GL_TRUE, GL_FALSE); // X + //Glitter::GltParticleManager__DispScenes(Glitter::glt_particle_manager, Glitter::DISP_TYPE_2); + //gl_state_set_color_mask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); + + gl_state_set_depth_mask(GL_TRUE); + draw_pass_3d_translucent( + draw_pass_3d[DRAW_PASS_3D_OPAQUE], + draw_pass_3d[DRAW_PASS_3D_TRANSPARENT], + draw_pass_3d[DRAW_PASS_3D_TRANSLUCENT], + mdl::OBJ_TYPE_OPAQUE_ALPHA_ORDER_2, + mdl::OBJ_TYPE_TRANSPARENT_ALPHA_ORDER_2, + mdl::OBJ_TYPE_TRANSLUCENT_ALPHA_ORDER_2); + gl_state_disable_depth_test(); + + gl_state_set_color_mask(GL_TRUE, GL_TRUE, GL_TRUE, GL_FALSE); + Glitter::GltParticleManager__DispScenes(Glitter::glt_particle_manager, Glitter::DISP_NORMAL); + gl_state_set_color_mask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); + + gl_state_enable_depth_test(); + gl_state_set_depth_mask(GL_TRUE); + draw_pass_3d_translucent( + draw_pass_3d[DRAW_PASS_3D_OPAQUE], + draw_pass_3d[DRAW_PASS_3D_TRANSPARENT], + draw_pass_3d[DRAW_PASS_3D_TRANSLUCENT], + mdl::OBJ_TYPE_OPAQUE_ALPHA_ORDER_1, + mdl::OBJ_TYPE_TRANSPARENT_ALPHA_ORDER_1, + mdl::OBJ_TYPE_TRANSLUCENT_ALPHA_ORDER_1); + +#if defined(CRE_DEV) + if (Glitter::glt_particle_manager->CheckHasLocalEffect()) { // X + camera* cam = camera_data; + double_t fov = cam->get_fov(); + cam->set_fov(32.2673416137695); + draw_pass_set_camera(); + + rctx->obj_scene_ubo.WriteMemory(rctx->obj_scene); + + disp_manager->draw(mdl::OBJ_TYPE_OPAQUE_LOCAL); + disp_manager->draw(mdl::OBJ_TYPE_TRANSPARENT_LOCAL); + gl_state_enable_blend(); + disp_manager->draw(mdl::OBJ_TYPE_TRANSLUCENT_LOCAL); + gl_state_disable_blend(); + + draw_pass_3d_translucent( + draw_pass_3d[DRAW_PASS_3D_OPAQUE], + draw_pass_3d[DRAW_PASS_3D_TRANSPARENT], + draw_pass_3d[DRAW_PASS_3D_TRANSLUCENT], + mdl::OBJ_TYPE_OPAQUE_ALPHA_ORDER_2_LOCAL, + mdl::OBJ_TYPE_TRANSPARENT_ALPHA_ORDER_2_LOCAL, + mdl::OBJ_TYPE_TRANSLUCENT_ALPHA_ORDER_2_LOCAL); + + gl_state_set_color_mask(GL_TRUE, GL_TRUE, GL_TRUE, GL_FALSE); + Glitter::GltParticleManager__DispScenes(Glitter::glt_particle_manager, Glitter::DISP_LOCAL); + gl_state_set_color_mask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); + cam->set_fov(fov); + draw_pass_set_camera(); + } +#endif + + gl_state_active_bind_texture_2d(14, 0); + gl_state_active_bind_texture_2d(15, 0); + + gl_state_disable_depth_test(); + + if (shadow) + draw_pass_3d_shadow_reset(); + pass_sprite_surf(); + shader_glsl::unbind(); + gl_state_bind_framebuffer(0); + } + + void RenderManager::pass_show_vector() { + return; + /*if (!show_vector_flags) + return; + + gl_state_begin_event("pass_show_vector"); + + render->bind_render_texture(); + draw_pass_set_camera(); + + rctx->obj_scene_ubo.WriteMemory(rctx->obj_scene); + + if (alpha_z_sort) { + disp_manager->obj_sort(&rctx->view_mat, mdl::OBJ_TYPE_TRANSLUCENT, 1); + disp_manager->obj_sort(&rctx->view_mat, mdl::OBJ_TYPE_TRANSLUCENT_NO_SHADOW, 2); + } + + if (opaque_z_sort) + disp_manager->obj_sort(&rctx->view_mat, mdl::OBJ_TYPE_OPAQUE, 0); + + //shaders_ft.env_vert_set(20, show_vector_length, show_vector_z_offset, 0.0f, 0.0f); + for (int32_t i = 1; i < 4; i++) { + if (!(show_vector_flags & (1 << (i - 1)))) + continue; + + if (draw_pass_3d[DRAW_PASS_3D_OPAQUE]) + draw_task_draw_objects_by_type_show_vector(mdl::OBJ_TYPE_OPAQUE, i); + if (draw_pass_3d[DRAW_PASS_3D_TRANSPARENT]) + draw_task_draw_objects_by_type_show_vector(mdl::OBJ_TYPE_TRANSPARENT, i); + if (draw_pass_3d[DRAW_PASS_3D_TRANSLUCENT]) { + draw_task_draw_objects_by_type_show_vector(mdl::OBJ_TYPE_TRANSLUCENT_NO_SHADOW, i); + draw_task_draw_objects_by_type_show_vector(mdl::OBJ_TYPE_TRANSLUCENT, i); + } + } + shader::unbind(); + gl_state_bind_framebuffer(0); + gl_state_end_event();*/ + } + + void RenderManager::pass_post_process() { + gl_state_begin_event("pass_post_process"); + render->apply_post_process(); + gl_state_end_event(); + } + + void RenderManager::pass_sprite() { + if (!sprite_manager_get_reqlist_count(0)) + return; + + gl_state_begin_event("pass_sprite"); + rndr::Render* rend = render; + glViewportDLL(0, 0, rctx->sprite_width, rctx->sprite_height); + + if (multisample && multisample_framebuffer) { + glBindFramebuffer(GL_FRAMEBUFFER, multisample_framebuffer); + gl_state_enable_multisample(); + glClearColorDLL(0.0f, 0.0f, 0.0f, 0.0f); + glClearDLL(GL_COLOR_BUFFER_BIT); + } + else + rctx->screen_buffer.Bind(); + + gl_state_disable_depth_test(); + gl_state_enable_blend(); + gl_state_disable_cull_face(); + sprite_manager_set_res((double_t)rctx->sprite_width / (double_t)rctx->sprite_height, + rctx->sprite_width, rctx->sprite_height); + sprite_manager_draw(0, true, + rend->temp_buffer.color_texture); + gl_state_enable_cull_face(); + gl_state_disable_blend(); + gl_state_enable_depth_test(); + + if (multisample && multisample_framebuffer) { + glBindFramebuffer(GL_FRAMEBUFFER, 0); + gl_state_disable_multisample(); + gl_state_bind_read_framebuffer(multisample_framebuffer); + glBlitFramebuffer(0, 0, width, height, + 0, 0, width, height, GL_COLOR_BUFFER_BIT, GL_NEAREST); + gl_state_bind_read_framebuffer(0); + } + gl_state_get_error(); + + fbo_blit(rctx->screen_buffer.fbos[0], 0, + 0, 0, rctx->sprite_width, rctx->sprite_height, + rctx->screen_x_offset, rctx->screen_y_offset, + rctx->sprite_width, rctx->sprite_height, GL_COLOR_BUFFER_BIT, GL_LINEAR); + shader_glsl::unbind(); + gl_state_bind_framebuffer(0); + gl_state_end_event(); + } + + void RenderManager::pass_3d_contour() { + RenderTexture* rt = &render->rend_texture[0]; + RenderTexture* contour_rt = render->sss_contour_texture; + + gl_state_enable_blend(); + gl_state_set_blend_func(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + gl_state_set_blend_equation(GL_FUNC_ADD); + gl_state_disable_depth_test(); + + quad_shader_data quad_data = {}; + quad_data.g_texcoord_modifier = { 0.5f, 0.5f, 0.5f, 0.5f }; + rctx->quad_ubo.WriteMemory(quad_data); + + contour_params_shader_data contour_params_data = {}; + contour_params_data.g_near_far = rctx->g_near_far; + rctx->contour_params_ubo.WriteMemory(contour_params_data); + + shaders_ft.set(SHADER_FT_CONTOUR_NPR); + gl_state_active_bind_texture_2d(16, contour_rt->GetColorTex()); + gl_state_bind_sampler(16, rctx->render_samplers[1]); + gl_state_active_bind_texture_2d(17, contour_rt->GetDepthTex()); + gl_state_bind_sampler(17, rctx->render_samplers[1]); + gl_state_active_bind_texture_2d(14, rt->GetDepthTex()); + gl_state_bind_sampler(14, rctx->render_samplers[1]); + rctx->quad_ubo.Bind(0); + rctx->contour_params_ubo.Bind(2); + gl_state_bind_vertex_array(rctx->common_vao); + shaders_ft.draw_arrays(GL_TRIANGLE_STRIP, 0, 4); + + if (effect_texture) + gl_state_active_bind_texture_2d(14, effect_texture->tex); + else + gl_state_active_bind_texture_2d(14, rctx->empty_texture_2d); + gl_state_enable_depth_test(); + gl_state_disable_blend(); + } + + void RenderManager::pass_sprite_surf() { + if (!sprite_manager_get_reqlist_count(1)) + return; + + rndr::Render* rend = render; + + gl_state_set_depth_mask(GL_FALSE); + gl_state_disable_depth_test(); + gl_state_disable_depth_test(); + gl_state_enable_blend(); + gl_state_disable_cull_face(); + sprite_manager_draw(1, true, + rend->temp_buffer.color_texture); + } +} + +void image_filter_scale(GLuint dst, GLuint src, const vec4 scale) { + if (!dst || !src) + return; + + texture_param tex_params[2]; + texture_params_get(dst, &tex_params[0], src, &tex_params[1]); + + filter_scene_shader_data filter_scene = {}; + filter_scene.g_transform = { 1.0f, 1.0f, 0.0f, 0.0f }; + filter_scene.g_texcoord = { 1.0f, 1.0f, 0.0f, 0.0f }; + rctx->filter_scene_ubo.WriteMemory(filter_scene); + + imgfilter_batch_shader_data imgfilter_batch = {}; + imgfilter_batch.g_color_scale = 1.0f; + imgfilter_batch.g_color_offset = 0.0f; + imgfilter_batch.g_texture_lod = 0.0f; + rctx->imgfilter_batch_ubo.WriteMemory(imgfilter_batch); + + uniform->arr[U_IMAGE_FILTER] = 5; + shaders_ft.set(SHADER_FT_IMGFILT); + rctx->filter_scene_ubo.Bind(0); + rctx->imgfilter_batch_ubo.Bind(1); + gl_state_active_bind_texture_2d(0, src); + gl_state_bind_vertex_array(rctx->common_vao); + shaders_ft.draw_arrays(GL_TRIANGLE_STRIP, 0, 4); + + texture_params_restore(&tex_params[0], &tex_params[1]); +} + +void draw_pass_set_camera() { + camera_struct::update_data(); + mat4_transpose(&camera_data->view_matrix, &rctx->view_mat); + mat4_transpose(&camera_data->projection_matrix, &rctx->proj_mat); + mat4_transpose(&camera_data->view_projection_matrix, &rctx->vp_mat); + rctx->obj_scene.set_projection_view(rctx->view_mat, rctx->proj_mat); + *(vec3*)&rctx->obj_scene.g_view_position = camera_data->view_point; + rctx->obj_scene.g_view_position.w = 0.0f; + + float_t max_distance = camera_data->max_distance; + float_t min_distance = camera_data->min_distance; + rctx->g_near_far = { + (float_t)(max_distance / (max_distance - min_distance)), + (float_t)(-(max_distance * min_distance) / (max_distance - min_distance)), + 0.0f, 0.0f + }; +} + +HOOK(void, FASTCALL, render_manager_init_render_textures, 0x0000000140502560, int32_t multisample) { + rndr::RenderManager& render_manager = *::render_manager; + + if (multisample) { + glGenFramebuffers(1, &render_manager.multisample_framebuffer); + glGenRenderbuffers(1, &render_manager.multisample_renderbuffer); + + gl_state_bind_framebuffer(render_manager.multisample_framebuffer); + glBindRenderbuffer(GL_RENDERBUFFER, render_manager.multisample_renderbuffer); + glRenderbufferStorageMultisample(GL_RENDERBUFFER, 8, + GL_RGBA8, render_manager.width, render_manager.height); + glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, + GL_RENDERBUFFER, render_manager.multisample_renderbuffer); + glDrawBufferDLL(GL_COLOR_ATTACHMENT0); + glDrawBufferDLL(GL_COLOR_ATTACHMENT0); + gl_state_bind_framebuffer(0); + glBindRenderbuffer(GL_RENDERBUFFER, 0); + + if (glGetErrorDLL()) { + glDeleteRenderbuffers(1, &render_manager.multisample_renderbuffer); + render_manager.multisample_renderbuffer = 0; + glDeleteFramebuffers(1, &render_manager.multisample_framebuffer); + render_manager.multisample_framebuffer = 0; + } + } + + struct RenderTextureData { + GLenum type; + int32_t width; + int32_t height; + int32_t max_level; + GLenum color_format; + GLenum depth_format; + }; + + const RenderTextureData* render_manager_render_texture_data_array + = (const RenderTextureData*)0x0000000140A24420; + + for (int32_t i = 0; i < 9; i++) { + const RenderTextureData* tex_data = &render_manager_render_texture_data_array[i]; + if (tex_data->type != GL_TEXTURE_2D) + continue; + + RenderTexture& rt = render_manager.render_textures[i]; + rt.Init(tex_data->width, tex_data->height, tex_data->max_level, + tex_data->color_format, tex_data->depth_format); + rt.Bind(); + glClearColorDLL(0.0f, 0.0f, 0.0f, 0.0f); + glClearDLL(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + } + gl_state_bind_framebuffer(0); +} + +HOOK(void, FASTCALL, render_manager_free_render_textures, 0x00000001405027A0) { + rndr::RenderManager& render_manager = *::render_manager; + + if (render_manager.multisample_renderbuffer) { + glDeleteRenderbuffers(1, &render_manager.multisample_renderbuffer); + render_manager.multisample_renderbuffer = 0; + } + + if (render_manager.multisample_framebuffer) { + glDeleteFramebuffers(1, &render_manager.multisample_framebuffer); + render_manager.multisample_framebuffer = 0; + } + + for (RenderTexture& i : render_manager.render_textures) + i.Free(); +} + +void render_manager_patch() { + INSTALL_HOOK(render_manager_init_render_textures); + INSTALL_HOOK(render_manager_free_render_textures); +} + +static void draw_pass_shadow_begin_make_shadowmap(Shadow* shad, int32_t index, int32_t a3) { + shad->curr_render_textures[0]->Bind(); + shad->curr_render_textures[0]->SetViewport(); + texture* tex = shad->curr_render_textures[0]->color_texture; + glScissorDLL(0, 0, tex->width, tex->height); + gl_state_enable_depth_test(); + gl_state_enable_scissor_test(); + glClearColorDLL(1.0, 1.0, 1.0, 1.0); + if (!a3) + glClearDLL(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + else if (shad->field_2F5) + glClearDLL(GL_COLOR_BUFFER_BIT); + glScissorDLL(1, 1, tex->width - 2, tex->height - 2); + + float_t offset = 0.0f; + float_t range = shad->view_region * shad->range; + vec3* interest; + vec3* view_point; + if (shad->field_2F5) { + offset = -0.5f; + if (index) + offset = 0.5f; + + interest = &shad->interest[index]; + view_point = &shad->view_point[index]; + } + else { + interest = &shad->interest_shared; + view_point = &shad->view_point_shared; + } + + mat4 temp; + mat4_translate(offset, 0.0f, 0.0f, &temp); + + mat4 proj; + mat4_ortho(-range, range, -range, range, shad->z_near, shad->z_far, &proj); + mat4_mul(&proj, &temp, &rctx->proj_mat); + mat4_look_at(view_point, interest, &rctx->view_mat); + + draw_state->shader_index = SHADER_FT_SIL; + uniform->arr[U0A] = 0; +} + +static void draw_pass_shadow_end_make_shadowmap(Shadow* shad, int32_t index, int32_t a3) { + gl_state_disable_depth_test(); + gl_state_disable_scissor_test(); + + draw_state->shader_index = -1; + if (a3 == shad->field_2EC - 1) { + draw_pass_shadow_filter(&shad->render_textures[3], + &shad->render_textures[4], shad->curr_render_textures[0], + shad->field_2DC, shad->field_2E0 / (shad->field_208 * 2.0f), false); + draw_pass_shadow_esm_filter(&shad->render_textures[5], + &shad->render_textures[6], &shad->render_textures[3]); + } + + RenderTexture* rend_tex = shad->curr_render_textures[1 + index]; + RenderTexture& rend_buf_tex = rctx->shadow_buffer; + rend_tex->Bind(); + + image_filter_scale(rend_tex->GetColorTex(), + shad->curr_render_textures[0]->GetColorTex(), 1.0f); + + rend_buf_tex.Bind(); + if (shad->blur_filter_enable[index]) { + for (int32_t i = shad->near_blur, j = 0; i > 0; i--, j++) { + blur_filter_apply(&rend_buf_tex, rend_tex, + shad->blur_filter, 1.0f, 1.0f, 0.0f); + glCopyTexSubImage2DDLL(GL_TEXTURE_2D, 0, 0, 0, 0, 0, rend_buf_tex.GetWidth(), rend_buf_tex.GetHeight()); + } + } + else { + glClearColorDLL(1.0f, 1.0f, 1.0f, 1.0f); + glClearDLL(GL_COLOR_BUFFER_BIT); + } + + gl_state_bind_framebuffer(0); + gl_state_bind_texture_2d(rend_tex->GetColorTex()); + glGenerateMipmap(GL_TEXTURE_2D); + gl_state_bind_texture_2d(0); +} + +static void draw_pass_shadow_filter(RenderTexture* a1, RenderTexture* a2, + RenderTexture* a3, float_t sigma, float_t far_texel_offset, bool enable_lit_proj) { + GLuint v7 = a1->GetColorTex(); + GLuint v9 = a2->GetColorTex(); + GLuint v11 = v7; + if (a3) + v11 = a3->GetDepthTex(); + + if (!v7 || !v9 || !v11) + return; + + texture_param tex_params[2]; + texture_params_get(v7, &tex_params[0], v9, &tex_params[1]); + if (tex_params[0].width != tex_params[1].width + || tex_params[0].height != tex_params[1].height) + return; + + filter_scene_shader_data filter_scene = {}; + filter_scene.g_transform = 0.0f; + filter_scene.g_texcoord = { 1.0f, 1.0f, 0.0f, 0.0f }; + rctx->filter_scene_ubo.WriteMemory(filter_scene); + + esm_filter_batch_shader_data esm_filter_batch = {}; + esm_filter_batch.g_params = { 1.0f / (float_t)tex_params[0].width, 0.0f, far_texel_offset, far_texel_offset }; + double_t v6 = 1.0 / (sqrt(M_PI * 2.0) * sigma); + double_t v8 = -1.0 / (2.0 * sigma * sigma); + for (int32_t i = 0; i < 8; i++) + ((float_t*)esm_filter_batch.g_gauss)[i] = (float_t)(exp((double_t)((ssize_t)i * i) * v8) * v6); + + uniform->arr[U_LIGHT_PROJ] = enable_lit_proj ? 1 : 0; + shaders_ft.set(SHADER_FT_ESMGAUSS); + rctx->filter_scene_ubo.Bind(0); + rctx->esm_filter_batch_ubo.Bind(1); + + a2->Bind(); + esm_filter_batch.g_params = { 1.0f / (float_t)tex_params[0].width, 0.0f, far_texel_offset, far_texel_offset }; + rctx->esm_filter_batch_ubo.WriteMemory(esm_filter_batch); + + gl_state_active_bind_texture_2d(0, v11); + if (a3) { + GLint swizzle[] = { GL_RED, GL_RED, GL_RED, GL_ONE }; + glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_RGBA, swizzle); + } + else { + GLint swizzle[] = { GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA }; + glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_RGBA, swizzle); + } + gl_state_bind_vertex_array(rctx->common_vao); + shaders_ft.draw_arrays(GL_TRIANGLE_STRIP, 0, 4); + + a1->Bind(); + + esm_filter_batch.g_params = { 0.0f, 1.0f / (float_t)tex_params[0].height, far_texel_offset, far_texel_offset }; + rctx->esm_filter_batch_ubo.WriteMemory(esm_filter_batch); + + gl_state_active_bind_texture_2d(0, v9); + gl_state_bind_vertex_array(rctx->common_vao); + shaders_ft.draw_arrays(GL_TRIANGLE_STRIP, 0, 4); + shader_glsl::unbind(); + + texture_params_restore(&tex_params[0], &tex_params[1], 0); +} + +static void draw_pass_shadow_esm_filter(RenderTexture* dst, RenderTexture* buf, RenderTexture* src) { + GLuint dst_tex = dst->GetColorTex(); + GLuint buf_tex = buf->GetColorTex(); + GLuint src_tex = src->GetColorTex(); + if (!dst_tex || !buf_tex || !src_tex) + return; + + filter_scene_shader_data filter_scene = {}; + filter_scene.g_transform = 0.0f; + filter_scene.g_texcoord = { 1.0f, 1.0f, 0.0f, 0.0f }; + rctx->filter_scene_ubo.WriteMemory(filter_scene); + + esm_filter_batch_shader_data esm_filter_batch = {}; + esm_filter_batch.g_gauss[0] = 0.0f; + esm_filter_batch.g_gauss[1] = 0.0f; + + rctx->filter_scene_ubo.Bind(0); + rctx->esm_filter_batch_ubo.Bind(1); + + texture_param tex_params[3]; + texture_params_get(dst_tex, &tex_params[0], src_tex, &tex_params[1], buf_tex, &tex_params[2]); + + buf->Bind(); + esm_filter_batch.g_params = { 1.0f / (float_t)tex_params[1].width, + 1.0f / (float_t)tex_params[1].height, 0.0f, 0.0f }; + rctx->esm_filter_batch_ubo.WriteMemory(esm_filter_batch); + + uniform->arr[U_ESM_FILTER] = 0; + shaders_ft.set(SHADER_FT_ESMFILT); + gl_state_active_bind_texture_2d(0, src_tex); + gl_state_bind_vertex_array(rctx->common_vao); + shaders_ft.draw_arrays(GL_TRIANGLE_STRIP, 0, 4); + + dst->Bind(); + esm_filter_batch.g_params = { 0.75f / (float_t)tex_params[2].width, + 0.75f / (float_t)tex_params[2].height, 0.0f, 0.0f }; + rctx->esm_filter_batch_ubo.WriteMemory(esm_filter_batch); + + uniform->arr[U_ESM_FILTER] = 1; + shaders_ft.set(SHADER_FT_ESMFILT); + gl_state_active_bind_texture_2d(0, buf_tex); + gl_state_bind_vertex_array(rctx->common_vao); + shaders_ft.draw_arrays(GL_TRIANGLE_STRIP, 0, 4); + + texture_params_restore(&tex_params[0], &tex_params[1], &tex_params[2]); +} + +static bool draw_pass_shadow_litproj() { + if (!*stage_param_data_litproj_current) + return false; + + texture* tex = texture_handler_get_texture((*stage_param_data_litproj_current)->tex_id); + if (!tex) + return false; + + litproj_texture->Bind(); + litproj_texture->SetViewport(); + gl_state_enable_depth_test(); + glClearColorDLL(0.0f, 0.0f, 0.0f, 0.0f); + glClearDepthf(1.0f); + glClearDLL(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + + if (!draw_pass_shadow_litproj_set_mat(false)) { + gl_state_bind_framebuffer(0); + return false; + } + + draw_state->shader_index = SHADER_FT_LITPROJ; + gl_state_active_bind_texture_2d(17, tex->tex); + gl_state_bind_sampler(17, rctx->render_samplers[2]); + gl_state_active_bind_texture_2d(18, litproj_shadow[0].GetColorTex()); + gl_state_bind_sampler(18, rctx->render_samplers[2]); + gl_state_active_texture(0); + return true; +} + +static bool draw_pass_shadow_litproj_set() { + if (!*stage_param_data_litproj_current) + return 0; + + static const vec4 color_clear = 1.0f; + static const GLfloat depth_clear = 1.0f; + + litproj_shadow[0].Bind(); + glViewportDLL(0, 0, 2048, 512); + gl_state_enable_depth_test(); + gl_state_set_depth_mask(GL_TRUE); + glClearBufferfv(GL_COLOR, 0, (float_t*)&color_clear); + glClearBufferfv(GL_DEPTH, 0, &depth_clear); + + if (draw_pass_shadow_litproj_set_mat(false)) { + draw_state->shader_index = SHADER_FT_SIL; + uniform->arr[U0A] = 1; + return true; + } + else { + litproj_texture->Bind(); + litproj_texture->SetViewport(); + gl_state_enable_depth_test(); + gl_state_set_depth_mask(GL_TRUE); + glClearBufferfv(GL_COLOR, 0, (float_t*)&color_clear); + glClearBufferfv(GL_DEPTH, 0, &depth_clear); + } + return false; +} + +static bool draw_pass_shadow_litproj_set_mat(bool set_mat) { + light_set* set = &light_set_data[LIGHT_SET_MAIN]; + light_data* data = &set->lights[LIGHT_PROJECTION]; + if (data->get_type() != LIGHT_SPOT) + return false; + + vec3 position; + vec3 spot_direction; + data->get_position(position); + data->get_spot_direction(spot_direction); + + if (vec3::length_squared(spot_direction) <= 0.000001f) + return false; + + float_t spot_cutoff = data->get_spot_cutoff(); + float_t fov = atanf(tanf(spot_cutoff * DEG_TO_RAD_FLOAT) * 0.25f) * 2.0f; + + vec3 interest = position + spot_direction; + if (set_mat) { + mat4 temp; + mat4_translate(0.5f, 0.5f, 0.5f, &temp); + mat4_scale_rot(&temp, 0.5f, 0.5f, 0.5f, &temp); + + mat4 proj; + mat4_persp(fov, 4.0f, 0.1f, 10.0f, &proj); + mat4_mul(&proj, &temp, &proj); + + mat4 view; + vec3 up = { 0.0f, 1.0f, 0.0f }; + mat4_look_at(&position, &interest, &up, &view); + + mat4 mat; + mat4_mul(&view, &proj, &mat); + rctx->obj_scene.set_g_light_projection(mat); + } + else { + mat4_persp(fov, 4.0f, 0.1f, 10.0f, &rctx->proj_mat); + + vec3 up = { 0.0f, 1.0f, 0.0f }; + mat4_look_at(&position, &interest, &up, &rctx->view_mat); + rctx->obj_scene.set_projection_view(rctx->view_mat, rctx->proj_mat); + } + return true; +} + +static void draw_pass_sss_contour(rndr::Render* rend) { + rend->sss_contour_texture->Bind(); + rend->sss_contour_texture->SetViewport(); + gl_state_enable_depth_test(); + gl_state_set_depth_func(GL_ALWAYS); + gl_state_set_depth_mask(GL_TRUE); + glViewportDLL(0, 0, rend->render_width[0], rend->render_height[0]); + gl_state_active_bind_texture_2d(0, rend->rend_texture[0].GetColorTex()); + gl_state_bind_sampler(0, rctx->render_samplers[1]); + gl_state_active_bind_texture_2d(1, rend->rend_texture[0].GetDepthTex()); + gl_state_bind_sampler(1, rctx->render_samplers[1]); + gl_state_active_texture(0); + + float_t v3 = 1.0f / tanf(camera_data->fov * 0.5f * DEG_TO_RAD_FLOAT); + + vec3 direction = camera_data->interest - camera_data->view_point; + float_t length = vec3::length(direction); + float_t v7 = direction.y; + if (length != 0.0f) + v7 /= length; + + float_t v9 = fabsf(v7) - 0.1f; + if (v9 < 0.0f) + v9 = 0.0f; + + contour_coef_shader_data shader_data = {}; + shader_data.g_contour = { v9 * 0.004f + 0.0027f, 0.003f, v3 * 0.35f, 0.0008f }; + shader_data.g_near_far = rctx->g_near_far; + rctx->contour_coef_ubo.WriteMemory(shader_data); + + shaders_ft.set(SHADER_FT_CONTOUR); + rctx->contour_coef_ubo.Bind(2); + render->draw_quad( + rend->render_post_width[0], rend->render_post_height[0], + rend->render_post_width_scale, rend->render_post_height_scale, + 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f); +} + +static void draw_pass_sss_filter_calc_coef(double_t a1, size_t a2, double_t a3, size_t a4, + const double_t* a5, const double_t* a6, const double_t* a7, const double_t* a8, vec4 params[64]) { + if (a2 > 8) + return; + + for (size_t i = a4; i; i--) { + float_t* v20 = (float_t*)params; + double_t v56[3]; + v56[0] = *a6; + v56[1] = *a7; + v56[2] = *a8; + + for (size_t j = 0; j < 3; j++) { + double_t v22 = 0.0; + double_t v23 = 0.0; + double_t v54[8]; + double_t v24 = 1.0 / (a3 * v56[j]); + v24 *= v24; + for (size_t k = 0; k < a2; k++) { + double_t v25 = exp(-0.5 * (v23 * v23) * v24); + v54[k] = v25; + v23 += a1; + v22 += v25; + } + + double_t v27 = 1.0 / v22; + for (size_t k = 0; k < a2; k++) + v54[k] *= v27; + + float_t* v35 = v20; + for (size_t k = 0; k < a2; k++) { + double_t v37 = v54[k] * *a5; + for (size_t v36 = 0; v36 < a2; v36++) { + *v35 += (float_t)(v37 * v54[v36]); + v35 += 4; + } + } + v20++; + } + a5++; + a6++; + a7++; + a8++; + } +} + +static void draw_pass_sss_filter(sss_data* sss) { + const int32_t sss_count = 6; + vec3 interest = camera_data->interest; + vec3 view_point = camera_data->view_point; + + vec3 chara_position[2]; + chara_position[0] = 0.0f; + chara_position[1] = 0.0f; + float_t chara_distance[2]; + size_t rob_chara_smth = get_rob_chara_smth(); + for (int32_t i = 0; i < 2; i++) { + chara_position[i] = interest; + chara_distance[i] = 999999.0f; + size_t rob_bone_data = rob_chara_array_get_bone_data(rob_chara_smth, i); + if (rob_chara_pv_data_array_check_chara_id(rob_chara_smth, i) + && rob_chara_array_check_visibility(rob_chara_smth, i)) { + mat4* mat = rob_chara_bone_data_get_mats_mat(rob_bone_data, 0); + if (mat) { + mat4_get_translation(mat, &chara_position[i]); + chara_distance[i] = vec3::distance(view_point, chara_position[i]); + } + } + } + + vec3 closest_chara_position; + if (chara_distance[0] > chara_distance[1]) { + closest_chara_position = chara_position[1]; + chara_position[0] = chara_position[1]; + } + else + closest_chara_position = chara_position[0]; + + float_t length = vec3::distance(interest, closest_chara_position); + if (length > 1.25f) + interest = chara_position[0]; + + float_t v29 = vec3::distance(view_point, interest); + if (v29 < 0.25f) + v29 = 0.25f; + float_t v31 = tanf(camera_data->fov * 0.5f * DEG_TO_RAD_FLOAT) * 5.0f; + if (v31 < 0.25f) + v31 = 0.25f; + float_t v32 = v31 * v29; + float_t v33 = 0.6f; + float_t v34 = 1.0f / clamp_def(v32, 0.25f, 100.0f); + if (v34 < 0.145f) { + float_t v36 = v34 - 0.02f; + if (v34 < 0.0f) + v36 = 0.0f; + v33 = (v36 * 8.0f) * 0.6f; + } + rctx->obj_batch.g_sss_param = { v33, 0.0f, 0.0f, 0.0f }; + + gl_state_active_texture(0); + if (sss->npr_contour) { + sss->textures[0].Bind(); + glViewportDLL(0, 0, 640, 360); + rndr::Render* rend = render; + uniform->arr[U_REDUCE] = 0; + shaders_ft.set(SHADER_FT_REDUCE); + gl_state_bind_texture_2d(rend->rend_texture[0].GetColorTex()); + render->draw_quad(640, 360, 1.0f, 1.0f, + 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 0.0f); + } + sss->textures[2].Bind(); + glViewportDLL(0, 0, 320, 180); + uniform->arr[U_SSS_FILTER] = 0; + shaders_ft.set(SHADER_FT_SSS_FILT); + gl_state_bind_texture_2d(sss->textures[0].GetColorTex()); + render->draw_quad(640, 360, 1.0f, 1.0f, + 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 0.0f); + + sss_filter_gaussian_coef_shader_data shader_data = {}; + shader_data.g_param = { (float_t)(sss_count - 1), 0.0f, 1.0f, 1.0f }; + + const double_t a5[] = { 0.4, 0.3, 0.3 }; + const double_t a6[] = { 1.0, 2.0, 5.0 }; + const double_t a7[] = { 0.2, 0.4, 1.2 }; + const double_t a8[] = { 0.3, 0.7, 2.0 }; + draw_pass_sss_filter_calc_coef(1.0, sss_count, v34, 3, a5, a6, a7, a8, shader_data.g_coef); + + rctx->sss_filter_gaussian_coef_ubo.WriteMemory(shader_data); + sss->textures[1].Bind(); + glViewportDLL(0, 0, 320, 180); + uniform->arr[U_SSS_FILTER] = 3; + shaders_ft.set(SHADER_FT_SSS_FILT); + gl_state_bind_texture_2d(sss->textures[2].GetColorTex()); + rctx->sss_filter_gaussian_coef_ubo.Bind(1); + render->draw_quad(320, 180, 1.0f, 1.0f, + 0.0f, 0.0f, 1.0f, 1.0f, 0.96f, 1.0f, 0.0f); + gl_state_bind_texture_2d(0); +} + +static int32_t draw_pass_3d_get_translucent_count() { + int32_t count = 0; + count += disp_manager->get_obj_count(mdl::OBJ_TYPE_OPAQUE_ALPHA_ORDER_1); + count += disp_manager->get_obj_count(mdl::OBJ_TYPE_TRANSPARENT_ALPHA_ORDER_1); + count += disp_manager->get_obj_count(mdl::OBJ_TYPE_TRANSLUCENT_ALPHA_ORDER_1); + count += disp_manager->get_obj_count(mdl::OBJ_TYPE_OPAQUE_ALPHA_ORDER_2); + count += disp_manager->get_obj_count(mdl::OBJ_TYPE_TRANSPARENT_ALPHA_ORDER_2); + count += disp_manager->get_obj_count(mdl::OBJ_TYPE_TRANSLUCENT_ALPHA_ORDER_2); + count += disp_manager->get_obj_count(mdl::OBJ_TYPE_OPAQUE_ALPHA_ORDER_3); + count += disp_manager->get_obj_count(mdl::OBJ_TYPE_TRANSPARENT_ALPHA_ORDER_3); + count += disp_manager->get_obj_count(mdl::OBJ_TYPE_TRANSLUCENT_ALPHA_ORDER_3); + //count += disp_manager->get_obj_count(mdl::OBJ_TYPE_OPAQUE_ALPHA_ORDER_2_LOCAL); + //count += disp_manager->get_obj_count(mdl::OBJ_TYPE_TRANSPARENT_ALPHA_ORDER_2_LOCAL); + //count += disp_manager->get_obj_count(mdl::OBJ_TYPE_TRANSLUCENT_ALPHA_ORDER_2_LOCAL); + return count; +} + +static void draw_pass_3d_shadow_reset() { + gl_state_active_bind_texture_2d(6, 0); + gl_state_active_bind_texture_2d(7, 0); + rctx->obj_scene.set_g_self_shadow_receivers(0, mat4_identity); + rctx->obj_scene.set_g_self_shadow_receivers(1, mat4_identity); + draw_state->self_shadow = false; + draw_state->light = false; +} + +static void draw_pass_3d_shadow_set(Shadow* shad) { + if (shad->self_shadow && shad->field_2EC > 0) { + gl_state_active_bind_texture_2d(19, shad->render_textures[3].GetColorTex()); + gl_state_active_bind_texture_2d(20, shad->render_textures[5].GetColorTex()); + gl_state_active_texture(0); + float_t esm_param = (shad->field_2D8 * shad->field_208 * 2.0f) * 1.442695f; + rctx->obj_scene.g_esm_param = { esm_param, 0.0f, 0.0f, 0.0f }; + draw_state->self_shadow = true; + } + else { + gl_state_active_bind_texture_2d(19, rctx->empty_texture_2d); + gl_state_active_bind_texture_2d(20, rctx->empty_texture_2d); + gl_state_active_texture(0); + draw_state->self_shadow = false; + } + + if (shad->field_2EC > 0) { + draw_state->light = true; + uniform->arr[U_LIGHT_1] = shad->field_2EC > 1 ? 1 : 0; + + float_t range = shad->view_region * shad->range; + for (int32_t i = 0; i < 2; i++) { + float_t v6 = 0.0f; + vec3* interest; + vec3* view_point; + if (shad->field_2F5) { + v6 = i ? 0.5f : -0.5f; + + interest = &shad->interest[i]; + view_point = &shad->view_point[i]; + } + else { + interest = &shad->interest_shared; + view_point = &shad->view_point_shared; + } + + mat4 temp; + mat4_translate(0.5f, 0.5f, 0.5f, &temp); + mat4_scale_rot(&temp, 0.5f, 0.5f, 0.5f, &temp); + mat4_mul_translate(&temp, v6, 0.0f, 0.0f, &temp); + + mat4 proj; + mat4_ortho(-range, range, -range, range, shad->z_near, shad->z_far, &proj); + mat4_mul(&proj, &temp, &proj); + + mat4 view; + mat4_look_at(view_point, interest, &view); + mat4_mul(&view, &proj, &view); + rctx->obj_scene.set_g_self_shadow_receivers(i, view); + } + + for (int32_t i = 0, j = 0; i < 2; i++) { + if (!shad->field_2F0[i]) { + gl_state_active_bind_texture_2d(6 + j, rctx->empty_texture_2d); + continue; + } + + gl_state_active_bind_texture_2d(6 + j, shad->curr_render_textures[1 + i]->GetColorTex()); + glTexParameterfDLL(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, 16.0f); + j++; + } + gl_state_active_texture(0); + + light_set* set = &light_set_data[LIGHT_SET_MAIN]; + light_data* data = &set->lights[LIGHT_SHADOW]; + + vec4 ambient; + if (data->get_type() == LIGHT_PARALLEL) + data->get_ambient(ambient); + else { + ambient.x = shad->ambient; + ambient.y = shad->ambient; + ambient.z = shad->ambient; + } + + rctx->obj_scene.g_shadow_ambient = { ambient.x, ambient.y, ambient.z, 1.0f }; + rctx->obj_scene.g_shadow_ambient1 = { 1.0f - ambient.x, 1.0f - ambient.y, 1.0f - ambient.z, 0.0f }; + } + else { + draw_state->light = false; + + for (int32_t i = 0; i < 2; i++) + gl_state_active_bind_texture_2d(6 + i, shad->curr_render_textures[1 + i]->GetColorTex()); + gl_state_active_texture(0); + + rctx->obj_scene.g_shadow_ambient = 1.0f; + rctx->obj_scene.g_shadow_ambient1 = 0.0f; + } +} + +static void draw_pass_3d_translucent(bool opaque_enable, + bool transparent_enable, bool translucent_enable, mdl::ObjType opaque, + mdl::ObjType transparent, mdl::ObjType translucent) { + if (disp_manager->get_obj_count(opaque) < 1 + && disp_manager->get_obj_count(transparent) < 1 + && disp_manager->get_obj_count(translucent) < 1) + return; + + rndr::Render* rend = render; + + int32_t alpha_array[256]; + int32_t count = draw_pass_3d_translucent_count_layers( + alpha_array, opaque, transparent, translucent); + for (int32_t i = 0; i < count; i++) { + int32_t alpha = alpha_array[i]; + rend->transparency_copy(); + if (opaque_enable && disp_manager->get_obj_count(opaque)) + disp_manager->draw_translucent(opaque, alpha); + if (transparent_enable && disp_manager->get_obj_count(transparent)) + disp_manager->draw_translucent(transparent, alpha); + if (translucent_enable && disp_manager->get_obj_count(translucent)) { + gl_state_enable_blend(); + disp_manager->draw_translucent(translucent, alpha); + gl_state_disable_blend(); + } + rend->transparency_combine((float_t)alpha * (float_t)(1.0 / 255.0)); + } +} + +static int32_t draw_pass_3d_translucent_count_layers(int32_t* alpha_array, + mdl::ObjType opaque, mdl::ObjType transparent, mdl::ObjType translucent) { + bool arr[256] = { 0 }; + + draw_pass_3d_translucent_has_objects(arr, opaque); + draw_pass_3d_translucent_has_objects(arr, transparent); + draw_pass_3d_translucent_has_objects(arr, translucent); + + int32_t count = 0; + for (int32_t i = 0xFF; i >= 1; i--) + if (arr[i]) { + count++; + *alpha_array++ = i; + } + return count; +} + +static void draw_pass_3d_translucent_has_objects(bool* arr, mdl::ObjType type) { + prj::list& vec = disp_manager->obj[type]; + for (mdl::ObjData*& i : vec) + switch (i->kind) { + case mdl::OBJ_KIND_NORMAL: { + int32_t alpha = (int32_t)(i->args.sub_mesh.blend_color.w * 255.0f); + alpha = clamp_def(alpha, 0, 255); + arr[alpha] = true; + } break; + case mdl::OBJ_KIND_TRANSLUCENT: { + for (uint32_t j = 0; j < i->args.translucent.count; j++) { + int32_t alpha = (int32_t)(i->args.translucent.sub_mesh[j]->blend_color.w * 255.0f); + alpha = clamp_def(alpha, 0, 255); + arr[alpha] = true; + } + } break; + } +} + +static void blur_filter_apply(RenderTexture* dst, RenderTexture* src, + blur_filter_mode filter, const vec2 res_scale, const vec4 scale, const vec4 offset) { + if (!dst || !src) + return; + + filter_scene_shader_data filter_scene = {}; + float_t w = res_scale.x / (float_t)src->GetWidth(); + float_t h = res_scale.y / (float_t)src->GetHeight(); + filter_scene.g_transform = { w, h, 0.0f, 0.0f }; + filter_scene.g_texcoord = { 1.0f, 1.0f, 0.0f, 0.0f }; + rctx->filter_scene_ubo.WriteMemory(filter_scene); + + imgfilter_batch_shader_data imgfilter_batch = {}; + if (filter == BLUR_FILTER_32) + imgfilter_batch.g_color_scale = scale * (float_t)(1.0 / 8.0); + else + imgfilter_batch.g_color_scale = scale * (float_t)(1.0 / 4.0); + imgfilter_batch.g_color_offset = offset; + imgfilter_batch.g_texture_lod = 0.0f; + rctx->imgfilter_batch_ubo.WriteMemory(imgfilter_batch); + + uniform->arr[U_IMAGE_FILTER] = filter == BLUR_FILTER_32 ? 1 : 0; + gl_state_bind_vertex_array(rctx->box_vao); + shaders_ft.set(SHADER_FT_IMGFILT); + rctx->filter_scene_ubo.Bind(0); + rctx->imgfilter_batch_ubo.Bind(1); + gl_state_active_bind_texture_2d(0, src->GetColorTex()); + //shaders_ft.draw_arrays(GL_TRIANGLE_STRIP, (GLint)(filter * 4LL), 4); +} diff --git a/src/DivaGL/render_manager.hpp b/src/DivaGL/render_manager.hpp new file mode 100644 index 0000000..da9a711 --- /dev/null +++ b/src/DivaGL/render_manager.hpp @@ -0,0 +1,154 @@ +/* + by korenkonder + GitHub/GitLab: korenkonder +*/ + +#pragma once + +#include "../KKdLib/default.hpp" +#include "../KKdLib/vec.hpp" +#include "render.hpp" +#include "shadow.hpp" +#include "types.hpp" +#include "wrap.hpp" + +enum draw_pass_3d_type { + DRAW_PASS_3D_OPAQUE = 0, + DRAW_PASS_3D_TRANSLUCENT, + DRAW_PASS_3D_TRANSPARENT, + DRAW_PASS_3D_MAX, +}; + +enum reflect_refract_resolution_mode { + REFLECT_REFRACT_RESOLUTION_256x256 = 0, + REFLECT_REFRACT_RESOLUTION_512x256, + REFLECT_REFRACT_RESOLUTION_512x512, + REFLECT_REFRACT_RESOLUTION_MAX, +}; + +enum stage_data_reflect_type { + STAGE_DATA_REFLECT_DISABLE = 0x00, + STAGE_DATA_REFLECT_NORMAL = 0x01, + STAGE_DATA_REFLECT_REFLECT_MAP = 0x02, +}; + +struct draw_pre_process { + int32_t type; + void(FASTCALL* func)(void*); + void* data; +}; + +namespace rndr { + enum RenderPassID { + RND_PASSID_SHADOW = 0, + RND_PASSID_SS_SSS, + RND_PASSID_2, + RND_PASSID_REFLECT, + RND_PASSID_REFRACT, + RND_PASSID_PRE_PROCESS, + RND_PASSID_CLEAR, + RND_PASSID_PRE_SPRITE, + RND_PASSID_3D, + RND_PASSID_SHOW_VECTOR, + RND_PASSID_POST_PROCESS, + RND_PASSID_SPRITE, + RND_PASSID_12, + RND_PASSID_NUM, + }; + + struct RenderManager { + bool pass_sw[RND_PASSID_NUM]; + struct Shadow* shadow_ptr; + bool reflect; + bool refract; + int32_t reflect_blur_num; + blur_filter_mode reflect_blur_filter; + rndr::Render* render; + bool sync_gpu; + double_t cpu_time[RND_PASSID_NUM]; + double_t gpu_time[RND_PASSID_NUM]; + time_struct time; + bool shadow; + bool opaque_z_sort; + bool alpha_z_sort; + bool draw_pass_3d[DRAW_PASS_3D_MAX]; + bool field_11E; + bool field_11F; + bool field_120; + bool show_ref_map; + stage_data_reflect_type reflect_type; + bool clear; + int32_t tex_index[11]; + RenderTexture render_textures[8]; + int32_t width; + int32_t height; + GLuint multisample_framebuffer; + GLuint multisample_renderbuffer; + bool multisample; + bool check_state; + int32_t show_vector_flags; + float_t show_vector_length; + float_t show_vector_z_offset; + bool field_2F8; + prj::list pre_process; + texture* effect_texture; + int32_t npr_param; + bool field_31C; + bool field_31D; + bool field_31E; + bool field_31F; + bool field_320; + bool npr; + + void add_pre_process(int32_t type, void(*func)(void*), void* data); + void clear_pre_process(int32_t type); + RenderTexture& get_render_texture(int32_t index); + void resize(int32_t width, int32_t height); + void set_effect_texture(texture* value); + void set_multisample(bool value); + void set_npr_param(int32_t value); + void set_pass_sw(rndr::RenderPassID id, bool value); + void set_reflect(bool value); + void set_reflect_blur(int32_t reflect_blur_num, blur_filter_mode reflect_blur_filter); + void set_reflect_resolution_mode(reflect_refract_resolution_mode mode); + void set_reflect_type(stage_data_reflect_type type); + void set_refract(bool value); + void set_refract_resolution_mode(reflect_refract_resolution_mode mode); + void set_shadow_false(); + void set_shadow_true(); + + void render_all(); + + void render_single_pass(rndr::RenderPassID id); + + void render_pass_begin(); + void render_pass_end(rndr::RenderPassID id); + + void pass_shadow(); + void pass_ss_sss(); + void pass_reflect(); + void pass_refract(); + void pass_pre_process(); + void pass_clear(); + void pass_pre_sprite(); + void pass_3d(); + void pass_show_vector(); + void pass_post_process(); + void pass_sprite(); + + void pass_3d_contour(); + void pass_sprite_surf(); + }; + + static_assert(sizeof(rndr::RenderManager) == 0x328, "\"rndr::RenderManager\" struct should have a size of 0x328"); +} + +extern RenderTexture* litproj_shadow; +extern RenderTexture* litproj_texture; +extern rndr::RenderManager* render_manager; + +extern void image_filter_scale(GLuint dst, GLuint src, const vec4 scale); + +extern void draw_pass_set_camera(); + +extern void render_manager_patch(); diff --git a/src/DivaGL/render_texture.cpp b/src/DivaGL/render_texture.cpp new file mode 100644 index 0000000..13f003c --- /dev/null +++ b/src/DivaGL/render_texture.cpp @@ -0,0 +1,43 @@ +/* + by korenkonder + GitHub/GitLab: korenkonder +*/ + +#include "render_texture.hpp" +#include "gl_state.hpp" + +int32_t RenderTexture::Bind(int32_t index) { + if (index < 0 || index > max_level) + return -1; + + gl_state_bind_framebuffer(fbos[index]); + if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) + return -1; + + gl_state_get_error(); + return 0; +} + +void RenderTexture::Free() { + static void (FASTCALL * RenderTexture__Free)(RenderTexture * rt) + = (void (FASTCALL*)(RenderTexture * rt))0x00000001405035C0; + RenderTexture__Free(this); +} + +int32_t RenderTexture::Init(int32_t width, int32_t height, + int32_t max_level, GLenum color_format, GLenum depth_format) { + static int32_t(FASTCALL * RenderTexture__Init)(RenderTexture * rt, int32_t width, int32_t height, + int32_t max_level, GLenum color_format, GLenum depth_format) + = (int32_t(FASTCALL*)(RenderTexture * rt, int32_t width, int32_t height, + int32_t max_level, GLenum color_format, GLenum depth_format))0x0000000140503420; + return RenderTexture__Init(this, width, height, max_level, color_format, depth_format); +} + +int32_t RenderTexture::SetColorDepthTextures(GLuint color_texture, + int32_t max_level, GLuint depth_texture) { + int32_t(FASTCALL * RenderTexture__SetColorDepthTextures)(RenderTexture * rt, + GLuint color_texture, int32_t level, GLuint depth_texture) + = (int32_t(FASTCALL*)(RenderTexture * rt, + GLuint color_texture, int32_t level, GLuint depth_texture))0x0000000140503130; + return RenderTexture__SetColorDepthTextures(this, color_texture, max_level, depth_texture); +} diff --git a/src/DivaGL/render_texture.hpp b/src/DivaGL/render_texture.hpp new file mode 100644 index 0000000..af29314 --- /dev/null +++ b/src/DivaGL/render_texture.hpp @@ -0,0 +1,49 @@ +/* + by korenkonder + GitHub/GitLab: korenkonder +*/ + +#pragma once + +#include "shared.hpp" +#include "texture.hpp" + +struct RenderTexture { + void* __vftable; + texture* color_texture; + texture* depth_texture; + int32_t binding; + int32_t max_level; + GLuint* fbos; + GLuint rbo; + GLuint field_2C; + + int32_t Bind(int32_t index = 0); + void Free(); + int32_t Init(int32_t width, int32_t height, + int32_t max_level, GLenum color_format, GLenum depth_format); + int32_t SetColorDepthTextures(GLuint color_texture, + int32_t max_level = 0, GLuint depth_texture = 0); + + inline GLuint GetColorTex() { + return color_texture->tex; + }; + + inline GLuint GetDepthTex() { + return depth_texture->tex; + }; + + inline int32_t GetHeight() { + return color_texture->height; + }; + + inline int32_t GetWidth() { + return color_texture->width; + }; + + inline void SetViewport() { + glViewportDLL(0, 0, GetWidth(), GetHeight()); + }; +}; + +static_assert(sizeof(RenderTexture) == 0x30, "\"RenderTexture\" struct should have a size of 0x30"); diff --git a/src/DivaGL/renderer/dof.cpp b/src/DivaGL/renderer/dof.cpp new file mode 100644 index 0000000..5233cce --- /dev/null +++ b/src/DivaGL/renderer/dof.cpp @@ -0,0 +1,273 @@ +/* + by korenkonder + GitHub/GitLab: korenkonder +*/ + +#include "dof.hpp" +#include "../rob/rob.hpp" +#include "../camera.hpp" +#include "../gl_state.hpp" +#include "../render_context.hpp" + +struct dof_common_shader_data { + vec4 g_depth_params; //x=(n-f)/(nf), y=1/n, z=coc_from_z_scale, w=coc_from_z_offset + vec4 g_spread_scale; //x=scale_from_meter_to_pixel, y=scale_from_meter_to_sample, + // z=scale_from_pixel_to_sample, w=scale_from_sample_to_pixel + vec4 g_depth_params2; //x=distance_to_focus_m, y=focus_range, + // z=k/(fuzzing_range*fuzzing_range), w=max_coc_radius_in_pixel //yzw=for_f2 +}; + +dof_debug* dof_debug_data = (dof_debug*)0x00000001411AB650; +dof_pv* dof_pv_data = (dof_pv*)0x0000001411AB630; + +namespace renderer { + void DOF3::apply(RenderTexture* rt) { + if (dof_debug_data->flags & DOF_DEBUG_USE_UI_PARAMS) { + if (dof_debug_data->flags & DOF_DEBUG_ENABLE_DOF) { + if (dof_debug_data->flags & DOF_DEBUG_ENABLE_PHYS_DOF) { + float_t focus = dof_debug_data->focus; + if (dof_debug_data->flags & DOF_DEBUG_AUTO_FOCUS) { + size_t rob_chara_smth = get_rob_chara_smth(); + + size_t rob_chr = 0; + for (int32_t i = 0; i < ROB_CHARA_COUNT; i++) { + size_t rob_chr = rob_chara_array_get(rob_chara_smth, i); + if (!rob_chr || !(*(uint8_t*)(rob_chara_smth + 0x440) & 1)) + continue; + + mat4 mat; + sub_1405163C0(rob_chr, 4, &mat); + mat4_transpose(&mat, &mat); + + vec3 chara_trans = 0.0f; + mat4_get_translation(&mat, &chara_trans); + + mat4 view_transpose; + mat4_transpose(&camera_data->view_matrix, &view_transpose); + focus = -vec3::dot(*(vec3*)&view_transpose.row2, chara_trans) + - view_transpose.row2.w - 0.1f; + break; + } + } + + focus = max_def(focus, camera_data->min_distance); + apply_physical(rt, rt->GetColorTex(), rt->GetDepthTex(), + camera_data->min_distance, camera_data->max_distance, + focus, dof_debug_data->focal_length, + camera_data->fov * DEG_TO_RAD_FLOAT, + dof_debug_data->f_number); + } + else { + float_t fuzzing_range = max_def(dof_debug_data->f2.fuzzing_range, 0.01f); + apply_f2(rt, + rt->GetColorTex(), + rt->GetDepthTex(), + camera_data->min_distance, camera_data->max_distance, + camera_data->fov * DEG_TO_RAD_FLOAT, + dof_debug_data->f2.focus, dof_debug_data->f2.focus_range, + fuzzing_range, dof_debug_data->f2.ratio); + } + } + } + else if (dof_pv_data->enable && dof_pv_data->f2.ratio > 0.0f) { + float_t fuzzing_range = max_def(dof_pv_data->f2.fuzzing_range, 0.01f); + if (dof_pv_data->f2.fuzzing_range >= 0.0099999998) + apply_f2(rt, rt->GetColorTex(), rt->GetDepthTex(), + camera_data->min_distance, camera_data->max_distance, + camera_data->fov * DEG_TO_RAD_FLOAT, + dof_pv_data->f2.focus, dof_pv_data->f2.focus_range, + fuzzing_range, dof_pv_data->f2.ratio); + enum_or(dof_debug_data->flags, DOF_DEBUG_ENABLE_DOF); + dof_debug_data->f2 = dof_pv_data->f2; + } + else + enum_and(dof_debug_data->flags, ~DOF_DEBUG_ENABLE_DOF); + } + + void DOF3::resize(int32_t width, int32_t height) { + if (textures[0]) { + glDeleteTextures(6, textures); + textures[0] = 0; + } + + void(FASTCALL * renderer__FBO__init)(void* fbo, int32_t width, int32_t height, + GLuint * color_textures, int32_t count, GLuint depth_texture) + = (void(FASTCALL*)(void* fbo, int32_t width, int32_t height, + GLuint * color_textures, int32_t count, GLuint depth_texture))0x00000001404AEF40; + + this->width = width; + this->height = height; + int32_t w20 = max_def(width / 20, 1); + int32_t h20 = max_def(height / 20, 1); + int32_t w2 = max_def(width / 2, 1); + int32_t h2 = max_def(height / 2, 1); + glGenTextures(6, textures); + gl_state_bind_texture_2d(textures[0]); + glTexStorage2D(GL_TEXTURE_2D, 1, GL_RG16F, w20, h20); + renderer__FBO__init(&fbo[0], w20, h20, &textures[0], 1, 0); + gl_state_bind_texture_2d(textures[1]); + glTexStorage2D(GL_TEXTURE_2D, 1, GL_RG16F, w20, h20); + renderer__FBO__init(&fbo[1], w20, h20, &textures[1], 1, 0); + gl_state_bind_texture_2d(textures[2]); + glTexStorage2D(GL_TEXTURE_2D, 1, GL_R11F_G11F_B10F, w2, h2); + gl_state_bind_texture_2d(textures[3]); + glTexStorage2D(GL_TEXTURE_2D, 1, GL_R11F_G11F_B10F, w2, h2); + renderer__FBO__init(&fbo[2], w2, h2, &textures[2], 2, 0); + gl_state_bind_texture_2d(textures[4]); + glTexStorage2D(GL_TEXTURE_2D, 1, GL_R11F_G11F_B10F, w2, h2); + gl_state_bind_texture_2d(textures[5]); + glTexStorage2D(GL_TEXTURE_2D, 1, GL_R8, w2, h2); + renderer__FBO__init(&fbo[3], w2, h2, &textures[4], 2, 0); + } + + void DOF3::apply_f2(RenderTexture* rt, GLuint color_texture, + GLuint depth_texture, float_t min_distance, float_t max_distance, float_t fov, + float_t focus, float_t focus_range, float_t fuzzing_range, float_t ratio) { + gl_state_begin_event("renderer::DOF3::apply_f2"); + gl_state_disable_blend(); + gl_state_set_depth_mask(GL_FALSE); + gl_state_set_depth_func(GL_ALWAYS); + update_data(min_distance, max_distance, + fov, focus, 0.0f, 1.0f, focus_range, fuzzing_range, ratio); + + gl_state_bind_vertex_array(vao); + render_tiles(depth_texture, true); + downsample(color_texture, depth_texture, true); + main_filter(true); + upsample(rt, color_texture, depth_texture, true); + + gl_state_use_program(0); + for (int32_t i = 0; i < 8; i++) { + gl_state_bind_sampler(i, 0); + gl_state_active_bind_texture_2d(i, 0); + } + gl_state_bind_vertex_array(0); + gl_state_end_event(); + } + + void DOF3::apply_physical(RenderTexture* rt, GLuint color_texture, + GLuint depth_texture, float_t min_distance, float_t max_distance, + float_t focus, float_t focal_length, float_t fov, float_t f_number) { + gl_state_begin_event("renderer::DOF3::apply_physical"); + gl_state_disable_blend(); + gl_state_set_depth_mask(GL_FALSE); + gl_state_set_depth_func(GL_ALWAYS); + update_data(min_distance, max_distance, + fov, focus, focal_length, f_number, 0.0f, 0.1f, 0.0f); + + gl_state_bind_vertex_array(vao); + render_tiles(depth_texture, false); + downsample(color_texture, depth_texture, false); + main_filter(false); + upsample(rt, color_texture, depth_texture, false); + + gl_state_use_program(0); + for (int32_t i = 0; i < 8; i++) { + gl_state_bind_sampler(i, 0); + gl_state_active_bind_texture_2d(i, 0); + } + gl_state_bind_vertex_array(0); + gl_state_end_event(); + } + + void DOF3::render_tiles(GLuint depth_texture, bool f2) { + gl_state_begin_event("renderer::DOF3::render_tiles"); + gl_state_bind_framebuffer(fbo[0].buffer); + glViewportDLL(0, 0, fbo[0].width, fbo[0].height); + gl_state_use_program(program[f2 ? 5 : 1]); + common_ubo.Bind(0); + gl_state_active_bind_texture_2d(0, depth_texture); + gl_state_bind_sampler(0, samplers[1]); + glDrawArraysDLL(GL_TRIANGLE_STRIP, 0, 4); + + gl_state_bind_framebuffer(fbo[1].buffer); + glViewportDLL(0, 0, fbo[1].width, fbo[1].height); + gl_state_use_program(program[0]); + gl_state_active_bind_texture_2d(0, textures[0]); + gl_state_bind_sampler(0, samplers[1]); + glDrawArraysDLL(GL_TRIANGLE_STRIP, 0, 4); + gl_state_end_event(); + + } + + void DOF3::downsample(GLuint color_texture, GLuint depth_texture, bool f2) { + gl_state_begin_event("renderer::DOF3::downsample"); + gl_state_bind_framebuffer(fbo[2].buffer); + glViewportDLL(0, 0, fbo[2].width, fbo[2].height); + gl_state_use_program(program[f2 ? 6 : 2]); + common_ubo.Bind(0); + gl_state_active_bind_texture_2d(0, depth_texture); + gl_state_bind_sampler(0, samplers[1]); + gl_state_active_bind_texture_2d(1, color_texture); + gl_state_bind_sampler(1, samplers[0]); + gl_state_active_bind_texture_2d(2, textures[1]); + gl_state_bind_sampler(2, samplers[1]); + glDrawArraysDLL(GL_TRIANGLE_STRIP, 0, 4); + gl_state_end_event(); + } + + void DOF3::main_filter(bool f2) { + gl_state_begin_event("renderer::DOF3::main_filter"); + gl_state_bind_framebuffer(fbo[3].buffer); + glViewportDLL(0, 0, fbo[3].width, fbo[3].height); + gl_state_use_program(program[f2 ? 7 : 3]); + common_ubo.Bind(0); + texcoords_ubo.Bind(1); + gl_state_active_bind_texture_2d(0, textures[3]); + gl_state_bind_sampler(0, samplers[1]); + gl_state_active_bind_texture_2d(1, textures[2]); + gl_state_bind_sampler(1, samplers[1]); + gl_state_active_bind_texture_2d(2, textures[1]); + gl_state_bind_sampler(2, samplers[1]); + glDrawArraysDLL(GL_TRIANGLE_STRIP, 0, 4); + gl_state_end_event(); + } + + void DOF3::upsample(RenderTexture* rt, GLuint color_texture, GLuint depth_texture, bool f2) { + gl_state_begin_event("renderer::DOF3::upsample"); + rctx->render_buffer.Bind(); + glViewportDLL(0, 0, width, height); + gl_state_use_program(program[f2 ? 8 : 4]); + common_ubo.Bind(0); + gl_state_active_bind_texture_2d(0, textures[4]); + gl_state_bind_sampler(0, samplers[1]); + gl_state_active_bind_texture_2d(1, textures[5]); + gl_state_bind_sampler(1, samplers[1]); + gl_state_active_bind_texture_2d(2, textures[1]); + gl_state_bind_sampler(2, samplers[1]); + gl_state_active_bind_texture_2d(3, color_texture); + gl_state_bind_sampler(3, samplers[1]); + gl_state_active_bind_texture_2d(4, depth_texture); + gl_state_bind_sampler(4, samplers[1]); + glDrawArraysDLL(GL_TRIANGLE_STRIP, 0, 4); + + glCopyImageSubData( + rctx->render_buffer.GetColorTex(), GL_TEXTURE_2D, 0, 0, 0, 0, + rt->GetColorTex(), GL_TEXTURE_2D, 0, 0, 0, 0, width, height, 1); + gl_state_end_event(); + } + + void DOF3::update_data(float_t min_dist, float_t max_dist, float_t fov, float_t dist, float_t focal_length, + float_t f_number, float_t focus_range, float_t fuzzing_range, float_t ratio) { + float_t fl = focal_length; + if (dist <= focal_length) + fl = dist + 0.1f; + fl = fl / (dist - fl) * fl / f_number; + + dof_common_shader_data shader_data = {}; + shader_data.g_depth_params.x = 1.0f / (min_dist * max_dist) * (min_dist - max_dist); + shader_data.g_depth_params.y = 1.0f / min_dist; + shader_data.g_depth_params.z = -((fl * dist * (min_dist - max_dist)) * (1.0f / (min_dist * max_dist))); + shader_data.g_depth_params.w = (1.0f - 1.0f / min_dist * dist) * fl; + shader_data.g_spread_scale.x = 720.0f / (tanf(fov * 0.5f) * (min_dist * 2.0f)); + shader_data.g_spread_scale.y = shader_data.g_spread_scale.x * (float_t)(1.0 / 3.0); + shader_data.g_spread_scale.z = (float_t)(1.0 / 3.0); + shader_data.g_spread_scale.w = 3.0f; + shader_data.g_depth_params2.x = dist; + shader_data.g_depth_params2.y = focus_range; + shader_data.g_depth_params2.z = -4.5f / (fuzzing_range * fuzzing_range); + shader_data.g_depth_params2.w = ratio * 8.0f; + common_ubo.WriteMemory(shader_data); + } + +} diff --git a/src/DivaGL/renderer/dof.hpp b/src/DivaGL/renderer/dof.hpp new file mode 100644 index 0000000..f97234a --- /dev/null +++ b/src/DivaGL/renderer/dof.hpp @@ -0,0 +1,82 @@ +/* + by korenkonder + GitHub/GitLab: korenkonder +*/ + +#pragma once + +#include "../../KKdLib/default.hpp" +#include "../gl_uniform_buffer.hpp" +#include "../render_texture.hpp" +#include "fbo.hpp" + +enum dof_debug_flags { + DOF_DEBUG_USE_UI_PARAMS = 0x01, + DOF_DEBUG_ENABLE_DOF = 0x02, + DOF_DEBUG_ENABLE_PHYS_DOF = 0x04, + DOF_DEBUG_AUTO_FOCUS = 0x08, +}; + +struct dof_f2 { + float_t focus; + float_t focus_range; + float_t fuzzing_range; + float_t ratio; +}; + +static_assert(sizeof(dof_f2) == 0x10, "\"dof_f2\" struct should have a size of 0x10"); + +struct dof_debug { + dof_debug_flags flags; + float_t focus; + float_t focal_length; + float_t f_number; + dof_f2 f2; +}; + +static_assert(sizeof(dof_debug) == 0x20, "\"dof_debug\" struct should have a size of 0x14"); + +struct dof_pv { + bool enable; + dof_f2 f2; +}; + +static_assert(sizeof(dof_pv) == 0x14, "\"dof_pv\" struct should have a size of 0x14"); + +namespace renderer { + struct DOF3 { + int32_t width; + int32_t height; + GLuint textures[6]; + FBO fbo[4]; + GLuint samplers[2]; + GLuint vao; + GLuint program[9]; + GLUniformBuffer common_ubo; + GLUniformBuffer texcoords_ubo; + + void apply(RenderTexture* rt); + void resize(int32_t width, int32_t height); + + private: + void apply_f2(RenderTexture* rt, GLuint color_texture, + GLuint depth_texture, float_t min_distance, float_t max_distance, float_t fov, + float_t focus, float_t focus_range, float_t fuzzing_range, float_t ratio); + void apply_physical(RenderTexture* rt, GLuint color_texture, + GLuint depth_texture, float_t min_distance, float_t max_distance, + float_t focus, float_t focal_length, float_t fov, float_t f_number); + + void render_tiles(GLuint depth_texture, bool f2); + void downsample(GLuint color_texture, GLuint depth_texture, bool f2); + void main_filter(bool f2); + void upsample(RenderTexture* rt, GLuint color_texture, GLuint depth_texture, bool f2); + + void update_data(float_t min_dist, float_t max_dist, float_t fov, float_t dist, float_t focal_length, + float_t f_number, float_t focus_range, float_t fuzzing_range, float_t ratio); + }; + + static_assert(sizeof(renderer::DOF3) == 0xD8, "\"renderer::DOF3\" struct should have a size of 0xD8"); +} + +extern dof_debug* dof_debug_data; +extern dof_pv* dof_pv_data; diff --git a/src/DivaGL/renderer/fbo.cpp b/src/DivaGL/renderer/fbo.cpp new file mode 100644 index 0000000..b216c9e --- /dev/null +++ b/src/DivaGL/renderer/fbo.cpp @@ -0,0 +1,62 @@ +/* + by korenkonder + GitHub/GitLab: korenkonder +*/ + +#include "fbo.hpp" +#include "../gl_state.hpp" + +namespace renderer { +#pragma warning(push) +#pragma warning(disable: 6385) +#pragma warning(disable: 6386) + void FBO::init(int32_t width, int32_t height, + GLuint* color_textures, int32_t count, GLuint depth_texture) { + free(); + + count = min_def(count, 8); + + this->width = width; + this->height = height; + this->count = count; + flags = (Flags)0; + if (depth_texture) { + this->flags = DEPTH_ATTACHMENT; + this->count++; + } + + textures = new GLuint[this->count]; + for (int32_t i = 0; i < count; i++) + textures[i] = color_textures[i]; + + if (flags & DEPTH_ATTACHMENT) + textures[count] = depth_texture; + + glGenFramebuffers(1, &buffer); + glBindFramebuffer(GL_FRAMEBUFFER, buffer); + for (int32_t i = 0; i < count; i++) + glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + i, textures[i], 0); + + if (flags & DEPTH_ATTACHMENT) + glFramebufferTexture(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, textures[count], 0); + + GLenum color_attachments[8]; + for (int32_t i = 0; i < count; i++) + color_attachments[i] = GL_COLOR_ATTACHMENT0 + i; + glDrawBuffers(count, color_attachments); + glCheckFramebufferStatus(GL_FRAMEBUFFER); + } +#pragma warning(pop) + + void FBO::free() { + if (buffer) { + glDeleteFramebuffers(1, &buffer); + buffer = 0; + } + + if (textures) { + delete[] textures; + textures = 0; + } + } +} diff --git a/src/DivaGL/renderer/fbo.hpp b/src/DivaGL/renderer/fbo.hpp new file mode 100644 index 0000000..2397c50 --- /dev/null +++ b/src/DivaGL/renderer/fbo.hpp @@ -0,0 +1,29 @@ +/* + by korenkonder + GitHub/GitLab: korenkonder +*/ + +#pragma once + +#include "../shared.hpp" + +namespace renderer { + struct FBO { + enum Flags { + DEPTH_ATTACHMENT = 0x01, + }; + + Flags flags; + int32_t width; + int32_t height; + GLuint buffer; + int32_t count; + GLuint* textures; + + void init(int32_t width, int32_t height, + GLuint* color_textures, int32_t count, GLuint depth_texture); + void free(); + }; + + static_assert(sizeof(renderer::FBO) == 0x20, "\"renderer::FBO\" struct should have a size of 0x20"); +} diff --git a/src/DivaGL/renderer/transparency.cpp b/src/DivaGL/renderer/transparency.cpp new file mode 100644 index 0000000..1da90fe --- /dev/null +++ b/src/DivaGL/renderer/transparency.cpp @@ -0,0 +1,46 @@ +/* + by korenkonder + GitHub/GitLab: korenkonder +*/ + +#include "transparency.hpp" +#include "../../KKdLib/str_utils.hpp" +#include "../render_context.hpp" +#include "../gl_state.hpp" + +extern render_context* rctx; + +namespace renderer { + void Transparency::combine(RenderTexture* rt, float_t alpha) { + vec4 g_opacity = { alpha, 0.0f, 0.0f, 0.0f }; + + gl_state_disable_blend(); + gl_state_disable_depth_test(); + rctx->render_buffer.Bind(); + gl_state_use_program(program); + glUniform4fv(0, 1, (GLfloat*)&g_opacity.x); + gl_state_active_bind_texture_2d(0, fbo.textures[0]); + gl_state_active_bind_texture_2d(1, rt->GetColorTex()); + gl_state_bind_vertex_array(vao); + glDrawArraysDLL(GL_TRIANGLE_STRIP, 0, 4); + gl_state_enable_depth_test(); + + glCopyImageSubData( + rctx->render_buffer.GetColorTex(), GL_TEXTURE_2D, 0, 0, 0, 0, + rt->GetColorTex(), GL_TEXTURE_2D, 0, 0, 0, 0, fbo.width, fbo.height, 1); + } + + void Transparency::copy(GLuint texture) { + glCopyImageSubData( + texture, GL_TEXTURE_2D, 0, 0, 0, 0, + fbo.textures[0], GL_TEXTURE_2D, 0, 0, 0, 0, fbo.width, fbo.height, 1); + gl_state_bind_framebuffer(fbo.buffer); + glViewportDLL(0, 0, fbo.width, fbo.height); + } + + void Transparency::resize(GLuint color_texture, GLuint depth_texture, int32_t width, int32_t height) { + GLuint color_textures[1]; + color_textures[0] = color_texture; + fbo.init(width, height, color_textures, 1, depth_texture); + } +} diff --git a/src/DivaGL/renderer/transparency.hpp b/src/DivaGL/renderer/transparency.hpp new file mode 100644 index 0000000..8ca73cd --- /dev/null +++ b/src/DivaGL/renderer/transparency.hpp @@ -0,0 +1,29 @@ +/* + by korenkonder + GitHub/GitLab: korenkonder +*/ + +#pragma once + +#include "../../KKdLib/default.hpp" +#include "../../KKdLib/vec.hpp" +#include "../render_texture.hpp" +#include "fbo.hpp" + +namespace renderer { + struct Transparency { + private: + FBO fbo; + GLuint program; + GLuint sampler; + GLuint vao; + + public: + void combine(RenderTexture* rt, float_t alpha); + void copy(GLuint texture); + + void resize(GLuint color_texture, GLuint depth_texture, int32_t width, int32_t height); + }; + + static_assert(sizeof(renderer::Transparency) == 0x30, "\"renderer::Transparency\" struct should have a size of 0x30"); +}; diff --git a/src/DivaGL/resolution_mode.cpp b/src/DivaGL/resolution_mode.cpp new file mode 100644 index 0000000..224a7c1 --- /dev/null +++ b/src/DivaGL/resolution_mode.cpp @@ -0,0 +1,177 @@ +/* + by korenkonder + GitHub/GitLab: korenkonder +*/ + +#include "resolution_mode.hpp" + +const resolution_table_struct resolution_table[] = { + { 320, 240, 0, 0, 0, 320, 225 }, // QVGA + { 640, 480, 0, 0, 60, 640, 360 }, // VGA + { 800, 600, 0, 0, 75, 800, 450 }, // SVGA + { 1024, 768, 0, 0, 96, 1024, 576 }, // XGA + { 1280, 1024, 1, 0, 152, 1280, 720 }, // SXGA + { 1400, 1050, 0, 0, 131, 1400, 788 }, // SXGA+ + { 1600, 1200, 0, 0, 150, 1600, 900 }, // UXGA + { 800, 480, 2, 0, 15, 800, 450 }, // WVGA + { 1024, 600, 2, 0, 12, 1024, 576 }, // WSVGA + { 1280, 768, 2, 0, 24, 1280, 720 }, // WXGA + { 1360, 768, 3, 0, 2, 1360, 765 }, // FWXGA + { 1920, 1200, 2, 0, 60, 1920, 1200 }, // WUXGA + { 2560, 1536, 2, 0, 48, 2560, 1440 }, // WQXGA + { 1280, 720, 3, 0, 0, 1280, 720 }, // HD + { 1920, 1080, 3, 0, 0, 1920, 1080 }, // FHD + { 2560, 1440, 3, 0, 0, 2560, 1440 }, // QHD + { 480, 272, 3, 0, 0, 480, 272 }, // WQVGA + { 960, 544, 3, 0, 0, 960, 544 }, // qHD + + // MM+ + /*{ 320, 240, 0, 0, 0, 320, 225 }, // QVGA + { 640, 480, 0, 0, 60, 640, 360 }, // VGA + { 800, 600, 0, 0, 75, 800, 450 }, // SVGA + { 1024, 768, 0, 0, 96, 1024, 576 }, // XGA + { 1280, 1024, 1, 0, 152, 1280, 720 }, // SXGA + { 1400, 1050, 0, 0, 131, 1400, 788 }, // SXGA+ + { 1600, 1200, 0, 0, 150, 1600, 900 }, // UXGA + { 800, 480, 2, 0, 15, 800, 450 }, // WVGA + { 1024, 600, 2, 0, 12, 1024, 576 }, // WSVGA + { 1280, 768, 2, 0, 24, 1280, 720 }, // WXGA + { 1360, 768, 3, 0, 2, 1360, 765 }, // FWXGA + { 1920, 1200, 2, 0, 60, 1920, 1200 }, // WUXGA + { 2560, 1536, 2, 0, 48, 2560, 1440 }, // WQXGA + { 1280, 720, 3, 0, 0, 1280, 720 }, // HD + { 1920, 1080, 3, 0, 0, 1920, 1080 }, // FHD + { 3840, 2160, 3, 0, 0, 3840, 2160 }, // UHD + { 3840, 2160, 3, 0, 0, 2880, 1620 }, // 3K at UHD + { 2880, 1620, 3, 0, 0, 2880, 1620 }, // 3K + { 2560, 1440, 3, 0, 0, 2560, 1440 }, // QHD + { 480, 272, 3, 0, 0, 480, 272 }, // WQVGA + { 960, 544, 3, 0, 0, 960, 544 }, // qHD + { 1152, 864, 0, 0, 0, 1152, 864 }, // XGA+ + { 1176, 664, 3, 0, 0, 1176, 664 }, // 1176x664 + { 1200, 960, 1, 0, 0, 1200, 960 }, // 1200x960 + { 1280, 800, 2, 0, 0, 1280, 800 }, // WXGA1280x900 + { 1280, 960, 0, 0, 0, 1280, 960 }, // SXGA- + { 1366, 768, 3, 0, 0, 1366, 768 }, // FWXGA1366x766 + { 1440, 900, 2, 0, 0, 1440, 900 }, // WXGA+ + { 1600, 900, 0, 0, 0, 1600, 900 }, // HD+ + { 1600, 1024, 2, 0, 0, 1600, 1024 }, // WSXGA + { 1680, 1050, 2, 0, 0, 1680, 1050 }, // WSXGA+ + { 1920, 1440, 0, 0, 0, 1920, 1440 }, // 1920x1440 + { 2048, 1152, 0, 0, 0, 2048, 1152 }, // QWXGA*/ +}; + +resolution_struct* res_window = (resolution_struct*)0x0000000140EDA8B0; +resolution_struct* res_window_internal = (resolution_struct*)0x0000000140EDA8D8; + +resolution_struct::resolution_struct(::resolution_mode mode) { + resolution_mode = mode; + x_offset = 0; + y_offset = 0; + if (mode == RESOLUTION_MODE_MAX) { + width = res_window->width; + height = res_window->height; + aspect = res_window->aspect; + field_20 = res_window->field_20; + } + else { + width = resolution_table[mode].width_full; + height = resolution_table[mode].height_full; + aspect = (double_t)width / (double_t)height; + field_20 = resolution_table[mode].field_8; + } +} + +resolution_mode_scale_data::resolution_mode_scale_data( + resolution_mode src_mode, resolution_mode dst_mode) { + scale = 1.0f; + src_res = 0.0f; + dst_res = 0.0f; + this->src_mode = src_mode; + this->dst_mode = dst_mode; + scale = resolution_mode_get_scale(dst_mode, src_mode); + if (dst_mode != RESOLUTION_MODE_MAX && src_mode != RESOLUTION_MODE_MAX + && dst_mode >= RESOLUTION_MODE_QVGA && src_mode >= RESOLUTION_MODE_MAX + && dst_mode < RESOLUTION_MODE_MAX && src_mode < RESOLUTION_MODE_MAX) { + src_res.x = (float_t)resolution_table[src_mode].width_full * 0.5f; + src_res.y = (float_t)resolution_table[src_mode].height_full * 0.5f; + dst_res.x = (float_t)resolution_table[dst_mode].width_full * 0.5f; + dst_res.y = (float_t)resolution_table[dst_mode].height_full * 0.5f; + } +} + +resolution_struct* res_window_get() { + return res_window; +} + +resolution_struct* res_window_internal_get() { + return res_window_internal; +} + +void res_window_set(resolution_mode mode) { + *res_window = resolution_struct(mode); + + int32_t width = resolution_table[mode].width; + int32_t height = resolution_table[mode].height; + + res_window_internal->resolution_mode = RESOLUTION_MODE_MAX; + res_window_internal->x_offset = resolution_table[mode].x_offset; + res_window_internal->y_offset = resolution_table[mode].y_offset; + res_window_internal->width = width; + res_window_internal->height = height; + res_window_internal->aspect = (double_t)width / (double_t)height; + res_window_internal->field_20 = 4; + + for (int32_t i = 0; i < RESOLUTION_MODE_MAX; i++) + if (resolution_table[i].width_full == width && resolution_table[i].height_full == height) { + res_window_internal->resolution_mode = (resolution_mode)i; + res_window_internal->field_20 = resolution_table[i].field_8; + } +} + +vec2 resolution_mode_get_scale(const resolution_mode dst_mode, const resolution_mode src_mode) { + if (dst_mode == RESOLUTION_MODE_MAX || src_mode == RESOLUTION_MODE_MAX + || dst_mode < RESOLUTION_MODE_QVGA || src_mode < RESOLUTION_MODE_QVGA + || dst_mode >= RESOLUTION_MODE_MAX || src_mode >= RESOLUTION_MODE_MAX) + return 1.0f; + + float_t scale_x = (float_t)resolution_table[dst_mode].width_full / (float_t)resolution_table[src_mode].width_full; + float_t scale_y = (float_t)resolution_table[dst_mode].height_full / (float_t)resolution_table[src_mode].height_full; + int32_t v9 = resolution_table[src_mode].field_8; + int32_t v10 = resolution_table[dst_mode].field_8; + if (v9 != v10) { + if (!v9 && 10 == 1) + return scale_x; + + if (v9 == 2 || v9 == 3) + switch (v10) { + case 0: + case 1: + case 2: + return scale_x; + } + } + + if (src_mode == RESOLUTION_MODE_qHD && dst_mode != RESOLUTION_MODE_qHD && v10 == 3) + return scale_x; + else + return scale_y; +} + +void resolution_mode_scale_pos(vec2& dst_pos, const resolution_mode dst_mode, + const vec2& src_pos, const resolution_mode src_mode) { + if (dst_mode == RESOLUTION_MODE_MAX || src_mode == RESOLUTION_MODE_MAX + || dst_mode < RESOLUTION_MODE_QVGA || src_mode < RESOLUTION_MODE_QVGA + || dst_mode >= RESOLUTION_MODE_MAX || src_mode >= RESOLUTION_MODE_MAX) { + dst_pos = src_pos; + return; + } + + const resolution_table_struct* src = &resolution_table[src_mode]; + const resolution_table_struct* dst = &resolution_table[dst_mode]; + + vec2 src_size((float_t)src->width_full, (float_t)src->height_full); + vec2 dst_size((float_t)dst->width_full, (float_t)dst->height_full); + vec2 scale = resolution_mode_get_scale(dst_mode, src_mode); + dst_pos = dst_size * 0.5f + (src_pos - src_size * 0.5f) * scale; +} \ No newline at end of file diff --git a/src/DivaGL/resolution_mode.hpp b/src/DivaGL/resolution_mode.hpp new file mode 100644 index 0000000..850c5ea --- /dev/null +++ b/src/DivaGL/resolution_mode.hpp @@ -0,0 +1,55 @@ +/* + by korenkonder + GitHub/GitLab: korenkonder +*/ + +#pragma once + +#include "../KKdLib/default.hpp" +#include "../KKdLib/spr.hpp" +#include "../KKdLib/vec.hpp" + +struct resolution_table_struct { + int32_t width_full; + int32_t height_full; + int32_t field_8; + int32_t x_offset; + int32_t y_offset; + int32_t width; + int32_t height; +}; + +struct resolution_struct { + resolution_mode resolution_mode; + int32_t x_offset; + int32_t y_offset; + int32_t width; + int32_t height; + double_t aspect; + int32_t field_20; + + inline resolution_struct() : resolution_struct(RESOLUTION_MODE_MAX) { + + } + + resolution_struct(::resolution_mode mode); +}; + +struct resolution_mode_scale_data { + vec2 scale; + vec2 src_res; + vec2 dst_res; + resolution_mode src_mode; + resolution_mode dst_mode; + + resolution_mode_scale_data(resolution_mode src_mode, resolution_mode dst_mode); +}; + +extern const resolution_table_struct resolution_table[]; + +extern resolution_struct* res_window_get(); +extern resolution_struct* res_window_internal_get(); +extern void res_window_set(resolution_mode mode); +extern vec2 resolution_mode_get_scale(const resolution_mode dst_mode, const resolution_mode src_mode); +extern void resolution_mode_scale_pos(vec2& dst_pos, const resolution_mode dst_mode, + const vec2& src_pos, const resolution_mode src_mode); diff --git a/src/DivaGL/rob/rob.cpp b/src/DivaGL/rob/rob.cpp new file mode 100644 index 0000000..778f905 --- /dev/null +++ b/src/DivaGL/rob/rob.cpp @@ -0,0 +1,136 @@ +/* + by korenkonder + GitHub/GitLab: korenkonder +*/ + +#include "rob.hpp" +#include "../mdl/disp_manager.hpp" +#include "../gl_state.hpp" +#include "../object.hpp" +#include +#include + +struct rob_chara_age_age_object_vertex { + vec3 position; + vec3 normal; + vec4 tangent; + vec2 texcoord; +}; + +struct rob_chara_age_age_object { + void* obj_set_handler; // obj_set_handler + int32_t obj_index; + int32_t field_C; + int32_t num_vertex; + int32_t num_index; + obj obj; + obj_mesh mesh; + obj_sub_mesh sub_mesh; + obj_material_data material[2]; + obj_axis_aligned_bounding_box axis_aligned_bounding_box; + rob_chara_age_age_object_vertex* vertex_data; + int32_t vertex_data_size; + int32_t vertex_array_size; + obj_mesh_vertex_buffer obj_vert_buf; + obj_mesh_index_buffer obj_index_buf; + vec3 trans[10]; + int32_t disp_count; + int32_t count; + bool field_C3C; +}; + +mat4* (FASTCALL* rob_chara_bone_data_get_mats_mat)(size_t rob_bone_data, size_t index) + = (mat4 * (FASTCALL*)(size_t rob_bone_data, size_t index))0x0000000140419520; +void(FASTCALL* sub_1405163C0)(size_t rob_chr, int32_t index, mat4* mat) + = (void(FASTCALL*)(size_t rob_chr, int32_t index, mat4 * mat))0x00000001405163C0; +float_t(FASTCALL* rob_chara_get_max_face_depth)(size_t rob_chr) + = (float_t(FASTCALL*)(size_t rob_chr))0x0000000140516510; +mat4* (FASTCALL* sub_140516740)(size_t rob_chr) + = (mat4 * (FASTCALL*)(size_t rob_chr))0x0000000140516740; +mat4* (FASTCALL* rob_chara_get_adjust_data_mat)(size_t rob_chr) + = (mat4 * (FASTCALL*)(size_t rob_chr))0x0000000140516750; +bool(FASTCALL* rob_chara_array_check_visibility)(size_t rob_chr, int32_t chara_id) + = (bool(FASTCALL*)(size_t rob_chr, int32_t chara_id))0x0000000140531F50; +size_t(FASTCALL* get_rob_chara_smth)() = (size_t(FASTCALL*)())0x00000001405320E0; +size_t(FASTCALL* rob_chara_array_get)(size_t rob_chr_smth, int32_t chara_id) + = (size_t(FASTCALL*)(size_t rob_chr_smth, int32_t chara_id))0x0000000140532030; +size_t(FASTCALL* rob_chara_array_get_bone_data)(size_t rob_chr_smth, int32_t chara_id) + = (size_t(FASTCALL*)(size_t rob_chr_smth, int32_t chara_id))0x00000001405320F0; +bool (FASTCALL* rob_chara_pv_data_array_check_chara_id)(size_t rob_chr_smth, int32_t chara_id) + = (bool (FASTCALL*)(size_t rob_chr_smth, int32_t chara_id))0x00000001405327B0; + +HOOK(void, FASTCALL, rob_chara_age_age_object__disp, 0x0000000140541D50, + rob_chara_age_age_object* rob_age_age_obj, size_t chara_index, bool npr, bool reflect, vec3* a5, bool chara_color) { + int32_t disp_count = rob_age_age_obj->disp_count; + if (!rob_age_age_obj->obj_set_handler || !disp_count) + return; + + disp_count = min_def(disp_count, 10); + + std::pair v44[10]; + for (int32_t i = 0; i < disp_count; i++) { + v44[i].first = vec3::dot(rob_age_age_obj->trans[i], *a5); + v44[i].second = i; + } + + if (disp_count >= 2) + std::sort(v44, v44 + disp_count, + [](const std::pair& a, const std::pair& b) { + return a.first < b.first; + }); + + rob_age_age_obj->obj_vert_buf.cycle_index(); + + GLuint buffer = rob_age_age_obj->obj_vert_buf.get_buffer(); + size_t vtx_data; + if (GL_VERSION_4_5) { + vtx_data = (size_t)glMapNamedBuffer(buffer, GL_WRITE_ONLY); + if (!vtx_data) { + glUnmapNamedBuffer(buffer); + return; + } + } + else { + gl_state_bind_array_buffer(buffer); + vtx_data = (size_t)glMapBuffer(GL_ARRAY_BUFFER, GL_WRITE_ONLY); + if (!vtx_data) { + glUnmapBuffer(GL_ARRAY_BUFFER); + gl_state_bind_array_buffer(0); + return; + } + } + + size_t vertex_array_size = rob_age_age_obj->vertex_array_size; + for (int32_t i = 0; i < disp_count; i++) + memmove((void*)(vtx_data + vertex_array_size * i), + (void*)((size_t)rob_age_age_obj->vertex_data + vertex_array_size * v44[i].second), vertex_array_size); + + if (GL_VERSION_4_5) + glUnmapNamedBuffer(buffer); + else { + glUnmapBuffer(GL_ARRAY_BUFFER); + gl_state_bind_array_buffer(0); + } + + rob_age_age_obj->mesh.num_vertex = disp_count * rob_age_age_obj->num_vertex; + rob_age_age_obj->sub_mesh.num_index = disp_count * rob_age_age_obj->num_index; + rob_age_age_obj->sub_mesh.material_index = npr ? 1 : 0; + + mdl::ObjFlags flags = (mdl::ObjFlags)(mdl::OBJ_SSS | mdl::OBJ_4 | mdl::OBJ_SHADOW); + if (reflect) + enum_or(flags, mdl::OBJ_CHARA_REFLECT); + disp_manager->set_obj_flags(flags); + disp_manager->set_chara_color(chara_color); + disp_manager->set_shadow_type(chara_index ? SHADOW_STAGE : SHADOW_CHARA); + + static prj::vector*(FASTCALL * rob_chara_age_age_object__get_obj_set_texture)(rob_chara_age_age_object * rob_age_age_obj) + = (prj::vector*(FASTCALL*)(rob_chara_age_age_object* rob_age_age_obj))0x000000014045A8E0; + disp_manager->entry_obj_by_obj(&mat4_identity, &rob_age_age_obj->obj, + rob_chara_age_age_object__get_obj_set_texture(rob_age_age_obj), + &rob_age_age_obj->obj_vert_buf, &rob_age_age_obj->obj_index_buf, 0, 1.0f); +} + + +void rob_patch() { + INSTALL_HOOK(rob_chara_age_age_object__disp); +} diff --git a/src/DivaGL/rob/rob.hpp b/src/DivaGL/rob/rob.hpp new file mode 100644 index 0000000..c578837 --- /dev/null +++ b/src/DivaGL/rob/rob.hpp @@ -0,0 +1,25 @@ +/* + by korenkonder + GitHub/GitLab: korenkonder +*/ + +#pragma once + +#include "../../KKdLib/default.hpp" +#include "../../KKdLib/mat.hpp" +#include "../../KKdLib/vec.hpp" + +#define ROB_CHARA_COUNT 6 + +extern mat4* (FASTCALL* rob_chara_bone_data_get_mats_mat)(size_t rob_bone_data, size_t index); +extern void(FASTCALL* sub_1405163C0)(size_t rob_chr, int32_t index, mat4* mat); +extern float_t(FASTCALL* rob_chara_get_max_face_depth)(size_t rob_chr); +extern mat4* (FASTCALL* sub_140516740)(size_t rob_chr); +extern mat4* (FASTCALL* rob_chara_get_adjust_data_mat)(size_t rob_chr); +extern bool(FASTCALL* rob_chara_array_check_visibility)(size_t rob_chr, int32_t chara_id); +extern size_t(FASTCALL* get_rob_chara_smth)(); +extern size_t(FASTCALL* rob_chara_array_get)(size_t rob_chr_smth, int32_t chara_id); +extern size_t(FASTCALL* rob_chara_array_get_bone_data)(size_t rob_chr_smth, int32_t chara_id); +extern bool (FASTCALL* rob_chara_pv_data_array_check_chara_id)(size_t rob_chr_smth, int32_t chara_id); + +extern void rob_patch(); diff --git a/src/DivaGL/shader_glsl.cpp b/src/DivaGL/shader_glsl.cpp new file mode 100644 index 0000000..67f32a3 --- /dev/null +++ b/src/DivaGL/shader_glsl.cpp @@ -0,0 +1,993 @@ +/* + by korenkonder + GitHub/GitLab: korenkonder +*/ + +#include "shader_glsl.hpp" +#include "../KKdLib/io/file_stream.hpp" +#include "../KKdLib/io/path.hpp" +#include "../KKdLib/hash.hpp" +#include "../KKdLib/str_utils.hpp" +#include "gl_state.hpp" +#include "print.hpp" +#include "uniform.hpp" +#include "wrap.hpp" +#include + +struct program_binary { + GLsizei length; + GLenum binary_format; + size_t binary; +}; + +struct program_spv { + size_t size; + size_t spv; +}; + +extern bool vulkan_render; + +static GLuint shader_compile_shader(GLenum type, const char* data, const char* file); +static GLuint shader_compile(const char* vert, const char* frag, const char* vp, const char* fp); +static GLuint shader_compile_binary(const char* vert, const char* frag, const char* vp, const char* fp, + program_binary* bin, GLsizei* buffer_size, void** binary); +static bool shader_load_binary_shader(program_binary* bin, GLuint* program); +static void shader_glsl_update_data(shader_glsl_set_data* set); + +int32_t shader_glsl::bind(shader_glsl_set_data* set, uint32_t sub_index) { + set->curr_shader = 0; + + if (num_sub < 1) + return -1; + + int32_t sub_shader_index = 0; + for (shader_glsl_sub* i = sub; i->sub_index != sub_index; i++) + if (++sub_shader_index >= num_sub) + return -1; + + shader_glsl_sub* sub_shader = &sub[sub_shader_index]; + + int32_t unival_shad_curr = 1; + int32_t unival_shad = 0; + int32_t uniform_val[SHADER_MAX_UNIFORM_VALUES] = {}; + if (num_uniform > 0) { + const int32_t* vp_unival_max = sub_shader->vp_unival_max; + const int32_t* fp_unival_max = sub_shader->fp_unival_max; + + int32_t i = 0; + for (i = 0; i < num_uniform && i < sizeof(uniform_val) / sizeof(int32_t); i++) { + const int32_t unival = uniform->arr[use_uniform[i]]; + const int32_t unival_max = use_permut[i] + ? max_def(vp_unival_max[i], fp_unival_max[i]) : 0; + unival_shad += unival_shad_curr * min_def(unival, unival_max); + unival_shad_curr *= unival_max + 1; + + int32_t unival_max_glsl = max_def(vp_unival_max[i], fp_unival_max[i]); + uniform_val[i] = min_def(unival, unival_max_glsl); + } + } + + shader_glsl_sub_shader* shader = &sub_shader->shaders[unival_shad]; + set->curr_shader = shader; + + gl_state_use_program(shader->program); + if (memcmp(shader->uniform_val, uniform_val, sizeof(uniform_val))) { + memcpy(shader->uniform_val, uniform_val, sizeof(uniform_val)); + shader->uniform_val_update = true; + } + return 0; +} + +bool shader_glsl::parse_define(const char* data, char** temp, size_t* temp_size) { + if (!data) + return false; + + const char* def = strstr(data, "//DEF\n"); + if (!def) { + size_t len = utf8_length(data); + if (len + 1 > *temp_size) { + free_def(*temp); + *temp_size = len + 1; + *temp = force_malloc(*temp_size); + } + + memcpy(*temp, data, len); + (*temp)[len] = 0; + return true; + } + + size_t len_a = def - data; + def += 5; + if (*def == '\n') + def++; + + size_t len_b = utf8_length(def); + size_t len = 0; + len += len_a + len_b; + + if (len + 1 > *temp_size) { + free_def(*temp); + *temp_size = len + 1; + *temp = force_malloc(*temp_size); + } + + size_t pos = 0; + memcpy(*temp + pos, data, len_a); + pos += len_a; + memcpy(*temp + pos, def, len_b); + pos += len_b; + (*temp)[pos] = 0; + return true; +} + +bool shader_glsl::parse_define(const char* data, int32_t num_uniform, + int32_t* uniform_value, char** temp, size_t* temp_size) { + if (!data) + return false; + + const char* def = strstr(data, "//DEF\n"); + if (!def) { + size_t len = utf8_length(data); + if (len + 1 > *temp_size) { + free_def(*temp); + *temp_size = len + 1; + *temp = force_malloc(*temp_size); + } + + memcpy(*temp, data, len); + (*temp)[len] = 0; + return true; + } + + const int32_t s = min_def(0x100, num_uniform); + + size_t t_len[0x100]; + char t[0x100] = {}; + + for (int32_t i = 0; i < s; i++) { + sprintf_s(t, sizeof(t), "#define _%d %d\n", i, uniform_value[i]); + t_len[i] = utf8_length(t); + } + + size_t len_a = def - data; + def += 5; + size_t len_b = utf8_length(def); + size_t len = 0; + for (int32_t i = 0; i < s; i++) + len += t_len[i]; + if (!len) + def++; + len += len_a + len_b; + + if (len + 1 > *temp_size) { + free_def(*temp); + *temp_size = len + 1; + *temp = force_malloc(*temp_size); + } + + size_t pos = 0; + memcpy(*temp + pos, data, len_a); + pos += len_a; + for (int32_t i = 0; i < s; i++) { + sprintf_s(t, sizeof(t), "#define _%d %d\n", i, uniform_value[i]); + memcpy(*temp + pos, t, t_len[i]); + pos += t_len[i]; + } + memcpy(*temp + pos, def, len_b); + pos += len_b; + (*temp)[pos] = 0; + return true; +} + +char* shader_glsl::parse_include(char* data, farc* f) { + if (!data || !f) + return data; + + char* data_end = data + utf8_length(data); + char* i0 = strstr(data, "#include \""); + char* i1 = i0 ? strstr(i0, "\"\n") : 0; + if (!i0 || !i1) + return data; + + size_t count = 1; + while (i1 && (i0 = strstr(i1, "#include \""))) { + i0 += 10; + i1 = strstr(i0, "\"\n"); + if (i1) + i1 += 1; + count++; + } + + char** temp = force_malloc(count); + size_t* temp_len = force_malloc(count); + char** temp_ptr0 = force_malloc(count); + char** temp_ptr1 = force_malloc(count); + if (!temp || !temp_len || !temp_ptr0 || !temp_ptr1) { + free_def(temp); + free_def(temp_len); + free_def(temp_ptr0); + free_def(temp_ptr1); + return data; + } + + i1 = data; + for (size_t i = 0; i < count; i++) { + temp[i] = 0; + i0 = i1 ? strstr(i1, "#include \"") : 0; + i1 = i0 ? strstr(i0, "\"\n") : 0; + if (!i0 || !i1) + continue; + + temp_ptr0[i] = i0; + temp_ptr1[i] = i1 + 1; + i0 += 10; + size_t s = i1 - i0; + i1 += 2; + char* t = force_malloc(s + 1); + if (!t) + continue; + + memcpy(t, i0, s); + t[s] = 0; + + farc_file* ff = f->read_file(t); + free_def(t); + if (!ff) + continue; + + t = force_malloc(ff->size + 1); + if (t) { + memcpy(t, ff->data, ff->size); + t[ff->size] = 0; + } + temp[i] = t; + temp_len[i] = ff->size; + } + + size_t len = data_end - data; + i1 = data; + for (size_t i = 0; i < count; i++) { + i0 = temp_ptr0[i]; + i1 = temp_ptr1[i]; + if (!i0 || !i1) + continue; + + len -= i1 - i0; + len += temp_len[i]; + } + + char* temp_data = force_malloc(len + 1); + size_t pos = 0; + memcpy(temp_data + pos, data, temp_ptr0[0] - data); + pos += temp_ptr0[0] - data; + for (int32_t i = 0; i < count; i++) { + if (temp[i]) { + size_t s = temp_len[i]; + memcpy(temp_data + pos, temp[i], s); + pos += s; + } + + if (i < count - 1 && temp_ptr1[i]) { + size_t s = temp_ptr0[i + 1] - temp_ptr1[i]; + memcpy(temp_data + pos, temp_ptr1[i], s); + pos += s; + } + else if (temp_ptr1[i]) { + size_t s = data_end - temp_ptr1[i]; + memcpy(temp_data + pos, temp_ptr1[i], s); + pos += s; + } + } + temp_data[pos] = 0; + + free_def(data); + for (size_t i = 0; i < count; i++) + free_def(temp[i]); + free_def(temp); + free_def(temp_len); + free_def(temp_ptr0); + free_def(temp_ptr1); + return temp_data; +} + +void shader_glsl::unbind() { + gl_state_use_program(0); +} + +shader_glsl_set_data::shader_glsl_set_data() : size(), shaders(), curr_shader(), +primitive_restart(), primitive_restart_index(), get_index_by_name_func() { + +} + +void shader_glsl_set_data::disable_primitive_restart() { + primitive_restart = false; +} + +void shader_glsl_set_data::draw_arrays(GLenum mode, GLint first, GLsizei count) { + shader_glsl_update_data(this); + glDrawArraysDLL(mode, first, count); +} + +void shader_glsl_set_data::draw_elements(GLenum mode, + GLsizei count, GLenum type, const void* indices) { + switch (mode) { + case GL_TRIANGLE_STRIP: + uint32_t index; + switch (type) { + case GL_UNSIGNED_BYTE: + index = 0xFF; + break; + case GL_UNSIGNED_SHORT: + index = 0xFFFF; + break; + case GL_UNSIGNED_INT: + default: + index = 0xFFFFFFFF; + break; + } + + enable_primitive_restart(); + + if (primitive_restart_index != index) + primitive_restart_index = index; + break; + } + + shader_glsl_update_data(this); + glDrawElementsDLL(mode, count, type, indices); + + switch (mode) { + case GL_TRIANGLE_STRIP: + disable_primitive_restart(); + break; + } +} + +void shader_glsl_set_data::draw_range_elements(GLenum mode, + GLuint start, GLuint end, GLsizei count, GLenum type, const void* indices) { + switch (mode) { + case GL_TRIANGLE_STRIP: + uint32_t index; + switch (type) { + case GL_UNSIGNED_BYTE: + index = 0xFF; + break; + case GL_UNSIGNED_SHORT: + index = 0xFFFF; + break; + case GL_UNSIGNED_INT: + default: + index = 0xFFFFFFFF; + break; + } + + enable_primitive_restart(); + + if (primitive_restart_index != index) + primitive_restart_index = index; + break; + } + + shader_glsl_update_data(this); + glDrawRangeElements(mode, start, end, count, type, indices); + + switch (mode) { + case GL_TRIANGLE_STRIP: + disable_primitive_restart(); + break; + } +} + +void shader_glsl_set_data::enable_primitive_restart() { + primitive_restart = true; +} + +int32_t shader_glsl_set_data::get_index_by_name(const char* name) { + if (get_index_by_name_func) { + int32_t index = get_index_by_name_func(name); + if (index != -1) + return index; + } + + for (size_t i = 0; i < size; i++) + if (!str_utils_compare(shaders[i].name, name)) + return (int32_t)shaders[i].name_index; + return -1; +} + +void shader_glsl_set_data::load(farc* f, bool ignore_cache, + const char* name, const shader_glsl_table* shaders_table, const size_t size, + const shader_glsl_bind_func* bind_func_table, const size_t bind_func_table_size, + PFNSHADERGLSLGETINDEXFUNCPROC get_index_by_name) { + if (!this || !f || !shaders_table || !size) + return; + + wchar_t temp_buf[MAX_PATH]; + if (FAILED(SHGetFolderPathW(0, CSIDL_LOCAL_APPDATA, 0, 0, temp_buf))) + return; + + wcscat_s(temp_buf, sizeof(temp_buf) / sizeof(wchar_t), L"\\PDAFT"); + CreateDirectoryW(temp_buf, 0); + + wchar_t buf[MAX_PATH]; + swprintf_s(buf, sizeof(buf) / sizeof(wchar_t), L"\\%hs_shader_cache", name); + wcscat_s(temp_buf, sizeof(temp_buf) / sizeof(wchar_t), buf); + + bool shader_cache_changed = false; + farc shader_cache_farc; + swprintf_s(buf, sizeof(buf) / sizeof(wchar_t), L"%ls.farc", temp_buf); + if (!ignore_cache && path_check_file_exists(buf)) + shader_cache_farc.read(buf, true, false); + + char vert_buf[MAX_PATH]; + char frag_buf[MAX_PATH]; + char vert_file_buf[MAX_PATH]; + char frag_file_buf[MAX_PATH]; + + GLsizei buffer_size = 0x100000; + void* binary = force_malloc(buffer_size); + size_t temp_vert_size = 0x10000; + char* temp_vert = force_malloc(temp_vert_size); + size_t temp_frag_size = 0x10000; + char* temp_frag = force_malloc(temp_frag_size); + std::vector vec_vert; + std::vector vec_frag; + std::vector program_data_binary; + shader_glsl* shaders = force_malloc(size); + this->shaders = shaders; + this->size = size; + for (size_t i = 0; i < size; i++) { + shader_glsl* shader = &shaders[i]; + shader->name = shaders_table[i].name; + shader->name_index = shaders_table[i].name_index; + shader->num_sub = shaders_table[i].num_sub; + shader->sub = force_malloc(shader->num_sub); + shader->num_uniform = shaders_table[i].num_uniform; + shader->use_uniform = shaders_table[i].use_uniform; + shader->use_permut = shaders_table[i].use_permut; + + int32_t num_sub = shader->num_sub; + const shader_glsl_sub_table* sub_table = shaders_table[i].sub; + shader_glsl_sub* sub = shader->sub; + vec_vert.resize(shader->num_uniform); + vec_frag.resize(shader->num_uniform); + int32_t* vec_vert_data = vec_vert.data(); + int32_t* vec_frag_data = vec_frag.data(); + for (size_t j = 0; j < num_sub; j++, sub++, sub_table++) { + sub->sub_index = sub_table->sub_index; + sub->vp_unival_max = sub_table->vp_unival_max; + sub->fp_unival_max = sub_table->fp_unival_max; + + strcpy_s(vert_file_buf, sizeof(vert_file_buf), sub_table->vp); + strcat_s(vert_file_buf, sizeof(vert_file_buf), ".vert"); + farc_file* vert_ff = f->read_file(vert_file_buf); + + char* vert_data = 0; + if (vert_ff && vert_ff->data) { + vert_data = force_malloc(vert_ff->size + 1); + if (vert_data) { + memcpy(vert_data, vert_ff->data, vert_ff->size); + vert_data[vert_ff->size] = 0; + } + } + + strcpy_s(frag_file_buf, sizeof(frag_file_buf), sub_table->fp); + strcat_s(frag_file_buf, sizeof(frag_file_buf), ".frag"); + farc_file* frag_ff = f->read_file(frag_file_buf); + + char* frag_data = 0; + if (frag_ff && frag_ff->data) { + frag_data = force_malloc(frag_ff->size + 1); + if (frag_data) { + memcpy(frag_data, frag_ff->data, frag_ff->size); + frag_data[frag_ff->size] = 0; + } + } + + if (!vert_data || !frag_data) { + free_def(vert_data); + free_def(frag_data); + continue; + } + + uint64_t vert_file_name_cache = hash_utf8_fnv1a64m(vert_file_buf); + uint64_t frag_file_name_cache = hash_utf8_fnv1a64m(frag_file_buf); + for (int32_t i = 0; i < 64; i += 8) + if (((vert_file_name_cache >> i) & 0xFF) == 0) + vert_file_name_cache |= 0xFFULL << i; + + for (int32_t i = 0; i < 64; i += 8) + if (((frag_file_name_cache >> i) & 0xFF) == 0) + frag_file_name_cache |= 0xFFULL << i; + + char shader_cache_file_name[MAX_PATH]; + strcpy_s(shader_cache_file_name, sizeof(shader_cache_file_name), sub_table->vp); + if (str_utils_compare(sub_table->vp, sub_table->fp)) { + strcat_s(shader_cache_file_name, sizeof(shader_cache_file_name), "."); + strcat_s(shader_cache_file_name, sizeof(shader_cache_file_name), sub_table->fp); + } + strcat_s(shader_cache_file_name, sizeof(shader_cache_file_name), ".bin"); + + vert_data = shader_glsl::parse_include(vert_data, f); + frag_data = shader_glsl::parse_include(frag_data, f); + uint64_t vert_data_hash = hash_utf8_fnv1a64m(vert_data); + uint64_t frag_data_hash = hash_utf8_fnv1a64m(frag_data); + + farc_file* shader_cache_file = shader_cache_farc.read_file(shader_cache_file_name); + program_binary* bin = 0; + if (!ignore_cache) { + if (!shader_cache_file || !shader_cache_file->data) + printf_debug("Shader not compiled: %s %s\n", vert_file_buf, frag_file_buf); + else if (vert_data_hash != ((uint64_t*)shader_cache_file->data)[0] + || frag_data_hash != ((uint64_t*)shader_cache_file->data)[1]) + printf_debug("Shader hash not equal: %s %s\n", vert_file_buf, frag_file_buf); + else + bin = (program_binary*)&((uint64_t*)shader_cache_file->data)[2]; + } + + if (shader->num_uniform > 0 + && (sub_table->vp_unival_max[0] != -1 || sub_table->fp_unival_max[0] != -1)) { + int32_t num_uniform = shader->num_uniform; + int32_t unival_shad_curr = 1; + int32_t unival_shad_count = 1; + const int32_t* vp_unival_max = sub_table->vp_unival_max; + const int32_t* fp_unival_max = sub_table->fp_unival_max; + for (size_t k = 0; k < num_uniform; k++) { + const int32_t unival_max = shader->use_permut[k] + ? max_def(vp_unival_max[k], fp_unival_max[k]) : 0; + unival_shad_count += unival_shad_curr * unival_max; + unival_shad_curr *= unival_max + 1; + } + + if (!ignore_cache) + program_data_binary.reserve(unival_shad_count); + shader_glsl_sub_shader* shaders = force_malloc(unival_shad_count); + sub->shaders = shaders; + if (shaders) { + strcpy_s(vert_buf, sizeof(vert_buf), sub_table->vp); + size_t vert_buf_pos = utf8_length(vert_buf); + vert_buf[vert_buf_pos++] = '.'; + vert_buf[vert_buf_pos] = 0; + memset(&vert_buf[vert_buf_pos], '0', num_uniform); + vert_buf[vert_buf_pos + num_uniform] = 0; + strcat_s(vert_buf, sizeof(vert_buf), ".vert"); + + strcpy_s(frag_buf, sizeof(frag_buf), sub_table->fp); + size_t frag_buf_pos = utf8_length(frag_buf); + frag_buf[frag_buf_pos++] = '.'; + frag_buf[frag_buf_pos] = 0; + memset(&frag_buf[frag_buf_pos], '0', num_uniform); + frag_buf[frag_buf_pos + num_uniform] = 0; + strcat_s(frag_buf, sizeof(frag_buf), ".frag"); + + for (size_t k = 0; k < unival_shad_count; k++) { + for (size_t l = 0, m = k; l < num_uniform; l++) { + size_t unival_max = (size_t)(shader->use_permut[l] + ? max_def(vp_unival_max[l], fp_unival_max[l]) : 0) + 1; + vec_vert_data[l] = (uint32_t)(min_def(m % unival_max, vp_unival_max[l])); + m /= unival_max; + vert_buf[vert_buf_pos + l] = (char)('0' + vec_vert_data[l]); + } + + for (size_t l = 0, m = k; l < num_uniform; l++) { + size_t unival_max = (size_t)(shader->use_permut[l] + ? max_def(vp_unival_max[l], fp_unival_max[l]) : 0) + 1; + vec_frag_data[l] = (uint32_t)(min_def(m % unival_max, fp_unival_max[l])); + m /= unival_max; + frag_buf[frag_buf_pos + l] = (char)('0' + vec_frag_data[l]); + } + + if (!bin || !shader_load_binary_shader(bin, &shaders[k].program)) { + bool vert_succ = shader_glsl::parse_define(vert_data, num_uniform, + vec_vert_data, &temp_vert, &temp_vert_size); + bool frag_succ = shader_glsl::parse_define(frag_data, num_uniform, + vec_frag_data, &temp_frag, &temp_frag_size); + + if (ignore_cache) + shaders[k].program = shader_compile(vert_succ ? temp_vert : 0, + frag_succ ? temp_frag : 0, vert_buf, frag_buf); + else { + program_data_binary.push_back({}); + shaders[k].program = shader_compile_binary(vert_succ ? temp_vert : 0, + frag_succ ? temp_frag : 0, vert_buf, frag_buf, + &program_data_binary.back(), &buffer_size, &binary); + } + shader_cache_changed |= shaders[k].program ? true : false; + } + else { + program_data_binary.push_back({}); + program_binary* b = &program_data_binary.back(); + b->length = bin->length; + b->binary_format = bin->binary_format; + b->binary = (size_t)force_malloc(bin->length); + memcpy((void*)b->binary, (void*)((size_t)bin + bin->binary), bin->length); + } + + if (!ignore_cache && bin) + bin++; + } + } + } + else { + program_data_binary.reserve(1); + shader_glsl_sub_shader* shaders = force_malloc(); + sub->shaders = shaders; + if (shaders) { + strcpy_s(vert_buf, sizeof(vert_buf), sub_table->vp); + strcpy_s(frag_buf, sizeof(vert_buf), sub_table->fp); + strcat_s(vert_buf, sizeof(vert_buf), "..vert"); + strcat_s(frag_buf, sizeof(vert_buf), "..frag"); + + if (!bin || !shader_load_binary_shader(bin, &shaders[0].program)) { + bool vert_succ = shader_glsl::parse_define(vert_data, &temp_vert, &temp_vert_size); + bool frag_succ = shader_glsl::parse_define(frag_data, &temp_frag, &temp_frag_size); + + if (ignore_cache) + shaders[0].program = shader_compile(vert_succ ? temp_vert : 0, + frag_succ ? temp_frag : 0, vert_buf, frag_buf); + else { + program_data_binary.push_back({}); + shaders[0].program = shader_compile_binary(vert_succ ? temp_vert : 0, + frag_succ ? temp_frag : 0, vert_buf, frag_buf, + &program_data_binary.back(), &buffer_size, &binary); + } + shader_cache_changed |= shaders[0].program ? true : false; + } + else { + program_data_binary.push_back({}); + program_binary* b = &program_data_binary.back(); + b->length = bin->length; + b->binary_format = bin->binary_format; + b->binary = (size_t)force_malloc(bin->length); + memcpy((void*)b->binary, (void*)((size_t)bin + bin->binary), bin->length); + } + + if (!ignore_cache && bin) + bin++; + } + } + + if (!ignore_cache) { + if (!shader_cache_file) + shader_cache_file = shader_cache_farc.add_file(shader_cache_file_name); + else + free_def(shader_cache_file->data); + + size_t bin_count = program_data_binary.size(); + size_t bin_size = sizeof(uint64_t) * 2 + bin_count * sizeof(program_binary); + for (program_binary& k : program_data_binary) + bin_size += align_val(k.length, 0x04); + shader_cache_file->data = force_malloc(bin_size); + shader_cache_file->size = bin_size; + shader_cache_file->data_changed = true; + + ((uint64_t*)shader_cache_file->data)[0] = vert_data_hash; + ((uint64_t*)shader_cache_file->data)[1] = frag_data_hash; + bin = (program_binary*)&((uint64_t*)shader_cache_file->data)[2]; + size_t bin_data_base = (size_t)shader_cache_file->data + sizeof(uint64_t) * 2; + size_t bin_data = bin_data_base + bin_count * sizeof(program_binary); + for (program_binary& k : program_data_binary) { + bin->length = k.length; + bin->binary_format = k.binary_format; + bin->binary = bin_data - bin_data_base; + memcpy((void*)bin_data, (void*)k.binary, k.length); + bin_data_base += sizeof(program_binary); + bin_data += align_val(k.length, 0x04); + void* binary = (void*)k.binary; + free_def(binary); + k.binary = 0; + bin++; + } + } + + free_def(vert_data); + free_def(frag_data); + program_data_binary.clear(); + } + vec_vert.clear(); + vec_frag.clear(); + + for (size_t j = 0; j < bind_func_table_size; j++) + if (shader->name_index == bind_func_table[j].name_index) { + shader->bind_func = bind_func_table[j].bind_func; + break; + } + } + free_def(binary); + free_def(temp_vert); + free_def(temp_frag); + + if (shader_cache_changed) + shader_cache_farc.write(temp_buf, FARC_FArC, FARC_NONE, false); + + this->get_index_by_name_func = get_index_by_name; +} + +void shader_glsl_set_data::set(uint32_t index) { + if (this && index && index != -1) { + shader_glsl* shader = &shaders[index]; + if (shader->bind_func) + shader->bind_func(this, shader); + else + shader->bind(this, shader->sub[0].sub_index); + } + else + shader_glsl::unbind(); +} + +void shader_glsl_set_data::unload() { + size_t size = this->size; + shader_glsl* shaders = this->shaders; + for (size_t i = 0; i < size; i++) { + shader_glsl* shader = &shaders[i]; + if (!shader->sub) + continue; + + int32_t num_sub = shader->num_sub; + shader_glsl_sub* sub = shader->sub; + for (size_t j = 0; j < num_sub; j++, sub++) { + int32_t unival_shad_count = 1; + if (shader->num_uniform > 0) { + int32_t num_uniform = shader->num_uniform; + int32_t unival_shad_curr = 1; + const int32_t* vp_unival_max = sub->vp_unival_max; + const int32_t* fp_unival_max = sub->fp_unival_max; + for (size_t k = 0; k < num_uniform; k++) { + const int32_t unival_max = shader->use_permut[k] + ? max_def(vp_unival_max[k], fp_unival_max[k]) : 0; + unival_shad_count += unival_shad_curr * unival_max; + unival_shad_curr *= unival_max + 1; + } + } + + if (sub->shaders) { + shader_glsl_sub_shader* shaders = sub->shaders; + for (size_t k = 0; k < unival_shad_count; k++) + glDeleteProgram(shaders[k].program); + free(shaders); + sub->shaders = 0; + } + } + free(shader->sub); + shader->sub = 0; + } + free_def(shaders); + this->shaders = 0; + + get_index_by_name_func = 0; +} + +static GLuint shader_compile_shader(GLenum type, const char* data, const char* file) { + if (!data) + return 0; + + GLuint shader = glCreateShader(type); + glShaderSource(shader, 1, &data, 0); + glCompileShader(shader); + + GLint success = 0; + glGetShaderiv(shader, GL_COMPILE_STATUS, &success); + if (!success) { + GLchar* info_log = force_malloc(0x10000); + glGetShaderInfoLog(shader, 0x10000, 0, info_log); + const char* type_str = "Unknown"; + switch (type) { + case GL_FRAGMENT_SHADER: + type_str = "Fragment"; + break; + case GL_VERTEX_SHADER: + type_str = "Vertex"; + break; + } + printf_debug("%s shader compile error:\nfile: %s\n%s\n", type_str, file, info_log); + free_def(info_log); + glDeleteShader(shader); + +#if defined(CRE_DEV) + wchar_t temp_buf[MAX_PATH]; + if (SUCCEEDED(SHGetFolderPathW(0, CSIDL_LOCAL_APPDATA, 0, 0, temp_buf))) { + wcscat_s(temp_buf, sizeof(temp_buf) / sizeof(wchar_t), L"\\ReDIVA"); + temp_buf[sizeof(temp_buf) / sizeof(wchar_t) - 1] = 0; + CreateDirectoryW(temp_buf, 0); + + wchar_t buf[MAX_PATH]; + swprintf_s(buf, sizeof(buf) / sizeof(wchar_t), + L"%ls\\shader_error", temp_buf); + buf[sizeof(buf) / sizeof(wchar_t) - 1] = 0; + CreateDirectoryW(buf, 0); + + swprintf_s(buf, sizeof(buf) / sizeof(wchar_t), + L"%ls\\shader_error\\%hs", temp_buf, file); + buf[sizeof(buf) / sizeof(wchar_t) - 1] = 0; + + file_stream s; + s.open(buf, L"wb"); + s.write(data, utf8_length(data)); + } +#endif + return 0; + } + return shader; +} + +static GLuint shader_compile(const char* vert, const char* frag, const char* vp, const char* fp) { + GLuint vert_shad = shader_compile_shader(GL_VERTEX_SHADER, vert, vp); + GLuint frag_shad = shader_compile_shader(GL_FRAGMENT_SHADER, frag, fp); + + GLuint program = glCreateProgram(); + if (vert_shad) + glAttachShader(program, vert_shad); + if (frag_shad) + glAttachShader(program, frag_shad); + glLinkProgram(program); + + if (vert_shad) + glDeleteShader(vert_shad); + if (frag_shad) + glDeleteShader(frag_shad); + + GLint success = 0; + glGetProgramiv(program, GL_LINK_STATUS, &success); + if (!success) { + GLchar* info_log = force_malloc(0x10000); + glGetProgramInfoLog(program, 0x10000, 0, info_log); + printf_debug("Program Shader Permut linking error:\nvp: %s; fp: %s\n%s\n", vp, fp, info_log); + free_def(info_log); + glDeleteProgram(program); + +#if defined(CRE_DEV) + wchar_t temp_buf[MAX_PATH]; + if (SUCCEEDED(SHGetFolderPathW(0, CSIDL_LOCAL_APPDATA, 0, 0, temp_buf))) { + wcscat_s(temp_buf, sizeof(temp_buf) / sizeof(wchar_t), L"\\ReDIVA"); + temp_buf[sizeof(temp_buf) / sizeof(wchar_t) - 1] = 0; + CreateDirectoryW(temp_buf, 0); + + wchar_t buf[MAX_PATH]; + swprintf_s(buf, sizeof(buf) / sizeof(wchar_t), + L"%ls\\shader_error", temp_buf); + buf[sizeof(buf) / sizeof(wchar_t) - 1] = 0; + CreateDirectoryW(buf, 0); + + swprintf_s(buf, sizeof(buf) / sizeof(wchar_t), + L"%ls\\shader_error\\%hs", temp_buf, vp); + buf[sizeof(buf) / sizeof(wchar_t) - 1] = 0; + + file_stream s; + s.open(buf, L"wb"); + s.write(vert, utf8_length(vert)); + s.close(); + + swprintf_s(buf, sizeof(buf) / sizeof(wchar_t), + L"%ls\\shader_error\\%hs", temp_buf, fp); + buf[sizeof(buf) / sizeof(wchar_t) - 1] = 0; + + s.open(buf, L"wb"); + s.write(frag, utf8_length(frag)); + s.close(); + } +#endif + return 0; + } + else { + gl_state_get_all_gl_errors(); + return program; + } +} + +static GLuint shader_compile_binary(const char* vert, const char* frag, const char* vp, const char* fp, + program_binary* bin, GLsizei* buffer_size, void** binary) { + memset(bin, 0, sizeof(*bin)); + + GLuint vert_shad = shader_compile_shader(GL_VERTEX_SHADER, vert, vp); + GLuint frag_shad = shader_compile_shader(GL_FRAGMENT_SHADER, frag, fp); + + GLuint program = glCreateProgram(); + if (vert_shad) + glAttachShader(program, vert_shad); + if (frag_shad) + glAttachShader(program, frag_shad); + glLinkProgram(program); + + if (vert_shad) + glDeleteShader(vert_shad); + if (frag_shad) + glDeleteShader(frag_shad); + + GLint success = 0; + glGetProgramiv(program, GL_LINK_STATUS, &success); + if (!success) { + GLchar* info_log = force_malloc(0x10000); + glGetProgramInfoLog(program, 0x10000, 0, info_log); + printf_debug("Program Shader Permut linking error:\nvp: %s; fp: %s\n%s\n", vp, fp, info_log); + free_def(info_log); + glDeleteProgram(program); + +#if defined(CRE_DEV) + wchar_t temp_buf[MAX_PATH]; + if (SUCCEEDED(SHGetFolderPathW(0, CSIDL_LOCAL_APPDATA, 0, 0, temp_buf))) { + wcscat_s(temp_buf, sizeof(temp_buf) / sizeof(wchar_t), L"\\ReDIVA"); + temp_buf[sizeof(temp_buf) / sizeof(wchar_t) - 1] = 0; + CreateDirectoryW(temp_buf, 0); + + wchar_t buf[MAX_PATH]; + swprintf_s(buf, sizeof(buf) / sizeof(wchar_t), + L"%ls\\shader_error", temp_buf); + buf[sizeof(buf) / sizeof(wchar_t) - 1] = 0; + CreateDirectoryW(buf, 0); + + swprintf_s(buf, sizeof(buf) / sizeof(wchar_t), + L"%ls\\shader_error\\%hs", temp_buf, vp); + buf[sizeof(buf) / sizeof(wchar_t) - 1] = 0; + + file_stream s; + s.open(buf, L"wb"); + s.write(vert, utf8_length(vert)); + s.close(); + + swprintf_s(buf, sizeof(buf) / sizeof(wchar_t), + L"%ls\\shader_error\\%hs", temp_buf, fp); + buf[sizeof(buf) / sizeof(wchar_t) - 1] = 0; + + s.open(buf, L"wb"); + s.write(frag, utf8_length(frag)); + s.close(); + } +#endif + return 0; + } + else { + gl_state_get_all_gl_errors(); + + GLenum binary_format = 0x0; + GLsizei length = 0; + while (*buffer_size < 0x7FFFFFF) { + glGetProgramBinary(program, *buffer_size, &length, &binary_format, *binary); + if (!gl_state_get_error()) + break; + + free_def(*binary); + *buffer_size <<= 1; + *binary = force_malloc(*buffer_size); + } + + bin->length = length; + bin->binary_format = binary_format; + bin->binary = (size_t)force_malloc(length); + if (*binary) + memcpy((void*)bin->binary, *binary, length); + return program; + } +} + +static bool shader_load_binary_shader(program_binary* bin, GLuint* program) { + *program = glCreateProgram(); + glProgramBinary(*program, bin->binary_format, (void*)((size_t)bin + bin->binary), bin->length); + GLint success = 0; + glGetProgramiv(*program, GL_LINK_STATUS, &success); + if (!success) { + glDeleteProgram(*program); + *program = 0; + return false; + } + return true; +} + +static void shader_glsl_update_data(shader_glsl_set_data* set) { + if (!set) + return; + + if (set->curr_shader) { + shader_glsl_sub_shader* shader = set->curr_shader; + if (shader->uniform_val_update) { + glUniform1iv(0, SHADER_MAX_UNIFORM_VALUES, (GLint*)shader->uniform_val); + shader->uniform_val_update = false; + } + } + + if (set->primitive_restart) { + gl_state_enable_primitive_restart(); + gl_state_set_primitive_restart_index(set->primitive_restart_index); + } + else + gl_state_disable_primitive_restart(); +} diff --git a/src/DivaGL/shader_glsl.hpp b/src/DivaGL/shader_glsl.hpp new file mode 100644 index 0000000..b8bc9a0 --- /dev/null +++ b/src/DivaGL/shader_glsl.hpp @@ -0,0 +1,114 @@ +/* + by korenkonder + GitHub/GitLab: korenkonder +*/ + +#pragma once + +#include +#include +#include "../KKdLib/default.hpp" +#include "../KKdLib/farc.hpp" +#include "../KKdLib/mat.hpp" +#include "../KKdLib/vec.hpp" +#include "gl.hpp" +#include "uniform.hpp" + +#define SHADER_MAX_LIGHTS 8 +#define SHADER_MAX_PALETTE_MATRICES 32 +#define SHADER_MAX_PROGRAM_ENV_PARAMETERS 256 +#define SHADER_MAX_PROGRAM_LOCAL_PARAMETERS 64 +#define SHADER_MAX_PROGRAM_BUFFER_PARAMETERS 1024 +#define SHADER_MAX_PROGRAM_MATRICES 8 +#define SHADER_MAX_TEXTURE_COORDS 8 +#define SHADER_MAX_UNIFORM_BLOCK_SIZE 65536 +#define SHADER_MAX_UNIFORM_VALUES 16 + +struct shader_glsl_sub_table { + uint32_t sub_index; + const int32_t* vp_unival_max; + const int32_t* fp_unival_max; + const char* vp; + const char* fp; +}; + +struct shader_glsl_table { + const char* name; + uint32_t name_index; + int32_t num_sub; + const shader_glsl_sub_table* sub; + int32_t num_uniform; + const uniform_name* use_uniform; + const bool* use_permut; +}; + +struct shader_glsl; +struct shader_glsl_set_data; + +typedef int32_t (*PFNSHADERGLSLGETINDEXFUNCPROC)(const char* name); + +typedef void (*PFNSHADERGLSLBINDFUNCPROC)(shader_glsl_set_data* set, shader_glsl* shad); + +struct shader_glsl_bind_func { + uint32_t name_index; + PFNSHADERGLSLBINDFUNCPROC bind_func; +}; + +struct shader_glsl_sub_shader { + GLuint program; + int32_t uniform_val[SHADER_MAX_UNIFORM_VALUES]; + bool uniform_val_update; +}; + +struct shader_glsl_sub { + uint32_t sub_index; + const int32_t* vp_unival_max; + const int32_t* fp_unival_max; + shader_glsl_sub_shader* shaders; +}; + +struct shader_glsl { + const char* name; + uint32_t name_index; + int32_t num_sub; + shader_glsl_sub* sub; + int32_t num_uniform; + const uniform_name* use_uniform; + const bool* use_permut; + PFNSHADERGLSLBINDFUNCPROC bind_func; + + int32_t bind(shader_glsl_set_data* set, uint32_t sub_index); + + static bool parse_define(const char* data, char** temp, size_t* temp_size); + static bool parse_define(const char* data, int32_t num_uniform, + int32_t* uniform_value, char** temp, size_t* temp_size); + static char* parse_include(char* data, farc* f); + static void unbind(); +}; + +struct shader_glsl_set_data { + size_t size; + shader_glsl* shaders; + shader_glsl_sub_shader* curr_shader; + GLboolean primitive_restart; + GLuint primitive_restart_index; + + PFNSHADERGLSLGETINDEXFUNCPROC get_index_by_name_func; + + shader_glsl_set_data(); + + void disable_primitive_restart(); + void draw_arrays(GLenum mode, GLint first, GLsizei count); + void draw_elements(GLenum mode, + GLsizei count, GLenum type, const void* indices); + void draw_range_elements(GLenum mode, + GLuint start, GLuint end, GLsizei count, GLenum type, const void* indices); + void enable_primitive_restart(); + int32_t get_index_by_name(const char* name); + void load(farc* f, bool ignore_cache, const char* name, + const shader_glsl_table* shaders_table, const size_t size, + const shader_glsl_bind_func* bind_func_table, const size_t bind_func_table_size, + PFNSHADERGLSLGETINDEXFUNCPROC get_index_by_name); + void set(uint32_t index); + void unload(); +}; diff --git a/src/DivaGL/shader_glsl_ft.cpp b/src/DivaGL/shader_glsl_ft.cpp new file mode 100644 index 0000000..46b7528 --- /dev/null +++ b/src/DivaGL/shader_glsl_ft.cpp @@ -0,0 +1,3387 @@ +/* + by korenkonder + GitHub/GitLab: korenkonder +*/ + +#include "shader_glsl_ft.hpp" +#include "../KKdLib/str_utils.hpp" +#include "gl_state.hpp" +#include "render_context.hpp" +#include "uniform.hpp" + +enum shader_ft_sub_enum { + SHADER_FT_SUB_SHADER_FFP = 0, + SHADER_FT_SUB_BLINN_VERT, + SHADER_FT_SUB_BLINN_FRAG, + SHADER_FT_SUB_ITEM_BLINN, + SHADER_FT_SUB_STAGE_BLINN, + SHADER_FT_SUB_SKIN_DEFAULT, + SHADER_FT_SUB_SSS_SKIN, + //SHADER_FT_SUB_SSS_FILTER, + SHADER_FT_SUB_SSS_FILTER_MIN, + SHADER_FT_SUB_SSS_FILTER_MIN_NPR, + SHADER_FT_SUB_SSS_FILTER_GAUSS_2D, + SHADER_FT_SUB_HAIR_DEFAULT, + //SHADER_FT_SUB_HAIR_ANISO, + SHADER_FT_SUB_HAIR_NPR1, + SHADER_FT_SUB_CLOTH_DEFAULT, + SHADER_FT_SUB_CLOTH_ANISO, + SHADER_FT_SUB_CLOTH_NPR1, + SHADER_FT_SUB_TIGHTS, + SHADER_FT_SUB_SKY_DEFAULT, + //SHADER_FT_SUB_EYE_BALL, + //SHADER_FT_SUB_EYE_LENS, + SHADER_FT_SUB_GLASS_EYE, + //SHADER_FT_SUB_MEMBRANE, + //SHADER_FT_SUB_SHADOWMAP, + //SHADER_FT_SUB_ESM, + SHADER_FT_SUB_ESM_GAUSS, + //SHADER_FT_SUB_ESM_FILTER, + SHADER_FT_SUB_ESM_FILTER_MIN, + SHADER_FT_SUB_ESM_FILTER_EROSION, + SHADER_FT_SUB_LIT_PROJ, + SHADER_FT_SUB_SIMPLE, + SHADER_FT_SUB_SILHOUETTE, + SHADER_FT_SUB_LAMBERT, + SHADER_FT_SUB_CONSTANT, + //SHADER_FT_SUB_PEEL, + SHADER_FT_SUB_TONEMAP, + SHADER_FT_SUB_TONEMAP_NPR1, + //SHADER_FT_SUB_REDUCE_TEX, + SHADER_FT_SUB_GHOST, + SHADER_FT_SUB_REDUCE_TEX_REDUCE_2, + SHADER_FT_SUB_REDUCE_TEX_REDUCE_2_ALPHAMASK, + SHADER_FT_SUB_REDUCE_TEX_REDUCE_4, + SHADER_FT_SUB_REDUCE_TEX_REDUCE_4_EXTRACT, + SHADER_FT_SUB_REDUCE_TEX_REDUCE_COMPOSITE_2, + SHADER_FT_SUB_REDUCE_TEX_REDUCE_COMPOSITE_BLUR, + SHADER_FT_SUB_REDUCE_TEX_REDUCE_COMPOSITE_4, + //SHADER_FT_SUB_MAGNIFY, + SHADER_FT_SUB_MAGNIFY_CONE, + SHADER_FT_SUB_MAGNIFY_CONE2, + SHADER_FT_SUB_MAGNIFY_DIFF, + SHADER_FT_SUB_MAGNIFY_DIFF2, + SHADER_FT_SUB_MAGNIFY_LINEAR, + //SHADER_FT_SUB_MLAA, + SHADER_FT_SUB_MLAA_EDGE, + SHADER_FT_SUB_MLAA_AREA, + SHADER_FT_SUB_MLAA_BLEND, + SHADER_FT_SUB_CONTOUR, + SHADER_FT_SUB_CONTOUR_NPR, + //SHADER_FT_SUB_EXPOSURE, + SHADER_FT_SUB_EXPOSURE_MINIFY, + SHADER_FT_SUB_EXPOSURE_MEASURE, + SHADER_FT_SUB_EXPOSURE_AVERAGE, + //SHADER_FT_SUB_PP_GAUSS, + SHADER_FT_SUB_PP_GAUSS_USUAL, + SHADER_FT_SUB_PP_GAUSS_CONE, + SHADER_FT_SUB_SUN, + SHADER_FT_SUB_SUN_NO_TEXTURED, + //SHADER_FT_SUB_FADE, + SHADER_FT_SUB_WATER01, + //SHADER_FT_SUB_WATER02, + //SHADER_FT_SUB_WATER_RING, + SHADER_FT_SUB_WATER_PARTICLE, + //SHADER_FT_SUB_SNOW_PARTICLE, + SHADER_FT_SUB_SNOW_PARTICLE, + SHADER_FT_SUB_SNOW_PARTICLE_CPU, + SHADER_FT_SUB_LEAF_PARTICLE, + SHADER_FT_SUB_STAR, + SHADER_FT_SUB_STAR_MILKY_WAY, + //SHADER_FT_SUB_SNOW_RING, + //SHADER_FT_SUB_SNOW_FOOTPRINT, + //SHADER_FT_SUB_SNOW_TEX_SPACE_LIGHT, + //SHADER_FT_SUB_SNOW_CALC_NORMAL, + SHADER_FT_SUB_FLOOR, + SHADER_FT_SUB_PUDDLE, + SHADER_FT_SUB_SIMPLE_REFLECT, + SHADER_FT_SUB_SIMPLE_REFRACT, + SHADER_FT_SUB_RIPPLE_EMIT, + SHADER_FT_SUB_RAIN, + //SHADER_FT_SUB_VOLUME_LIGHT, + //SHADER_FT_SUB_FENCE_ALPHA, + SHADER_FT_SUB_RIPPLE, + SHADER_FT_SUB_FOG_PTCL, + SHADER_FT_SUB_PARTICLE, + SHADER_FT_SUB_GLITTER_PARTICLE, + //SHADER_FT_SUB_SHOW_VECTOR, + SHADER_FT_SUB_FONT, + SHADER_FT_SUB_MOVIE, + //SHADER_FT_SUB_IMGFILTER, + SHADER_FT_SUB_BOX4, + SHADER_FT_SUB_BOX8, + SHADER_FT_SUB_COPY, + SHADER_FT_SUB_SPRITE, + SHADER_FT_SUB_SHADER_END, +}; + +static const int32_t blinn_vert_vpt_unival_max[] = { + //1, 1, 0, 1, 0, 0, 0, 3, 1, 1, 0, 0, // 11th added + 1, 0, 1, 0, 0, 0, 3, 1, 1, 0, 0, // 0th removed, 11th added +}; + +static const int32_t blinn_vert_fpt_unival_max[] = { + //0, 0, 2, 1, 0, 1, 1, 3, 0, 0, 1, 1, // 11th added + 0, 2, 1, 0, 1, 1, 3, 0, 0, 1, 1, // 0th removed, 11th added +}; + +static const int32_t blinn_frag_vpt_unival_max[] = { + //1, 1, 0, 1, 0, 0, 0, 3, 1, 1, 0, 0, // 11th added + 1, 0, 1, 0, 0, 0, 3, 1, 1, 0, 0, // 0th removed, 11th added +}; + +static const int32_t blinn_frag_fpt_unival_max[] = { + //0, 0, 2, 1, 1, 1, 1, 3, 0, 0, 1, 1, // 11th added + 0, 2, 1, 1, 1, 1, 3, 0, 0, 1, 1, // 0th removed, 11th added +}; + +static const int32_t item_blinn_vpt_unival_max[] = { + //1, 1, 1, 0, 0, 1, 0, 0, 0, 2, 0, 1, 0, 0, + 1, 1, 0, 0, 1, 0, 0, 0, 2, 0, 1, 0, 0, // 0th removed +}; + +static const int32_t item_blinn_fpt_unival_max[] = { + //1, 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, + 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, // 0th removed +}; + +static const int32_t stage_blinn_vpt_unival_max[] = { + //1, 1, 1, 1, 0, 0, 1, 0, 3, 0, 0, 0, // 11th added + 1, 1, 1, 0, 0, 1, 0, 3, 0, 0, 0, // 0th removed, 11th added +}; + +static const int32_t stage_blinn_fpt_unival_max[] = { + //0, 0, 0, 0, 2, 1, 1, 1, 3, 1, 1, 1, // 11th added + 0, 0, 0, 2, 1, 1, 1, 3, 1, 1, 1, // 0th removed, 11th added +}; + +static const int32_t skin_default_vpt_unival_max[] = { + //1, 1, 1, 0, 2, 0, 1, 0, 0, 0, + 1, 1, 0, 2, 0, 1, 0, 0, 0, // 0th removed +}; + +static const int32_t skin_default_fpt_unival_max[] = { + //1, 0, 1, 1, 0, 1, 0, 1, 1, 1, + 0, 1, 1, 0, 1, 0, 1, 1, 1, // 0th removed +}; + +static const int32_t sss_skin_vpt_unival_max[] = { + //1, 1, 0, 0, 0, 1, 0, 0, + 1, 0, 0, 0, 1, 0, 0, // 0th removed +}; + +static const int32_t sss_skin_fpt_unival_max[] = { + //1, 0, 1, 1, 1, 0, 1, 1, + 0, 1, 1, 1, 0, 1, 1, // 0th removed +}; + +/*static const int32_t sss_filter_vpt_unival_max[] = { + //0, 3, 0, + 3, 0, // 0th removed +}; + +static const int32_t sss_filter_fpt_unival_max[] = { + //1, 3, 1, + 3, 1, // 0th removed +};*/ + +static const int32_t sss_filter_min_vpt_unival_max[] = { + //0, 0, 0, + 0, 0, // 0th removed +}; + +static const int32_t sss_filter_min_fpt_unival_max[] = { + //0, 0, 0, + 0, 0, // 0th removed +}; + +static const int32_t sss_filter_min_npr_vpt_unival_max[] = { + //0, 0, 0, + 0, 0, // 0th removed +}; + +static const int32_t sss_filter_min_npr_fpt_unival_max[] = { + //0, 0, 0, + 0, 0, // 0th removed +}; + +static const int32_t sss_filter_gauss_2d_vpt_unival_max[] = { + //0, 0, 0, + 0, 0, // 0th removed +}; + +static const int32_t sss_filter_gauss_2d_fpt_unival_max[] = { + //1, 0, 0, + 0, 0, // 0th removed +}; + +/*static const int32_t hair_default_vpt_unival_max[] = { + //1, 1, 0, 0, 1, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, // 14th added + 1, 0, 0, 1, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, // 0th removed, 14th added +}; + +static const int32_t hair_default_fpt_unival_max[] = { + //1, 0, 2, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 1, // 14th added + 0, 2, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 1, // 0th removed, 14th added +}; + +static const int32_t hair_aniso_vpt_unival_max[] = { + //1, 1, 0, 0, 1, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, // 14th added + 1, 0, 0, 1, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, // 0th removed, 14th added +}; + +static const int32_t hair_aniso_fpt_unival_max[] = { + //1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 0, 1, 1, 1, // 14th added + 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 0, 1, 1, 1, // 0th removed, 14th added +};*/ + +static const int32_t hair_default_vpt_unival_max[] = { + //1, 1, 0, 0, 1, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, // 14th added + 1, 0, 0, 1, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, // 0th removed, 14th added +}; + +static const int32_t hair_default_fpt_unival_max[] = { + //1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 0, 1, 1, 1, // 14th added + 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 0, 1, 1, 1, // 0th removed, 14th added +}; + +static const int32_t hair_npr1_vpt_unival_max[] = { + //1, 1, 0, 0, 1, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, // 14th added + 1, 0, 0, 1, 0, 0, 3, 0, 2, 1, 0, 0, 0, 0, // 0th removed, 14th added +}; + +static const int32_t hair_npr1_fpt_unival_max[] = { + //1, 0, 0, 0, 0, 1, 0, 3, 1, 0, 0, 0, 0, 0, 1, // 14th added + 0, 0, 0, 0, 1, 0, 3, 1, 0, 0, 0, 0, 0, 1, // 0th removed, 14th added +}; + +static const int32_t cloth_default_vpt_unival_max[] = { + //1, 1, 0, 0, 1, 0, 0, 0, 2, 0, 0, 1, 0, 0, 0, + 1, 0, 0, 1, 0, 0, 0, 2, 0, 0, 1, 0, 0, 0, // 0th removed +}; + +static const int32_t cloth_default_fpt_unival_max[] = { + //1, 0, 2, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 1, 1, + 0, 2, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 1, 1, // 0th removed +}; + +static const int32_t cloth_aniso_vpt_unival_max[] = { + //1, 1, 0, 0, 1, 0, 0, 0, 2, 0, 0, 1, 0, 0, 0, + 1, 0, 0, 1, 0, 0, 0, 2, 0, 0, 1, 0, 0, 0, // 0th removed +}; + +static const int32_t cloth_aniso_fpt_unival_max[] = { + //1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 3, 0, 0, 1, 1, + 0, 0, 1, 0, 1, 1, 1, 0, 1, 3, 0, 0, 1, 1, // 0th removed +}; + +static const int32_t cloth_npr1_vpt_unival_max[] = { + //1, 1, 0, 0, 1, 0, 0, 0, 2, 0, 0, 1, 0, 0, 0, + 1, 0, 0, 1, 0, 0, 0, 2, 0, 0, 1, 0, 0, 0, // 0th removed +}; + +static const int32_t cloth_npr1_fpt_unival_max[] = { + //1, 0, 0, 1, 1, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 1, 1, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, // 0th removed +}; + +static const int32_t tights_vpt_unival_max[] = { + //1, 1, 0, 0, 0, 2, 0, 1, 0, 0, 0, + 1, 0, 0, 0, 2, 0, 1, 0, 0, 0, // 0th removed +}; + +static const int32_t tights_fpt_unival_max[] = { + //1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, + 1, 1, 1, 0, 1, 0, 1, 1, 1, // 0th removed +}; + +static const int32_t sky_default_vpt_unival_max[] = { + 0, 0, 0, 1, 1, 3, 0, // 6th added +}; + +static const int32_t sky_default_fpt_unival_max[] = { + 3, 3, 2, 0, 0, 3, 1, // 6th added +}; + +/*static const int32_t eye_ball_vpt_unival_max[] = { + 1, 0, +}; + +static const int32_t eye_ball_fpt_unival_max[] = { + 0, 1, +};*/ + +/*static const int32_t eye_lens_vpt_unival_max[] = { + 1, 0, 0, +}; + +static const int32_t eye_lens_fpt_unival_max[] = { + 0, 1, 1, +};*/ + +static const int32_t glass_eye_vpt_unival_max[] = { + //1, 1, 0, 2, 0, 1, 0, 0, + 1, 0, 2, 0, 1, 0, 0, // 0th removed +}; + +static const int32_t glass_eye_fpt_unival_max[] = { + //1, 1, 1, 0, 1, 0, 1, 1, + 1, 1, 0, 1, 0, 1, 1, // 0th removed +}; + +/*static const int32_t membrane_vpt_unival_max[] = { + 1, 1, 0, +}; + +static const int32_t membrane_fpt_unival_max[] = { + 0, 1, 3, +};*/ + +/*static const int32_t shadowmap_vpt_unival_max[] = { + 1, 2, 1, 0, 0, +}; + +static const int32_t shadowmap_fpt_unival_max[] = { + 0, 2, 1, 1, 5, +};*/ + +/*static const int32_t esm_vpt_unival_max[] = { + //1, 1, 2, 1, + 1, 2, 1, // 0th removed +}; + +static const int32_t esm_fpt_unival_max[] = { + //0, 0, 2, 1, + 0, 2, 1, // 0th removed +};*/ + +static const int32_t esm_gauss_vpt_unival_max[] = { + 0, +}; + +static const int32_t esm_gauss_fpt_unival_max[] = { + 1, +}; + +/*static const int32_t esm_filter_vpt_unival_max[] = { + 0, +}; + +static const int32_t esm_filter_fpt_unival_max[] = { + 1, +};*/ + +static const int32_t esm_filter_min_vpt_unival_max[] = { + 0, +}; + +static const int32_t esm_filter_min_fpt_unival_max[] = { + 0, +}; + +static const int32_t esm_filter_erosion_vpt_unival_max[] = { + 0, +}; + +static const int32_t esm_filter_erosion_fpt_unival_max[] = { + 0, +}; + +static const int32_t lit_proj_vpt_unival_max[] = { + //1, 1, 0, 1, 0, 0, + 1, 0, 1, 0, 0, // 0th removed +}; + +static const int32_t lit_proj_fpt_unival_max[] = { + //0, 0, 1, 1, 2, 1, + 0, 1, 1, 2, 1, // 0th removed +}; + +static const int32_t simple_vpt_unival_max[] = { + //1, 1, 0, 0, 1, 0, + 1, 0, // 0th removed, 3rd removed, 4th removed, 5th removed +}; + +static const int32_t simple_fpt_unival_max[] = { + //0, 0, 2, 0, 0, 3, + 0, 2, // 0th removed, 3rd removed, 4th removed, 5th removed +}; + +static const int32_t silhouette_vpt_unival_max[] = { + //1, 1, 1, 2, 1, 1, 0, 0, // 7th added + 1, 1, 2, 1, 1, 0, 0, // 0th removed, 7th added +}; + +static const int32_t silhouette_fpt_unival_max[] = { + //0, 0, 1, 0, 0, 0, 1, 1, // 7th added + 0, 1, 0, 0, 0, 1, 1, // 0th removed, 7th added +}; + +static const int32_t lambert_vpt_unival_max[] = { + //1, 1, 0, 1, 3, 1, 1, 0, 0, // 8th added + 1, 0, 1, 3, 1, 1, 0, 0, // 0th removed, 8th added +}; + +static const int32_t lambert_fpt_unival_max[] = { + //0, 0, 2, 1, 3, 0, 0, 1, 1, // 8th added + 0, 2, 1, 3, 0, 0, 1, 1, // 0th removed, 8th added +}; + +static const int32_t constant_vpt_unival_max[] = { + //1, 1, 0, 3, 1, 1, 0, // 6th added + 1, 0, 3, 1, 1, 0, // 0th removed, 6th added +}; + +static const int32_t constant_fpt_unival_max[] = { + //0, 0, 2, 3, 0, 0, 1, // 6th added + 0, 2, 3, 0, 0, 1, // 0th removed, 6th added +}; + +/*static const int32_t peel_vpt_unival_max[] = { + 0, 1, +}; + +static const int32_t peel_fpt_unival_max[] = { + 1, 0, +};*/ + +static const int32_t tone_map_vpt_unival_max[] = { + //0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 1, 0, 0, // 0th, 7th removed +}; + +static const int32_t tone_map_fpt_unival_max[] = { + //0, 2, 2, 1, 1, 1, 0, 0, + 2, 2, 1, 1, 1, 0, // 0th, 7th removed +}; + +static const int32_t tone_map_npr1_vpt_unival_max[] = { + //0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 1, 0, 0, // 0th, 7th removed +}; + +static const int32_t tone_map_npr1_fpt_unival_max[] = { + //1, 0, 0, 1, 1, 0, 0, 1, + 0, 0, 1, 1, 0, 0, // 0th, 7th removed +}; + +/*static const int32_t reduce_tex_vpt_unival_max[] = { + 8, 1, +}; + +static const int32_t reduce_tex_fpt_unival_max[] = { + 8, 1, +};*/ + +static const int32_t reduce_tex_reduce_2_vpt_unival_max[] = { + 0, 0, +}; + +static const int32_t reduce_tex_reduce_2_fpt_unival_max[] = { + 0, 0, +}; + +static const int32_t reduce_tex_reduce_2_alphamask_vpt_unival_max[] = { + 0, 0, +}; + +static const int32_t reduce_tex_reduce_2_alphamask_fpt_unival_max[] = { + 0, 0, +}; + +static const int32_t reduce_tex_reduce_4_vpt_unival_max[] = { + 0, 0, +}; + +static const int32_t reduce_tex_reduce_4_fpt_unival_max[] = { + 0, 0, +}; + +static const int32_t reduce_tex_reduce_4_extract_vpt_unival_max[] = { + 0, 0, +}; + +static const int32_t reduce_tex_reduce_4_extract_fpt_unival_max[] = { + 0, 0, +}; + +static const int32_t ghost_vpt_unival_max[] = { + 0, 0, +}; + +static const int32_t ghost_fpt_unival_max[] = { + 0, 0, +}; + +static const int32_t reduce_tex_reduce_composite_2_vpt_unival_max[] = { + 0, 0, +}; + +static const int32_t reduce_tex_reduce_composite_2_fpt_unival_max[] = { + 0, 0, +}; + +static const int32_t reduce_tex_reduce_composite_blur_vpt_unival_max[] = { + 0, 0, +}; + +static const int32_t reduce_tex_reduce_composite_blur_fpt_unival_max[] = { + 0, 0, +}; + +static const int32_t reduce_tex_reduce_composite_4_vpt_unival_max[] = { + 0, 0, +}; + +static const int32_t reduce_tex_reduce_composite_4_fpt_unival_max[] = { + 0, 0, +}; + +/*static const int32_t magnify_vpt_unival_max[] = { + 7, +}; + +static const int32_t magnify_fpt_unival_max[] = { + 7, +};*/ + +static const int32_t magnify_linear_vpt_unival_max[] = { + 0, +}; + +static const int32_t magnify_linear_fpt_unival_max[] = { + 0, +}; + +static const int32_t magnify_diff_vpt_unival_max[] = { + 0, +}; + +static const int32_t magnify_diff_fpt_unival_max[] = { + 0, +}; + +static const int32_t magnify_diff2_vpt_unival_max[] = { + 0, +}; + +static const int32_t magnify_diff2_fpt_unival_max[] = { + 0, +}; + +static const int32_t magnify_cone_vpt_unival_max[] = { + 0, +}; + +static const int32_t magnify_cone_fpt_unival_max[] = { + 0, +}; + +static const int32_t magnify_cone2_vpt_unival_max[] = { + 0, +}; + +static const int32_t magnify_cone2_fpt_unival_max[] = { + 0, +}; + +/*static const int32_t mlaa_vpt_unival_max[] = { + //0, 0, 2, 0, + 0, 2, 0, // 0th removed +}; + +static const int32_t mlaa_fpt_unival_max[] = { + //1, 1, 2, 2, + 1, 2, 2, // 0th removed +};*/ + +static const int32_t mlaa_edge_vpt_unival_max[] = { + 0, 0, 0, +}; + +static const int32_t mlaa_edge_fpt_unival_max[] = { + 1, 0, 0, +}; + +static const int32_t mlaa_area_vpt_unival_max[] = { + 0, 0, 0, +}; + +static const int32_t mlaa_area_fpt_unival_max[] = { + 0, 0, 2, +}; + +static const int32_t mlaa_blend_vpt_unival_max[] = { + 0, 0, 0, +}; + +static const int32_t mlaa_blend_fpt_unival_max[] = { + 1, 0, 0, +}; + +static const int32_t contour_vpt_unival_max[] = { + //0, 1, + 1, // 0th removed +}; + +static const int32_t contour_fpt_unival_max[] = { + //1, 1, + 1, // 0th removed +}; + +static const int32_t contour_npr_vpt_unival_max[] = { + -1, +}; + +static const int32_t contour_npr_fpt_unival_max[] = { + -1, +}; + +/*static const int32_t exposure_vpt_unival_max[] = { + 2, +}; + +static const int32_t exposure_fpt_unival_max[] = { + 2, +};*/ + +static const int32_t exposure_minify_vpt_unival_max[] = { + 0, +}; + +static const int32_t exposure_minify_fpt_unival_max[] = { + 0, +}; + +static const int32_t exposure_measure_vpt_unival_max[] = { + 0, +}; + +static const int32_t exposure_measure_fpt_unival_max[] = { + 0, +}; + +static const int32_t exposure_average_vpt_unival_max[] = { + 0, +}; + +static const int32_t exposure_average_fpt_unival_max[] = { + 0, +}; + +/*static const int32_t pp_gauss_vpt_unival_max[] = { + 1, +}; + +static const int32_t pp_gauss_fpt_unival_max[] = { + 1, +};*/ + +static const int32_t pp_gauss_usual_vpt_unival_max[] = { + 0, +}; + +static const int32_t pp_gauss_usual_fpt_unival_max[] = { + 0, +}; + +static const int32_t pp_gauss_cone_vpt_unival_max[] = { + 0, +}; + +static const int32_t pp_gauss_cone_fpt_unival_max[] = { + 0, +}; + +static const int32_t sun_vpt_unival_max[] = { + -1, +}; + +static const int32_t sun_fpt_unival_max[] = { + -1, +}; + +static const int32_t sun_no_textured_vpt_unival_max[] = { + -1, +}; + +static const int32_t sun_no_textured_fpt_unival_max[] = { + -1, +}; + +/*static const int32_t fade_vpt_unival_max[] = { + 5, +}; + +static const int32_t fade_fpt_unival_max[] = { + 5, +};*/ + +static const int32_t water01_vpt_unival_max[] = { + 1, 1, 0, 0, 0, 0, 0, 1, +}; + +static const int32_t water01_fpt_unival_max[] = { + 0, 0, 2, 1, 1, 1, 1, 1, +}; + +/*static const int32_t water02_vpt_unival_max[] = { + -1, +}; + +static const int32_t water02_fpt_unival_max[] = { + -1, +};*/ + +/*static const int32_t water_ring_vpt_unival_max[] = { + 1, 0, +}; + +static const int32_t water_ring_fpt_unival_max[] = { + 1, 1, +};*/ + +static const int32_t water_particle_vpt_unival_max[] = { + -1, +}; + +static const int32_t water_particle_fpt_unival_max[] = { + -1, +}; + +/*static const int32_t snow_particle_vpt_unival_max[] = { + 1, +}; + +static const int32_t snow_particle_fpt_unival_max[] = { + 1, +};*/ + +static const int32_t snow_particle_vpt_unival_max[] = { + 0, +}; + +static const int32_t snow_particle_fpt_unival_max[] = { + 0, +}; + +static const int32_t snow_particle_cpu_vpt_unival_max[] = { + 0, +}; + +static const int32_t snow_particle_cpu_fpt_unival_max[] = { + 0, +}; + +static const int32_t leaf_particle_vpt_unival_max[] = { + -1, +}; + +static const int32_t leaf_particle_fpt_unival_max[] = { + -1, +}; + +/*static const int32_t star_vpt_unival_max[] = { + 1, +}; + +static const int32_t star_fpt_unival_max[] = { + 1, +};*/ + +static const int32_t star_vpt_unival_max[] = { + 0, +}; + +static const int32_t star_fpt_unival_max[] = { + 0, +}; + +static const int32_t star_milky_way_vpt_unival_max[] = { + 0, +}; + +static const int32_t star_milky_way_fpt_unival_max[] = { + 0, +}; + +static const int32_t snow_ring_vpt_unival_max[] = { + 0, 0, 0, 1, 0, +}; + +static const int32_t snow_ring_fpt_unival_max[] = { + 2, 1, 1, 1, 1, +}; + +static const int32_t snow_footprint_vpt_unival_max[] = { + -1, +}; + +static const int32_t snow_footprint_fpt_unival_max[] = { + -1, +}; + +static const int32_t snow_tex_space_light_vpt_unival_max[] = { + -1, +}; + +static const int32_t snow_tex_space_light_fpt_unival_max[] = { + -1, +}; + +static const int32_t snow_calc_normal_vpt_unival_max[] = { + -1, +}; + +static const int32_t snow_calc_normal_fpt_unival_max[] = { + -1, +}; + +static const int32_t floor_vpt_unival_max[] = { + 0, 0, 1, 0, 3, 1, 1, 0, +}; + +static const int32_t floor_fpt_unival_max[] = { + 2, 1, 1, 1, 3, 0, 0, 1, // 7th added +}; + +static const int32_t puddle_vpt_unival_max[] = { + 0, 1, 0, 3, +}; + +static const int32_t puddle_fpt_unival_max[] = { + 1, 1, 1, 3, +}; + +static const int32_t simple_reflect_vpt_unival_max[] = { + //1, 1, 2, 1, 1, 0, 0, 0, 0, 0, + 1, 2, 1, 1, 0, 0, 0, 0, 0, // 0th removed +}; + +static const int32_t simple_reflect_fpt_unival_max[] = { + //0, 0, 2, 0, 0, 1, 1, 2, 1, 1, + 0, 2, 0, 0, 1, 1, 2, 1, 1, // 0th removed +}; + +static const int32_t simple_refract_vpt_unival_max[] = { + 1, 0, +}; + +static const int32_t simple_refract_fpt_unival_max[] = { + 0, 1, +}; + +static const int32_t ripple_emit_vpt_unival_max[] = { + 0, 0, +}; + +static const int32_t ripple_emit_fpt_unival_max[] = { + 1, 1, +}; + +static const int32_t rain_vpt_unival_max[] = { + -1, +}; + +static const int32_t rain_fpt_unival_max[] = { + -1, +}; + +/*static const int32_t volume_light_vpt_unival_max[] = { + -1, +}; + +static const int32_t volume_light_fpt_unival_max[] = { + -1, +};*/ + +/*static const int32_t fence_alpha_vpt_unival_max[] = { + 1, 3, +}; + +static const int32_t fence_alpha_fpt_unival_max[] = { + 0, 3, +};*/ + +static const int32_t ripple_vpt_unival_max[] = { + 0, +}; + +static const int32_t ripple_fpt_unival_max[] = { + 1, +}; + +static const int32_t fog_ptcl_vpt_unival_max[] = { + -1, +}; + +static const int32_t fog_ptcl_fpt_unival_max[] = { + -1, +}; + +static const int32_t particle_vpt_unival_max[] = { + -1, +}; + +static const int32_t particle_fpt_unival_max[] = { + -1, +}; + +static const int32_t glitter_particle_vpt_unival_max[] = { + 2, 0, 3, 0, +}; + +static const int32_t glitter_particle_fpt_unival_max[] = { + 2, 3, 3, 3, +}; + +/*static const int32_t show_vector_vpt_unival_max[] = { + //1, 1, 3, + 1, 3, // 0th removed +}; + +static const int32_t show_vector_fpt_unival_max[] = { + //0, 0, 0, + 0, 0, // 0th removed +};*/ + +static const int32_t font_vpt_unival_max[] = { + //0, + -1, // 0th removed, 1st added +}; + +static const int32_t font_fpt_unival_max[] = { + //1, + -1, // 0th removed, 1st added +}; + +static const int32_t movie_vpt_unival_max[] = { + 0, +}; + +static const int32_t movie_fpt_unival_max[] = { + 1, +}; + +/*static const int32_t imgfilter_vpt_unival_max[] = { + 0, +}; + +static const int32_t imgfilter_fpt_unival_max[] = { + 5, +};*/ + +static const int32_t box4_vpt_unival_max[] = { + 0, +}; + +static const int32_t box4_fpt_unival_max[] = { + 0, +}; + +static const int32_t box8_vpt_unival_max[] = { + 0, +}; + +static const int32_t box8_fpt_unival_max[] = { + 0, +}; + +static const int32_t copy_vpt_unival_max[] = { + 0, +}; + +static const int32_t copy_fpt_unival_max[] = { + 0, +}; +static const int32_t sprite_vpt_unival_max[] = { + 0, 0, 0, +}; + +static const int32_t sprite_fpt_unival_max[] = { + 3, 3, 2, +}; + +static const shader_glsl_sub_table BLINN_table[] = { + { + SHADER_FT_SUB_BLINN_VERT, + blinn_vert_vpt_unival_max, + blinn_vert_fpt_unival_max, + "blinn_per_vert", + "blinn_per_vert", + }, + { + SHADER_FT_SUB_BLINN_FRAG, + blinn_frag_vpt_unival_max, + blinn_frag_fpt_unival_max, + "blinn_per_frag", + "blinn_per_frag", + }, +}; + +static const shader_glsl_sub_table ITEM_table[] = { + { + SHADER_FT_SUB_ITEM_BLINN, + item_blinn_vpt_unival_max, + item_blinn_fpt_unival_max, + "item_blinn", + "item_blinn", + }, +}; + +static const shader_glsl_sub_table STAGE_table[] = { + { + SHADER_FT_SUB_STAGE_BLINN, + stage_blinn_vpt_unival_max, + stage_blinn_fpt_unival_max, + "stage_blinn", + "stage_blinn", + }, +}; + +static const shader_glsl_sub_table SKIN_table[] = { + { + SHADER_FT_SUB_SKIN_DEFAULT, + skin_default_vpt_unival_max, + skin_default_fpt_unival_max, + "skin_default", + "skin_default", + }, +}; + +static const shader_glsl_sub_table SSS_SKIN_table[] = { + { + SHADER_FT_SUB_SSS_SKIN, + sss_skin_vpt_unival_max, + sss_skin_fpt_unival_max, + "sss_skin", + "sss_skin", + }, +}; + +/*static const shader_glsl_sub_table SSS_FILT_table[] = { + { + SHADER_FT_SUB_SSS_FILTER, + sss_filter_vpt_unival_max, + sss_filter_fpt_unival_max, + "sss_filter", + "sss_filter", + }, +};*/ + +static const shader_glsl_sub_table SSS_FILT_table[] = { + { + SHADER_FT_SUB_SSS_FILTER_MIN, + sss_filter_min_vpt_unival_max, + sss_filter_min_fpt_unival_max, + "sss_filter_min", + "sss_filter_min", + }, + { + SHADER_FT_SUB_SSS_FILTER_MIN_NPR, + sss_filter_min_npr_vpt_unival_max, + sss_filter_min_npr_fpt_unival_max, + "sss_filter_min", + "sss_filter_min_npr", + }, + { + SHADER_FT_SUB_SSS_FILTER_GAUSS_2D, + sss_filter_gauss_2d_vpt_unival_max, + sss_filter_gauss_2d_fpt_unival_max, + "sss_filter_gauss_2d", + "sss_filter_gauss_2d", + }, +}; + +/*static const shader_glsl_sub_table HAIR_table[] = { + { + SHADER_FT_SUB_HAIR_DEFAULT, + hair_default_vpt_unival_max, + hair_default_fpt_unival_max, + "hair_default", + "hair_default", + }, + { + SHADER_FT_SUB_HAIR_ANISO, + hair_aniso_vpt_unival_max, + hair_aniso_fpt_unival_max, + "hair_default", + "hair_aniso", + }, + { + SHADER_FT_SUB_HAIR_NPR1, + hair_npr1_vpt_unival_max, + hair_npr1_fpt_unival_max, + "hair_default", + "hair_npr1", + }, +};*/ + +static const shader_glsl_sub_table HAIR_table[] = { + { + SHADER_FT_SUB_HAIR_DEFAULT, + hair_default_vpt_unival_max, + hair_default_fpt_unival_max, + "hair_default", + "hair_default", + }, + { + SHADER_FT_SUB_HAIR_NPR1, + hair_npr1_vpt_unival_max, + hair_npr1_fpt_unival_max, + "hair_default", + "hair_npr1", + }, +}; + +static const shader_glsl_sub_table CLOTH_table[] = { + { + SHADER_FT_SUB_CLOTH_DEFAULT, + cloth_default_vpt_unival_max, + cloth_default_fpt_unival_max, + "cloth_default", + "cloth_default", + }, + { + SHADER_FT_SUB_CLOTH_ANISO, + cloth_aniso_vpt_unival_max, + cloth_aniso_fpt_unival_max, + "cloth_default", + "cloth_aniso", + }, + { + SHADER_FT_SUB_CLOTH_NPR1, + cloth_npr1_vpt_unival_max, + cloth_npr1_fpt_unival_max, + "cloth_default", + "cloth_npr1", + }, +}; + +static const shader_glsl_sub_table TIGHTS_table[] = { + { + SHADER_FT_SUB_TIGHTS, + tights_vpt_unival_max, + tights_fpt_unival_max, + "tights", + "tights", + }, +}; + +static const shader_glsl_sub_table SKY_table[] = { + { + SHADER_FT_SUB_SKY_DEFAULT, + sky_default_vpt_unival_max, + sky_default_fpt_unival_max, + "sky_default", + "sky_default", + }, +}; + +/*static const shader_glsl_sub_table EYEBALL_table[] = { + { + SHADER_FT_SUB_EYE_BALL, + eye_ball_vpt_unival_max, + eye_ball_fpt_unival_max, + "eye_ball", + "eye_ball", + }, +};*/ + +/*static const shader_glsl_sub_table EYELENS_table[] = { + { + SHADER_FT_SUB_EYE_LENS, + eye_lens_vpt_unival_max, + eye_lens_fpt_unival_max, + "eye_lens", + "eye_lens", + }, +};*/ + +static const shader_glsl_sub_table GLASEYE_table[] = { + { + SHADER_FT_SUB_GLASS_EYE, + glass_eye_vpt_unival_max, + glass_eye_fpt_unival_max, + "glass_eye", + "glass_eye", + }, +}; + +/*static const shader_glsl_sub_table MEMBRAN_table[] = { + { + SHADER_FT_SUB_MEMBRANE, + membrane_vpt_unival_max, + membrane_fpt_unival_max, + "membrane", + "membrane", + }, +};*/ + +/*static const shader_glsl_sub_table SHDMAP_table[] = { + { + SHADER_FT_SUB_SHADOWMAP, + shadowmap_vpt_unival_max, + shadowmap_fpt_unival_max, + "shadowmap", + "shadowmap", + }, +};*/ + +/*static const shader_glsl_sub_table ESM_table[] = { + { + SHADER_FT_SUB_ESM, + esm_vpt_unival_max, + esm_fpt_unival_max, + "esm", + "esm", + }, +};*/ + +static const shader_glsl_sub_table ESMGAUSS_table[] = { + { + SHADER_FT_SUB_ESM_GAUSS, + esm_gauss_vpt_unival_max, + esm_gauss_fpt_unival_max, + "esm_gauss", + "esm_gauss", + }, +}; + +/*static const shader_glsl_sub_table ESMFILT_table[] = { + { + SHADER_FT_SUB_ESM_FILTER, + esm_filter_vpt_unival_max, + esm_filter_fpt_unival_max, + "esm_filter", + "esm_filter", + }, +};*/ + +static const shader_glsl_sub_table ESMFILT_table[] = { + { + SHADER_FT_SUB_ESM_FILTER_MIN, + esm_filter_min_vpt_unival_max, + esm_filter_min_fpt_unival_max, + "esm_filter_min", + "esm_filter_min", + }, + { + SHADER_FT_SUB_ESM_FILTER_EROSION, + esm_filter_erosion_vpt_unival_max, + esm_filter_erosion_fpt_unival_max, + "esm_filter_erosion", + "esm_filter_erosion", + }, +}; + +static const shader_glsl_sub_table LITPROJ_table[] = { + { + SHADER_FT_SUB_LIT_PROJ, + lit_proj_vpt_unival_max, + lit_proj_fpt_unival_max, + "lit_proj", + "lit_proj", + }, +}; + +static const shader_glsl_sub_table SIMPLE_table[] = { + { + SHADER_FT_SUB_SIMPLE, + simple_vpt_unival_max, + simple_fpt_unival_max, + "simple", + "simple", + }, +}; + +static const shader_glsl_sub_table SIL_table[] = { + { + SHADER_FT_SUB_SILHOUETTE, + silhouette_vpt_unival_max, + silhouette_fpt_unival_max, + "silhouette", + "silhouette", + }, +}; + +static const shader_glsl_sub_table LAMBERT_table[] = { + { + SHADER_FT_SUB_LAMBERT, + lambert_vpt_unival_max, + lambert_fpt_unival_max, + "lambert", + "lambert", + }, +}; + +static const shader_glsl_sub_table CONSTANT_table[] = { + { + SHADER_FT_SUB_CONSTANT, + constant_vpt_unival_max, + constant_fpt_unival_max, + "constant", + "constant", + }, +}; + +/*static const shader_glsl_sub_table PEEL_table[] = { + { + SHADER_FT_SUB_PEEL, + peel_vpt_unival_max, + peel_fpt_unival_max, + "depth_peel", + "depth_peel", + }, +};*/ + +static const shader_glsl_sub_table TONEMAP_table[] = { + { + SHADER_FT_SUB_TONEMAP, + tone_map_vpt_unival_max, + tone_map_fpt_unival_max, + "tone_map", + "tone_map", + }, + { + SHADER_FT_SUB_TONEMAP_NPR1, + tone_map_npr1_vpt_unival_max, + tone_map_npr1_fpt_unival_max, + "tone_map_npr1", + "tone_map_npr1", + }, +}; + +/*static const shader_glsl_sub_table REDUCE_table[] = { + { + SHADER_FT_SUB_REDUCE_TEX, + reduce_tex_vpt_unival_max, + reduce_tex_fpt_unival_max, + "reduce_tex", + "reduce_tex", + }, +};*/ + +static const shader_glsl_sub_table REDUCE_table[] = { + { + SHADER_FT_SUB_REDUCE_TEX_REDUCE_2, + reduce_tex_reduce_2_vpt_unival_max, + reduce_tex_reduce_2_fpt_unival_max, + "reduce_tex_reduce_2", + "reduce_tex_reduce_2", + }, + { + SHADER_FT_SUB_REDUCE_TEX_REDUCE_2_ALPHAMASK, + reduce_tex_reduce_2_alphamask_vpt_unival_max, + reduce_tex_reduce_2_alphamask_fpt_unival_max, + "reduce_tex_reduce_2_alphamask", + "reduce_tex_reduce_2_alphamask", + }, + { + SHADER_FT_SUB_REDUCE_TEX_REDUCE_4, + reduce_tex_reduce_4_vpt_unival_max, + reduce_tex_reduce_4_fpt_unival_max, + "reduce_tex_reduce_4", + "reduce_tex_reduce_4", + }, + { + SHADER_FT_SUB_REDUCE_TEX_REDUCE_4_EXTRACT, + reduce_tex_reduce_4_extract_vpt_unival_max, + reduce_tex_reduce_4_extract_fpt_unival_max, + "reduce_tex_reduce_4_extract", + "reduce_tex_reduce_4_extract", + }, + { + SHADER_FT_SUB_GHOST, + ghost_vpt_unival_max, + ghost_fpt_unival_max, + "ghost", + "ghost", + }, + { + SHADER_FT_SUB_REDUCE_TEX_REDUCE_COMPOSITE_2, + reduce_tex_reduce_composite_2_vpt_unival_max, + reduce_tex_reduce_composite_2_fpt_unival_max, + "reduce_tex_reduce_composite_2", + "reduce_tex_reduce_composite_2", + }, + { + SHADER_FT_SUB_REDUCE_TEX_REDUCE_COMPOSITE_BLUR, + reduce_tex_reduce_composite_blur_vpt_unival_max, + reduce_tex_reduce_composite_blur_fpt_unival_max, + "reduce_tex_reduce_composite_blur", + "reduce_tex_reduce_composite_blur", + }, + { + SHADER_FT_SUB_REDUCE_TEX_REDUCE_COMPOSITE_4, + reduce_tex_reduce_composite_4_vpt_unival_max, + reduce_tex_reduce_composite_4_fpt_unival_max, + "reduce_tex_reduce_composite_4", + "reduce_tex_reduce_composite_4", + }, +}; + +/*static const shader_glsl_sub_table MAGNIFY_table[] = { + { + SHADER_FT_SUB_MAGNIFY, + magnify_vpt_unival_max, + magnify_fpt_unival_max, + "magnify", + "magnify", + }, +};*/ + +static const shader_glsl_sub_table MAGNIFY_table[] = { + { + SHADER_FT_SUB_MAGNIFY_LINEAR, + magnify_linear_vpt_unival_max, + magnify_linear_fpt_unival_max, + "magnify_linear", + "magnify_linear", + }, + { + SHADER_FT_SUB_MAGNIFY_DIFF, + magnify_diff_vpt_unival_max, + magnify_diff_fpt_unival_max, + "magnify_diff", + "magnify_diff", + }, + { + SHADER_FT_SUB_MAGNIFY_DIFF2, + magnify_diff2_vpt_unival_max, + magnify_diff2_fpt_unival_max, + "magnify_diff2", + "magnify_diff2", + }, + { + SHADER_FT_SUB_MAGNIFY_CONE, + magnify_cone_vpt_unival_max, + magnify_cone_fpt_unival_max, + "magnify_cone", + "magnify_cone", + }, + { + SHADER_FT_SUB_MAGNIFY_CONE2, + magnify_cone2_vpt_unival_max, + magnify_cone2_fpt_unival_max, + "magnify_cone2", + "magnify_cone2", + }, +}; + +/*static const shader_glsl_sub_table MLAA_table[] = { + { + SHADER_FT_SUB_MLAA, + mlaa_vpt_unival_max, + mlaa_fpt_unival_max, + "mlaa", + "mlaa", + }, +};*/ + +static const shader_glsl_sub_table MLAA_table[] = { + { + SHADER_FT_SUB_MLAA_EDGE, + mlaa_edge_vpt_unival_max, + mlaa_edge_fpt_unival_max, + "mlaa_edge", + "mlaa_edge", + }, + { + SHADER_FT_SUB_MLAA_AREA, + mlaa_area_vpt_unival_max, + mlaa_area_fpt_unival_max, + "mlaa_area", + "mlaa_area", + }, + { + SHADER_FT_SUB_MLAA_BLEND, + mlaa_blend_vpt_unival_max, + mlaa_blend_fpt_unival_max, + "mlaa_blend", + "mlaa_blend", + }, +}; + +static const shader_glsl_sub_table CONTOUR_table[] = { + { + SHADER_FT_SUB_CONTOUR, + contour_vpt_unival_max, + contour_fpt_unival_max, + "contour", + "contour", + }, +}; + +static const shader_glsl_sub_table CONTOUR_NPR_table[] = { + { + SHADER_FT_SUB_CONTOUR_NPR, + contour_npr_vpt_unival_max, + contour_npr_fpt_unival_max, + "contour_npr", + "contour_npr", + }, +}; + +/*static const shader_glsl_sub_table EXPOSURE_table[] = { + { + SHADER_FT_SUB_EXPOSURE, + exposure_vpt_unival_max, + exposure_fpt_unival_max, + "exposure", + "exposure", + }, +};*/ + +static const shader_glsl_sub_table EXPOSURE_table[] = { + { + SHADER_FT_SUB_EXPOSURE_MINIFY, + exposure_minify_vpt_unival_max, + exposure_minify_fpt_unival_max, + "exposure_minify", + "exposure_minify", + }, + { + SHADER_FT_SUB_EXPOSURE_MEASURE, + exposure_measure_vpt_unival_max, + exposure_measure_fpt_unival_max, + "exposure_measure", + "exposure_measure", + }, + { + SHADER_FT_SUB_EXPOSURE_AVERAGE, + exposure_average_vpt_unival_max, + exposure_average_fpt_unival_max, + "exposure_average", + "exposure_average", + }, +}; + +/*static const shader_glsl_sub_table GAUSS_table[] = { + { + SHADER_FT_SUB_PP_GAUSS, + pp_gauss_vpt_unival_max, + pp_gauss_fpt_unival_max, + "pp_gauss", + "pp_gauss", + }, +};*/ + +static const shader_glsl_sub_table GAUSS_table[] = { + { + SHADER_FT_SUB_PP_GAUSS_USUAL, + pp_gauss_usual_vpt_unival_max, + pp_gauss_usual_fpt_unival_max, + "pp_gauss_usual", + "pp_gauss_usual", + }, + { + SHADER_FT_SUB_PP_GAUSS_CONE, + pp_gauss_cone_vpt_unival_max, + pp_gauss_cone_fpt_unival_max, + "pp_gauss_cone", + "pp_gauss_cone", + }, +}; + +static const shader_glsl_sub_table SUN_table[] = { + { + SHADER_FT_SUB_SUN, + sun_vpt_unival_max, + sun_fpt_unival_max, + "sun", + "sun", + }, +}; + +static const shader_glsl_sub_table SUN_NO_TEXTURED_table[] = { + { + SHADER_FT_SUB_SUN_NO_TEXTURED, + sun_no_textured_vpt_unival_max, + sun_no_textured_fpt_unival_max, + "sun_no_textured", + "sun_no_textured", + }, +}; + +/*static const shader_glsl_sub_table FADE_table[] = { + { + SHADER_FT_SUB_FADE, + fade_vpt_unival_max, + fade_fpt_unival_max, + "fade", + "fade", + }, +};*/ + +static const shader_glsl_sub_table WATER01_table[] = { + { + SHADER_FT_SUB_WATER01, + water01_vpt_unival_max, + water01_fpt_unival_max, + "water01", + "water01", + }, +}; + +/*static const shader_glsl_sub_table WATER02_table[] = { + { + SHADER_FT_SUB_WATER02, + water02_vpt_unival_max, + water02_fpt_unival_max, + "water02", + "water02", + }, +};*/ + +/*static const shader_glsl_sub_table WATRING_table[] = { + { + SHADER_FT_SUB_WATER_RING, + water_ring_vpt_unival_max, + water_ring_fpt_unival_max, + "water_ring", + "water_ring", + }, +};*/ + +static const shader_glsl_sub_table W_PTCL_table[] = { + { + SHADER_FT_SUB_WATER_PARTICLE, + water_particle_vpt_unival_max, + water_particle_fpt_unival_max, + "water_particle", + "water_particle", + }, +}; + +/*static const shader_glsl_sub_table SNOW_PT_table[] = { + { + SHADER_FT_SUB_SNOW_PARTICLE, + snow_particle_vpt_unival_max, + snow_particle_fpt_unival_max, + "snow_particle", + "snow_particle", + }, +};*/ + +static const shader_glsl_sub_table SNOW_PT_table[] = { + { + SHADER_FT_SUB_SNOW_PARTICLE, + snow_particle_vpt_unival_max, + snow_particle_fpt_unival_max, + "snow_particle", + "snow_particle", + }, + { + SHADER_FT_SUB_SNOW_PARTICLE_CPU, + snow_particle_cpu_vpt_unival_max, + snow_particle_cpu_fpt_unival_max, + "snow_particle_cpu", + "snow_particle_cpu", + }, +}; + +static const shader_glsl_sub_table LEAF_PT_table[] = { + { + SHADER_FT_SUB_LEAF_PARTICLE, + leaf_particle_vpt_unival_max, + leaf_particle_fpt_unival_max, + "leaf_particle", + "leaf_particle", + }, +}; + +static const shader_glsl_sub_table STAR_table[] = { + { + SHADER_FT_SUB_STAR, + star_vpt_unival_max, + star_fpt_unival_max, + "star", + "star", + }, + { + SHADER_FT_SUB_STAR_MILKY_WAY, + star_milky_way_vpt_unival_max, + star_milky_way_fpt_unival_max, + "star_milky_way", + "star_milky_way", + }, +}; + +/*static const shader_glsl_sub_table SNORING_table[] = { + { + SHADER_FT_SUB_SNOW_RING, + snow_ring_vpt_unival_max, + snow_ring_fpt_unival_max, + "snow_ring", + "snow_ring", + }, +}; + +static const shader_glsl_sub_table SN_FOOT_table[] = { + { + SHADER_FT_SUB_SNOW_FOOTPRINT, + snow_footprint_vpt_unival_max, + snow_footprint_fpt_unival_max, + "snow_footprint", + "snow_footprint", + }, +}; + +static const shader_glsl_sub_table SN_TSL_table[] = { + { + SHADER_FT_SUB_SNOW_TEX_SPACE_LIGHT, + snow_tex_space_light_vpt_unival_max, + snow_tex_space_light_fpt_unival_max, + "snow_tex_space_light", + "snow_tex_space_light", + }, +}; + +static const shader_glsl_sub_table SN_NRM_table[] = { + { + SHADER_FT_SUB_SNOW_CALC_NORMAL, + snow_calc_normal_vpt_unival_max, + snow_calc_normal_fpt_unival_max, + "snow_calc_normal", + "snow_calc_normal", + }, +};*/ + +static const shader_glsl_sub_table FLOOR_table[] = { + { + SHADER_FT_SUB_FLOOR, + floor_vpt_unival_max, + floor_fpt_unival_max, + "floor", + "floor", + }, +}; + +static const shader_glsl_sub_table PUDDLE_table[] = { + { + SHADER_FT_SUB_PUDDLE, + puddle_vpt_unival_max, + puddle_fpt_unival_max, + "puddle", + "puddle", + }, +}; + +static const shader_glsl_sub_table S_REFL_table[] = { + { + SHADER_FT_SUB_SIMPLE_REFLECT, + simple_reflect_vpt_unival_max, + simple_reflect_fpt_unival_max, + "simple_reflect", + "simple_reflect", + }, +}; + +static const shader_glsl_sub_table S_REFR_table[] = { + { + SHADER_FT_SUB_SIMPLE_REFRACT, + simple_refract_vpt_unival_max, + simple_refract_fpt_unival_max, + "simple_refract", + "simple_refract", + }, +}; + +static const shader_glsl_sub_table RIPEMIT_table[] = { + { + SHADER_FT_SUB_RIPPLE_EMIT, + ripple_emit_vpt_unival_max, + ripple_emit_fpt_unival_max, + "ripple_emit", + "ripple_emit", + }, +}; + +static const shader_glsl_sub_table RAIN_table[] = { + { + SHADER_FT_SUB_RAIN, + rain_vpt_unival_max, + rain_fpt_unival_max, + "rain", + "rain", + }, +}; + +/*static const shader_glsl_sub_table VOLLIT_table[] = { + { + SHADER_FT_SUB_VOLUME_LIGHT, + volume_light_vpt_unival_max, + volume_light_fpt_unival_max, + "volume_light", + "volume_light", + }, +};*/ + +/*static const shader_glsl_sub_table FENCE_table[] = { + { + SHADER_FT_SUB_FENCE_ALPHA, + fence_alpha_vpt_unival_max, + fence_alpha_fpt_unival_max, + "fence_alpha", + "fence_alpha", + }, +};*/ + +static const shader_glsl_sub_table RIPPLE_table[] = { + { + SHADER_FT_SUB_RIPPLE, + ripple_vpt_unival_max, + ripple_fpt_unival_max, + "ripple", + "ripple", + }, +}; + +static const shader_glsl_sub_table FOGPTCL_table[] = { + { + SHADER_FT_SUB_FOG_PTCL, + fog_ptcl_vpt_unival_max, + fog_ptcl_fpt_unival_max, + "fog_ptcl", + "fog_ptcl", + }, +}; + +static const shader_glsl_sub_table PARTICL_table[] = { + { + SHADER_FT_SUB_PARTICLE, + particle_vpt_unival_max, + particle_fpt_unival_max, + "particle", + "particle", + }, +}; + +static const shader_glsl_sub_table GLITTER_PT_table[] = { + { + SHADER_FT_SUB_GLITTER_PARTICLE, + glitter_particle_vpt_unival_max, + glitter_particle_fpt_unival_max, + "glitter_particle", + "glitter_particle", + }, +}; + +/*static const shader_glsl_sub_table SHOW_VEC_table[] = { + { + SHADER_FT_SUB_SHOW_VECTOR, + show_vector_vpt_unival_max, + show_vector_fpt_unival_max, + "show_vector", + "show_vector", + }, +};*/ + +static const shader_glsl_sub_table FONT_table[] = { + { + SHADER_FT_SUB_FONT, + font_vpt_unival_max, + font_fpt_unival_max, + "font", + "font", + }, +}; + +static const shader_glsl_sub_table MOVIE_table[] = { + { + SHADER_FT_SUB_MOVIE, + movie_vpt_unival_max, + movie_fpt_unival_max, + "movie", + "movie", + }, +}; + +/*static const shader_glsl_sub_table IMGFILT_table[] = { + { + SHADER_FT_SUB_IMGFILTER, + imgfilter_vpt_unival_max, + imgfilter_fpt_unival_max, + "imgfilter", + "imgfilter", + }, +};*/ + +static const shader_glsl_sub_table IMGFILT_table[] = { + { + SHADER_FT_SUB_BOX4, + box4_vpt_unival_max, + box4_fpt_unival_max, + "box4", + "box4", + }, + { + SHADER_FT_SUB_BOX8, + box8_vpt_unival_max, + box8_fpt_unival_max, + "box8", + "box8", + }, + { + SHADER_FT_SUB_COPY, + copy_vpt_unival_max, + copy_fpt_unival_max, + "copy", + "copy", + }, +}; + +static const shader_glsl_sub_table SPRITE_table[] = { + { + SHADER_FT_SUB_SPRITE, + sprite_vpt_unival_max, + sprite_fpt_unival_max, + "sprite", + "sprite", + }, +}; + +static const uniform_name BLINN_uniform[] = { + //U16, // 0th removed + U_BONE_MAT, + U_TEXTURE_COUNT, + U_LIGHT_0, + U_NORMAL, + U_SPECULAR, + U_ENV_MAP, + U_FOG_HEIGHT, + U_MORPH, + U_MORPH_COLOR, + U_LIGHT_1, + U_ALPHA_TEST, // 11th added +}; + +static const uniform_name ITEM_uniform[] = { + //U16, // 0th removed + U_BONE_MAT, + U_MORPH, + U_SPECULAR_IBL, + U_SPECULAR, + U_NORMAL, + U_TEXTURE_COUNT, + U_ENV_MAP, + U_SELF_SHADOW, + U_FOG, + U_ALPHA_TEST, + U_SHADOW, + U_CHARA_COLOR, + U_TONE_CURVE, +}; + +static const uniform_name STAGE_uniform[] = { + //U16, // 0th removed + U_BONE_MAT, + U_MORPH, + U_MORPH_COLOR, + U_TEXTURE_COUNT, + U_ENV_MAP, + U_LIGHT_0, + U_NORMAL, + U_FOG_HEIGHT, + U_LIGHT_1, + U12, + U_ALPHA_TEST, // 11th added +}; + +static const uniform_name SKIN_uniform[] = { + //U16, // 0th removed + U_BONE_MAT, + U_NORMAL, + U_SELF_SHADOW, + U_FOG, + U_ALPHA_TEST, + U_SHADOW, + U_NPR, + U_CHARA_COLOR, + U_TONE_CURVE, +}; + +static const uniform_name SSS_SKIN_uniform[] = { + //U16, // 0th removed + U_BONE_MAT, + U37, + U_ALPHA_TEST, + U_SELF_SHADOW, + U_SHADOW, + U_NPR, + U26, +}; + +static const uniform_name SSS_FILT_uniform[] = { + //U16, // 0th removed + U_SSS_FILTER, + U_NPR, +}; + +static const uniform_name HAIR_uniform[] = { + //U16, // 0th removed + U_BONE_MAT, + U_SPECULAR_IBL, + U_SPECULAR, + U_NORMAL, + U_TRANSPARENCY, + U_TRANSLUCENCY, + U_ANISO, + U_SELF_SHADOW, + U_FOG, + U_SHADOW, + U_NPR, + U_CHARA_COLOR, + U_TONE_CURVE, + U_ALPHA_TEST, // 14th added +}; + +static const uniform_name CLOTH_uniform[] = { + //U16, // 0th removed + U_BONE_MAT, + U_SPECULAR_IBL, + U_SPECULAR, + U_NORMAL, + U_TRANSPARENCY, + U_ENV_MAP, + U_SELF_SHADOW, + U_FOG, + U_ALPHA_TEST, + U_ANISO, + U_SHADOW, + U_NPR, + U_CHARA_COLOR, + U_TONE_CURVE, +}; + +static const uniform_name TIGHTS_uniform[] = { + //U16, // 0th removed + U_BONE_MAT, + U_SPECULAR, + U_ENV_MAP, + U_SELF_SHADOW, + U_FOG, + U_ALPHA_TEST, + U_SHADOW, + U_NPR, + U_CHARA_COLOR, + U_TONE_CURVE, +}; + +static const uniform_name SKY_uniform[] = { + U_TEX_0_TYPE, + U_TEX_1_TYPE, + U_TEXTURE_COUNT, + U_MORPH, + U_MORPH_COLOR, + U_FOG_HEIGHT, + U_ALPHA_TEST, // 6th added +}; + +/*static const uniform_name EYEBALL_uniform[] = { + U_BONE_MAT, + U_ENV_MAP, +};*/ + +/*static const uniform_name EYELENS_uniform[] = { + U_BONE_MAT, + U_SPECULAR, + U_ENV_MAP, +};*/ + +static const uniform_name GLASEYE_uniform[] = { + //U16, // 0th removed + U_BONE_MAT, + U_SELF_SHADOW, + U_FOG, + U18, + U_SHADOW, + U_CHARA_COLOR, + U_TONE_CURVE, +}; + +/*static const uniform_name MEMBRAN_uniform[] = { + U_BONE_MAT, + U_NORMAL, + U_MEMBRANE, +};*/ + +/*static const uniform_name SHDMAP_uniform[] = { + U_BONE_MAT, + U_TEXTURE_COUNT, + U_TRANSPARENCY, + U_LIGHT_1, + U2D, +};*/ + +/*static const uniform_name ESM_uniform[] = { + //U16, // 0th removed + U_BONE_MAT, + U_TEXTURE_COUNT, + U_TRANSPARENCY, +};*/ + +static const uniform_name ESMGAUSS_uniform[] = { + U_LIGHT_PROJ, +}; + +static const uniform_name ESMFILT_uniform[] = { + U_ESM_FILTER, +}; + +static const uniform_name LITPROJ_uniform[] = { + //U16, // 0th removed + U_BONE_MAT, + U_SPECULAR, + U_NORMAL, + U_TEXTURE_COUNT, + U_TRANSPARENCY, +}; + +static const uniform_name SIMPLE_uniform[] = { + //U16, // 0th removed + U_BONE_MAT, + U_TEXTURE_COUNT, + //U_NORMAL, // 3rd removed + //U_INSTANCE, // 4th removed + //U2E, // 5th removed +}; + +static const uniform_name SIL_uniform[] = { + //U16, // 0th removed + U_BONE_MAT, + U_TRANSPARENCY, + U_TEXTURE_COUNT, + U_MORPH, + U_MORPH_COLOR, + U0A, + U_ALPHA_TEST, // 7th added +}; + +static const uniform_name LAMBERT_uniform[] = { + //U16, // 0th removed + U_BONE_MAT, + U_TEXTURE_COUNT, + U_LIGHT_0, + U_FOG_HEIGHT, + U_MORPH, + U_MORPH_COLOR, + U_LIGHT_1, + U_ALPHA_TEST, // 8th added +}; + +static const uniform_name CONSTANT_uniform[] = { + //U16, // 0th removed + U_BONE_MAT, + U_TEXTURE_COUNT, + U_FOG_HEIGHT, + U_MORPH, + U_MORPH_COLOR, + U_ALPHA_TEST, // 6th added +}; + +/*static const uniform_name PEEL_uniform[] = { + U_DEPTH_PEEL, + U_BONE_MAT, +};*/ + +static const uniform_name TONEMAP_uniform[] = { + //U16, // 0th removed + U_TONE_MAP, + U_FLARE, + U_SCENE_FADE, + U_AET_BACK, + U_LIGHT_PROJ, + U_NPR, + //U25, 7th removed +}; + +static const uniform_name REDUCE_uniform[] = { + U_REDUCE, + U_ALPHA_MASK, +}; + +static const uniform_name MAGNIFY_uniform[] = { + U_MAGNIFY, +}; + +static const uniform_name MLAA_uniform[] = { + //U16, // 0th removed + U_ALPHA_MASK, + U_MLAA, + U_MLAA_SEARCH, +}; + +static const uniform_name CONTOUR_uniform[] = { + //U16, // 0th removed + U24, +}; + +static const uniform_name CONTOUR_NPR_uniform[] = { + U_INVALID, +}; + +static const uniform_name EXPOSURE_uniform[] = { + U_EXPOSURE, +}; + +static const uniform_name GAUSS_uniform[] = { + U_GAUSS, +}; + +static const uniform_name SUN_uniform[] = { + U_INVALID, +}; + +static const uniform_name SUN_NO_TEXTURED_uniform[] = { + U_INVALID, +}; + +/*static const uniform_name FADE_uniform[] = { + U_FADE, +};*/ + +static const uniform_name WATER01_uniform[] = { + U_MORPH, + U_MORPH_COLOR, + U_TEXTURE_COUNT, + U_NORMAL, + U_WATER_REFLECT, + U_ENV_MAP, + U_SPECULAR, + U_FOG_HEIGHT, +}; + +/*static const uniform_name WATER02_uniform[] = { + U_INVALID, +};*/ + +/*static const uniform_name WATRING_uniform[] = { + U_LIGHT_0, + U_LIGHT_1, +};*/ + +static const uniform_name W_PTCL_uniform[] = { + U_INVALID, +}; + +static const uniform_name SNOW_PT_uniform[] = { + U_SNOW_PARTICLE, +}; + +static const uniform_name LEAF_PT_uniform[] = { + U_INVALID, +}; + +static const uniform_name STAR_uniform[] = { + U_STAR, +}; + +/*static const uniform_name SNORING_uniform[] = { + U_TEXTURE_COUNT, + U_NORMAL, + U_SPECULAR, + U_LIGHT_0, + U_LIGHT_1, +}; + +static const uniform_name SN_FOOT_uniform[] = { + U_INVALID, +}; + +static const uniform_name SN_TSL_uniform[] = { + U_INVALID, +}; + +static const uniform_name SN_NRM_uniform[] = { + U_INVALID, +};*/ + +static const uniform_name FLOOR_uniform[] = { + U_TEXTURE_COUNT, + U_NORMAL, + U_LIGHT_0, + U_LIGHT_1, + U_FOG_HEIGHT, + U_MORPH, + U_MORPH_COLOR, + U_ALPHA_TEST, // 7th added +}; + +static const uniform_name PUDDLE_uniform[] = { + U_NORMAL, + U_LIGHT_0, + U_LIGHT_1, + U_FOG_HEIGHT, +}; + +static const uniform_name S_REFL_uniform[] = { + //U16, // 0th removed + U_BONE_MAT, + U_REFLECT, + U_MORPH, + U_MORPH_COLOR, + U_ALPHA_TEST, + U_CLIP_PLANE, + U_TEXTURE_COUNT, + U_TONE_CURVE, + U_CHARA_COLOR, +}; + +static const uniform_name S_REFR_uniform[] = { + U_BONE_MAT, + U_TRANSPARENCY, +}; + +static const uniform_name RIPEMIT_uniform[] = { + U_RIPPLE, + U_RIPPLE_EMIT, +}; + +static const uniform_name RAIN_uniform[] = { + U_INVALID, +}; + +/*static const uniform_name VOLLIT_uniform[] = { + U_INVALID, +};*/ + +/*static const uniform_name FENCE_uniform[] = { + U_INSTANCE, + U_FOG_HEIGHT, +};*/ + +static const uniform_name RIPPLE_uniform[] = { + U_RIPPLE, +}; + +static const uniform_name FOGPTCL_uniform[] = { + U_INVALID, +}; + +static const uniform_name PARTICL_uniform[] = { + U_INVALID, +}; + +static const uniform_name GLITTER_PT_uniform[] = { + U_TEXTURE_COUNT, + U_TEXTURE_BLEND, + U_FOG_HEIGHT, + U_ALPHA_BLEND, +}; + +/*static const uniform_name SHOW_VEC_uniform[] = { + //U16, // 0th removed + U_BONE_MAT, + U_SHOW_VECTOR, +};*/ + +static const uniform_name FONT_uniform[] = { + //U16, // 0th removed + U_INVALID, // 0th removed, 1st added +}; + +static const uniform_name MOVIE_uniform[] = { + U_MOVIE, +}; + +static const uniform_name IMGFILT_uniform[] = { + U_IMAGE_FILTER, +}; + +static const uniform_name SPRITE_uniform[] = { + U_TEX_0_TYPE, + U_TEX_1_TYPE, + U_COMBINER, +}; + +static const bool BLINN_permut[] = { + // true, // 0th removed + true, + false, + false, + false, + false, + false, + false, + true, + true, + false, + false, // 11th added +}; + +static const bool ITEM_permut[] = { + //true, // 0th removed + true, + true, + false, + false, + false, + false, + false, + false, + false, + false, + false, + false, + false, +}; + +static const bool STAGE_permut[] = { + //true, // 0th removed + true, + true, + true, + false, + false, + false, + false, + false, + false, + false, + false, // 11th added +}; + +static const bool SKIN_permut[] = { + //true, // 0th removed + true, + false, + false, + false, + false, + false, + false, + false, + false, +}; + +static const bool SSS_SKIN_permut[] = { + //true, // 0th removed + true, + false, + false, + false, + false, + false, + false, +}; + +static const bool SSS_FILT_permut[] = { + //true, // 0th removed + true, + true, +}; + +static const bool HAIR_permut[] = { + //true, // 0th removed + true, + false, + false, + false, + false, + false, + false, + false, + false, + false, + false, + false, + false, + false, // 14th added +}; + +static const bool CLOTH_permut[] = { + //true, // 0th removed + true, + false, + false, + false, + false, + false, + false, + false, + false, + false, + false, + false, + false, + false, +}; + +static const bool TIGHTS_permut[] = { + //true, // 0th removed + true, + false, + false, + false, + false, + false, + false, + false, + false, + false, +}; + +static const bool SKY_permut[] = { + false, + false, + false, + true, + true, + false, + false, // 6th added +}; + +/*static const bool EYEBALL_permut[] = { + true, + false, +};*/ + +/*static const bool EYELENS_permut[] = { + true, + false, + false, +};*/ + +static const bool GLASEYE_permut[] = { + //true, // 0th removed + true, + false, + false, + false, + false, + false, + false, +}; + +/*static const bool MEMBRAN_permut[] = { + true, + false, + false, +};*/ + +/*static const bool SHDMAP_permut[] = { + true, + false, + false, + false, + true, +};*/ + +/*static const bool ESM_permut[] = { + //true, // 0th removed + true, + false, + false, +};*/ + +static const bool ESMGAUSS_permut[] = { + true, +}; + +static const bool ESMFILT_permut[] = { + true, +}; + +static const bool LITPROJ_permut[] = { + //true, // 0th removed + true, + false, + false, + false, + false, +}; + +static const bool SIMPLE_permut[] = { + //true, // 0th removed + true, + false, + //false, // 3rd removed + //false, // 4th removed + //false, // 5th removed +}; + +static const bool SIL_permut[] = { + //true, // 0th removed + true, + false, + false, + true, + false, + false, + false, // 7th added +}; + +static const bool LAMBERT_permut[] = { + //true, // 0th removed + true, + false, + false, + false, + true, + true, + false, + false, // 8th added +}; + +static const bool CONSTANT_permut[] = { + //true, // 0th removed + true, + false, + false, + true, + true, + false, // 6th added +}; + +/*static const bool PEEL_permut[] = { + false, + true, +};*/ + +static const bool TONEMAP_permut[] = { + //true, // 0th removed + false, + false, + false, + false, + false, + false, + false, +}; + +static const bool REDUCE_permut[] = { + true, + true, +}; + +static const bool MAGNIFY_permut[] = { + true, +}; + +static const bool MLAA_permut[] = { + //true, // 0th removed + true, + true, + true, +}; + +static const bool CONTOUR_permut[] = { + //true, // 0th removed + false, +}; + +static const bool CONTOUR_NPR_permut[] = { + false, +}; + +static const bool EXPOSURE_permut[] = { + true, +}; + +static const bool GAUSS_permut[] = { + true, +}; + +static const bool SUN_permut[] = { + false, +}; + +static const bool SUN_NO_TEXTURED_permut[] = { + false, +}; + +/*static const bool FADE_permut[] = { + false, +};*/ + +static const bool WATER01_permut[] = { + true, + true, + false, + false, + false, + false, + false, + false, +}; + +static const bool WATER02_permut[] = { + false, +}; + +/*static const bool WATRING_permut[] = { + false, + false, +};*/ + +static const bool W_PTCL_permut[] = { + false, +}; + +static const bool SNOW_PT_permut[] = { + false, +}; + +static const bool LEAF_PT_permut[] = { + false, +}; + +static const bool STAR_permut[] = { + false, +}; + +/*static const bool SNORING_permut[] = { + false, + false, + false, + false, + false, +}; + +static const bool SN_FOOT_permut[] = { + false, +}; + +static const bool SN_TSL_permut[] = { + false, +}; + +static const bool SN_NRM_permut[] = { + false, +};*/ + +static const bool FLOOR_permut[] = { + false, + false, + false, + false, + false, + true, + true, + false, // 7th added +}; + +static const bool PUDDLE_permut[] = { + false, + false, + false, + false, +}; + +static const bool S_REFL_permut[] = { + //true, // 0th removed + true, + true, + true, + true, + false, + false, + false, + false, + false, +}; + +static const bool S_REFR_permut[] = { + true, + false, +}; + +static const bool RIPEMIT_permut[] = { + true, + true, +}; + +static const bool RAIN_permut[] = { + false, +}; + +/*static const bool VOLLIT_permut[] = { + false, +};*/ + +/*static const bool FENCE_permut[] = { + false, + false, +};*/ + +static const bool RIPPLE_permut[] = { + true, +}; + +static const bool FOGPTCL_permut[] = { + false, +}; + +static const bool PARTICL_permut[] = { + false, +}; + +static const bool GLITTER_PT_permut[] = { + false, + false, + false, + false, +}; + +/*static const bool SHOW_VEC_permut[] = { + //true, // 0th removed + false, + false, +};*/ + +static const bool FONT_permut[] = { + //true, // 0th removed + false, // 0th removed, 1st added +}; + +static const bool MOVIE_permut[] = { + true, +}; + +static const bool IMGFILT_permut[] = { + false, +}; + +static const bool SPRITE_permut[] = { + false, + false, + false, +}; + +struct glass_eye_struct { + vec4 field_0; + vec4 field_10; + float_t field_20; + float_t field_24; + float_t field_28; + float_t field_2C; + vec3 field_30; + vec3 field_3C; + vec3 field_48; + float_t field_54; + vec3 field_58; + float_t field_64; + vec3 field_68; + vec3 field_74; + vec3 field_80; + float_t field_8C; + vec3 field_90; + uint32_t frame; + vec4 field_A0; + bool field_B0; + bool field_B1; + bool field_B2; + bool field_B3; + int32_t field_B4; + int32_t field_B8; + int32_t field_BC; +}; + +#define shader_table_struct(n) \ +{ \ + #n, \ + SHADER_FT_##n, \ + sizeof(n##_table) / sizeof(shader_glsl_sub_table), \ + n##_table, \ + sizeof(n##_uniform) / sizeof(uniform_name), \ + n##_uniform, \ + n##_permut, \ +} + +const shader_glsl_table shader_ft_table[] = { + { + "SHADER_FFP", + SHADER_FT_FFP, + 0, + 0, + 0, + 0, + 0, + }, + shader_table_struct(BLINN), + shader_table_struct(ITEM), + shader_table_struct(STAGE), + shader_table_struct(SKIN), + shader_table_struct(SSS_SKIN), + shader_table_struct(SSS_FILT), + shader_table_struct(HAIR), + shader_table_struct(CLOTH), + shader_table_struct(TIGHTS), + shader_table_struct(SKY), + //shader_table_struct(EYEBALL), + //shader_table_struct(EYELENS), + shader_table_struct(GLASEYE), + //shader_table_struct(MEMBRAN), + //shader_table_struct(SHDMAP), + //shader_table_struct(ESM), + shader_table_struct(ESMGAUSS), + shader_table_struct(ESMFILT), + shader_table_struct(LITPROJ), + shader_table_struct(SIMPLE), + shader_table_struct(SIL), + shader_table_struct(LAMBERT), + shader_table_struct(CONSTANT), + //shader_table_struct(PEEL), + shader_table_struct(TONEMAP), + shader_table_struct(REDUCE), + shader_table_struct(MAGNIFY), + shader_table_struct(MLAA), + shader_table_struct(CONTOUR), + shader_table_struct(CONTOUR_NPR), + shader_table_struct(EXPOSURE), + shader_table_struct(GAUSS), + shader_table_struct(SUN), + shader_table_struct(SUN_NO_TEXTURED), + //shader_table_struct(FADE), + shader_table_struct(WATER01), + //shader_table_struct(WATER02), + //shader_table_struct(WATRING), + shader_table_struct(W_PTCL), + shader_table_struct(SNOW_PT), + shader_table_struct(LEAF_PT), + shader_table_struct(STAR), + /*shader_table_struct(SNORING), + shader_table_struct(SN_FOOT), + shader_table_struct(SN_TSL), + shader_table_struct(SN_NRM),*/ + shader_table_struct(FLOOR), + shader_table_struct(PUDDLE), + shader_table_struct(S_REFL), + shader_table_struct(S_REFR), + shader_table_struct(RIPEMIT), + shader_table_struct(RAIN), + //shader_table_struct(VOLLIT), + //shader_table_struct(FENCE), + shader_table_struct(RIPPLE), + shader_table_struct(FOGPTCL), + shader_table_struct(PARTICL), + shader_table_struct(GLITTER_PT), + //shader_table_struct(SHOW_VEC), + shader_table_struct(FONT), + shader_table_struct(MOVIE), + shader_table_struct(IMGFILT), + shader_table_struct(SPRITE), +}; + +#undef shader_table_struct +#undef shader_table_struct + +const size_t shader_ft_table_size = + sizeof(shader_ft_table) / sizeof(shader_glsl_table); + +static void glass_eye_calc(glass_eye_struct* glass_eye); +static void glass_eye_set(glass_eye_struct* glass_eye); +static void shader_bind_blinn(shader_glsl_set_data* set, shader_glsl* shad); +static void shader_bind_cloth(shader_glsl_set_data* set, shader_glsl* shad); +static void shader_bind_hair(shader_glsl_set_data* set, shader_glsl* shad); +static void shader_bind_eye_ball(shader_glsl_set_data* set, shader_glsl* shad); +static void shader_bind_tone_map(shader_glsl_set_data* set, shader_glsl* shad); +static void shader_bind_sss_filter(shader_glsl_set_data* set, shader_glsl* shad); // Added +static void shader_bind_esm_filter(shader_glsl_set_data* set, shader_glsl* shad); // Added +static void shader_bind_reduce_tex(shader_glsl_set_data* set, shader_glsl* shad); // Added +static void shader_bind_magnify(shader_glsl_set_data* set, shader_glsl* shad); // Added +static void shader_bind_mlaa(shader_glsl_set_data* set, shader_glsl* shad); // Added +static void shader_bind_exposure(shader_glsl_set_data* set, shader_glsl* shad); // Added +static void shader_bind_gauss(shader_glsl_set_data* set, shader_glsl* shad); // Added +static void shader_bind_snow_particle(shader_glsl_set_data* set, shader_glsl* shad); // Added +static void shader_bind_star(shader_glsl_set_data* set, shader_glsl* shad); // Added +static void shader_bind_imgfilter(shader_glsl_set_data* set, shader_glsl* shad); // Added + +const shader_glsl_bind_func shader_ft_bind_func_table[] = { + { + SHADER_FT_BLINN, + shader_bind_blinn, + }, + { + SHADER_FT_CLOTH, + shader_bind_cloth, + }, + { + SHADER_FT_HAIR, + shader_bind_hair, + }, + { + //SHADER_FT_EYEBALL, + SHADER_FT_GLASEYE, + shader_bind_eye_ball, + }, + { + SHADER_FT_TONEMAP, + shader_bind_tone_map, + }, + { // Added + SHADER_FT_SSS_FILT, + shader_bind_sss_filter, + }, + { // Added + SHADER_FT_ESMFILT, + shader_bind_esm_filter, + }, + { // Added + SHADER_FT_REDUCE, + shader_bind_reduce_tex, + }, + { // Added + SHADER_FT_MAGNIFY, + shader_bind_magnify, + }, + { // Added + SHADER_FT_MLAA, + shader_bind_mlaa, + }, + { // Added + SHADER_FT_EXPOSURE, + shader_bind_exposure, + }, + { // Added + SHADER_FT_GAUSS, + shader_bind_gauss, + }, + { // Added + SHADER_FT_SNOW_PT, + shader_bind_snow_particle, + }, + { // Added + SHADER_FT_STAR, + shader_bind_star, + }, + { // Added + SHADER_FT_IMGFILT, + shader_bind_imgfilter, + }, +}; + +const size_t shader_ft_bind_func_table_size = + sizeof(shader_ft_bind_func_table) / sizeof(shader_glsl_bind_func); + +shader_glsl_set_data shaders_ft; + +static glass_eye_struct glass_eye = { + { 5.0f, 5.0f, 0.5f, 0.5f }, + { 2.5f, 2.5f, 0.5f, 0.5f }, + 1.0f, + 1.45f, + 0.02f, + 0.85f, + { 1.0f, 1.2f, 0.45f }, + { 1.0f, 1.2f, 0.25f }, + { 0.5f, 0.6f, 0.4f }, + -0.2f, + { 1.0f, 1.0f, 1.0f }, + 0.0f, + { 0.0f, 0.0f, 0.0f }, + { 0.0f, 0.0f, 0.0f }, + { 0.0f, 0.0f, 0.0f }, + 0.0, + { 0.0f, 0.0f, 0.0f }, + 0, + { 0.0f, 0.0f, 0.0f, 0.0f }, + 0, + 0, + 0, + 0, + 0, + 0, + 0, +}; + +int32_t shader_ft_get_index_by_name(const char* name) { + if (!str_utils_compare(name, "EYEBALL")) + return SHADER_FT_GLASEYE; + return -1; +} + +static void glass_eye_calc(glass_eye_struct* glass_eye) { + float_t v2 = glass_eye->field_28; + glass_eye->field_64 = glass_eye->field_2C / v2; + glass_eye->field_90 = glass_eye->field_58; + glass_eye->field_68 = glass_eye->field_30 * v2; + glass_eye->field_74 = glass_eye->field_3C * v2; + glass_eye->field_80 = glass_eye->field_48 * v2; + glass_eye->field_8C = glass_eye->field_54 * v2; + if (glass_eye->field_B0 == 0) { + glass_eye->field_A0 = 0.0f; + return; + } + + uint32_t(FASTCALL * get_frame_counter)() = (uint32_t(FASTCALL*)())0x0000000140192E00; + + uint32_t frame = get_frame_counter(); + if (frame == glass_eye->frame) + return; + + glass_eye->frame = frame; + if (frame == (frame / 90) * 90) { + float_t(FASTCALL * rand_state_array_get_float)(int32_t index) = (float_t(FASTCALL*)(int32_t index))0x00000001404FFE60; + glass_eye->field_A0.x = (rand_state_array_get_float(0) - 0.5f) * 0.015f; + glass_eye->field_A0.y = (rand_state_array_get_float(0) - 0.5f) * 0.015f; + } + + float_t v17 = (float_t)(uint8_t)frame * (float_t)(M_PI * (1.0 / 128.0)); + float_t v19 = sinf(sinf(v17 * 27.0f) + v17 * 2.0f); + float_t v20 = sinf(v17 * 23.0f); + glass_eye->field_A0.w = 0.0f; + glass_eye->field_A0.z = (v19 + v20) * 0.5f * 0.01f; +} + +static void glass_eye_set(glass_eye_struct* glass_eye) { + glass_eye_batch_shader_data glass_eye_batch = {}; + + vec4 temp; + *(vec3*)&temp = glass_eye->field_68 * glass_eye->field_68; + temp.w = temp.z; + *(vec3*)&temp = vec3::rcp(*(vec3*)&temp); + glass_eye_batch.g_ellipsoid_radius = temp; + + *(vec3*)&temp = glass_eye->field_68; + temp.w = 1.0f; + glass_eye_batch.g_ellipsoid_scale = temp; + + glass_eye_batch.g_tex_model_param = glass_eye->field_0; + glass_eye_batch.g_tex_offset = glass_eye->field_A0; + + *(vec3*)&temp = glass_eye->field_90 * glass_eye->field_90; + temp.w = temp.z; + *(vec3*)&temp = vec3::rcp(*(vec3*)&temp); + glass_eye_batch.g_eb_radius = temp; + + glass_eye_batch.g_eb_tex_model_param = glass_eye->field_10; + + float_t v2 = (glass_eye->field_20 - glass_eye->field_24) / (glass_eye->field_20 + glass_eye->field_24); + v2 *= v2; + glass_eye_batch.g_fresnel = { 1.0f - v2, v2, 0.0f, 0.0f }; + + float_t v3 = (glass_eye->field_20 * glass_eye->field_20) / (glass_eye->field_24 * glass_eye->field_24); + glass_eye_batch.g_refract1 = { v3, 1.0f - v3, glass_eye->field_20 / glass_eye->field_24, 0.0f }; + + float_t v4 = (glass_eye->field_24 * glass_eye->field_24) / (glass_eye->field_20 * glass_eye->field_20); + glass_eye_batch.g_refract2 = { v4, 1.0f - v4, glass_eye->field_24 / glass_eye->field_20, 0.0f }; + + *(vec3*)&temp = glass_eye->field_74 * glass_eye->field_74; + temp.w = -1.0f; + *(vec3*)&temp = vec3::rcp(*(vec3*)&temp); + glass_eye_batch.g_iris_radius = temp; + + *(vec3*)&temp = glass_eye->field_68 * glass_eye->field_68; + temp.w = -1.0f; + *(vec3*)&temp = vec3::rcp(*(vec3*)&temp); + glass_eye_batch.g_cornea_radius = temp; + + *(vec3*)&temp = glass_eye->field_80 * glass_eye->field_80; + temp.w = -1.0f; + *(vec3*)&temp = vec3::rcp(*(vec3*)&temp); + glass_eye_batch.g_pupil_radius = temp; + + *(vec2*)&temp = *(vec2*)&glass_eye->field_0 * *(vec2*)&glass_eye->field_74; + temp.z = glass_eye->field_64 * 1.442695f; + temp.w = glass_eye->field_8C; + *(vec2*)&temp = vec2::rcp(*(vec2*)&temp); + glass_eye_batch.g_tex_scale = temp; + + rctx->glass_eye_batch_ubo.WriteMemory(glass_eye_batch); + rctx->glass_eye_batch_ubo.Bind(4); +} + +static void shader_bind_blinn(shader_glsl_set_data* set, shader_glsl* shad) { + shad->bind(set, uniform->arr[U_NORMAL] + ? SHADER_FT_SUB_BLINN_FRAG : SHADER_FT_SUB_BLINN_VERT); +} + +static void shader_bind_cloth(shader_glsl_set_data* set, shader_glsl* shad) { + shad->bind(set, uniform->arr[U_NPR] ? SHADER_FT_SUB_CLOTH_NPR1 + : (uniform->arr[U_ANISO] ? SHADER_FT_SUB_CLOTH_ANISO : SHADER_FT_SUB_CLOTH_DEFAULT)); +} + +static void shader_bind_hair(shader_glsl_set_data* set, shader_glsl* shad) { + shad->bind(set, uniform->arr[U_NPR] ? SHADER_FT_SUB_HAIR_NPR1 : SHADER_FT_SUB_HAIR_DEFAULT); +} + +static void shader_bind_eye_ball(shader_glsl_set_data* set, shader_glsl* shad) { + uniform->arr[U18] = 0; + if (set->shaders[SHADER_FT_GLASEYE].bind(set, SHADER_FT_SUB_GLASS_EYE) >= 0) { + glass_eye_calc(&glass_eye); + glass_eye_set(&glass_eye); + } +} + +static void shader_bind_tone_map(shader_glsl_set_data* set, shader_glsl* shad) { + shad->bind(set, uniform->arr[U_NPR] == 1 + ? SHADER_FT_SUB_TONEMAP_NPR1 : SHADER_FT_SUB_TONEMAP); +} + +static void shader_bind_sss_filter(shader_glsl_set_data* set, shader_glsl* shad) { // Added + switch (uniform->arr[U_SSS_FILTER]) { + case 0: + shad->bind(set, uniform->arr[U_NPR] + ? SHADER_FT_SUB_SSS_FILTER_MIN_NPR : SHADER_FT_SUB_SSS_FILTER_MIN); + break; + case 3: + shad->bind(set, SHADER_FT_SUB_SSS_FILTER_GAUSS_2D); + break; + } +} + +static void shader_bind_esm_filter(shader_glsl_set_data* set, shader_glsl* shad) { // Added + switch (uniform->arr[U_ESM_FILTER]) { + case 0: + shad->bind(set, SHADER_FT_SUB_ESM_FILTER_MIN); + break; + case 1: + shad->bind(set, SHADER_FT_SUB_ESM_FILTER_EROSION); + break; + } +} + +static void shader_bind_reduce_tex(shader_glsl_set_data* set, shader_glsl* shad) { // Added + switch (uniform->arr[U_REDUCE]) { + case 0: + switch (uniform->arr[U_ALPHA_MASK]) { + case 0: + shad->bind(set, SHADER_FT_SUB_REDUCE_TEX_REDUCE_2); + break; + default: + shad->bind(set, SHADER_FT_SUB_REDUCE_TEX_REDUCE_2_ALPHAMASK); + break; + } + break; + case 1: + switch (uniform->arr[U_ALPHA_MASK]) { + case 0: + shad->bind(set, SHADER_FT_SUB_REDUCE_TEX_REDUCE_4); + break; + } + break; + case 3: + switch (uniform->arr[U_ALPHA_MASK]) { + case 0: + shad->bind(set, SHADER_FT_SUB_REDUCE_TEX_REDUCE_4_EXTRACT); + break; + } + break; + case 4: + switch (uniform->arr[U_ALPHA_MASK]) { + case 0: + shad->bind(set, SHADER_FT_SUB_GHOST); + break; + } + break; + case 5: + switch (uniform->arr[U_ALPHA_MASK]) { + case 0: + shad->bind(set, SHADER_FT_SUB_REDUCE_TEX_REDUCE_COMPOSITE_2); + break; + } + break; + case 6: + switch (uniform->arr[U_ALPHA_MASK]) { + case 0: + shad->bind(set, SHADER_FT_SUB_REDUCE_TEX_REDUCE_COMPOSITE_BLUR); + break; + } + break; + case 7: + switch (uniform->arr[U_ALPHA_MASK]) { + case 0: + shad->bind(set, SHADER_FT_SUB_REDUCE_TEX_REDUCE_COMPOSITE_4); + break; + } + break; + } +} + +static void shader_bind_magnify(shader_glsl_set_data* set, shader_glsl* shad) { // Added + switch (uniform->arr[U_MAGNIFY]) { + case 0: + shad->bind(set, SHADER_FT_SUB_MAGNIFY_LINEAR); + break; + case 2: + shad->bind(set, SHADER_FT_SUB_MAGNIFY_DIFF); + break; + case 3: + shad->bind(set, SHADER_FT_SUB_MAGNIFY_DIFF2); + break; + case 4: + shad->bind(set, SHADER_FT_SUB_MAGNIFY_CONE); + break; + case 5: + shad->bind(set, SHADER_FT_SUB_MAGNIFY_CONE2); + break; + } +} + +static void shader_bind_mlaa(shader_glsl_set_data* set, shader_glsl* shad) { // Added + switch (uniform->arr[U_MLAA]) { + case 0: + shad->bind(set, SHADER_FT_SUB_MLAA_EDGE); + break; + case 1: + shad->bind(set, SHADER_FT_SUB_MLAA_AREA); + break; + case 2: + shad->bind(set, SHADER_FT_SUB_MLAA_BLEND); + break; + } +} + +static void shader_bind_exposure(shader_glsl_set_data* set, shader_glsl* shad) { // Added + switch (uniform->arr[U_EXPOSURE]) { + case 0: + shad->bind(set, SHADER_FT_SUB_EXPOSURE_MINIFY); + break; + case 1: + shad->bind(set, SHADER_FT_SUB_EXPOSURE_MEASURE); + break; + case 2: + shad->bind(set, SHADER_FT_SUB_EXPOSURE_AVERAGE); + break; + } +} + +static void shader_bind_gauss(shader_glsl_set_data* set, shader_glsl* shad) { // Added + switch (uniform->arr[U_GAUSS]) { + case 0: + shad->bind(set, SHADER_FT_SUB_PP_GAUSS_USUAL); + break; + case 1: + shad->bind(set, SHADER_FT_SUB_PP_GAUSS_CONE); + break; + } +} + +static void shader_bind_snow_particle(shader_glsl_set_data* set, shader_glsl* shad) { // Added + switch (uniform->arr[U_SNOW_PARTICLE]) { + case 0: + shad->bind(set, SHADER_FT_SUB_SNOW_PARTICLE_CPU); + break; + case 1: + shad->bind(set, SHADER_FT_SUB_SNOW_PARTICLE); + break; + } +} + +static void shader_bind_star(shader_glsl_set_data* set, shader_glsl* shad) { // Added + switch (uniform->arr[U_STAR]) { + case 0: + shad->bind(set, SHADER_FT_SUB_STAR); + break; + case 1: + shad->bind(set, SHADER_FT_SUB_STAR_MILKY_WAY); + break; + } +} + +static void shader_bind_imgfilter(shader_glsl_set_data* set, shader_glsl* shad) { + switch (uniform->arr[U_IMAGE_FILTER]) { + case 0: + shad->bind(set, SHADER_FT_SUB_BOX4); + break; + case 1: + shad->bind(set, SHADER_FT_SUB_BOX8); + break; + case 5: + shad->bind(set, SHADER_FT_SUB_COPY); + break; + } +} diff --git a/src/DivaGL/shader_glsl_ft.hpp b/src/DivaGL/shader_glsl_ft.hpp new file mode 100644 index 0000000..b3e24e6 --- /dev/null +++ b/src/DivaGL/shader_glsl_ft.hpp @@ -0,0 +1,87 @@ +/* + by korenkonder + GitHub/GitLab: korenkonder +*/ + +#pragma once + +#include "../KKdLib/default.hpp" +#include "shader_glsl.hpp" + +enum shader_ft_enum { + SHADER_FT_FFP = 0, + SHADER_FT_BLINN, + SHADER_FT_ITEM, + SHADER_FT_STAGE, + SHADER_FT_SKIN, + SHADER_FT_SSS_SKIN, + SHADER_FT_SSS_FILT, + SHADER_FT_HAIR, + SHADER_FT_CLOTH, + SHADER_FT_TIGHTS, + SHADER_FT_SKY, + //SHADER_FT_EYEBALL, + //SHADER_FT_EYELENS, + SHADER_FT_GLASEYE, + //SHADER_FT_MEMBRAN, + //SHADER_FT_SHDMAP, + //SHADER_FT_ESM, + SHADER_FT_ESMGAUSS, + SHADER_FT_ESMFILT, + SHADER_FT_LITPROJ, + SHADER_FT_SIMPLE, + SHADER_FT_SIL, + SHADER_FT_LAMBERT, + SHADER_FT_CONSTANT, + //SHADER_FT_PEEL, + SHADER_FT_TONEMAP, + SHADER_FT_REDUCE, + SHADER_FT_MAGNIFY, + SHADER_FT_MLAA, + SHADER_FT_CONTOUR, + SHADER_FT_CONTOUR_NPR, + SHADER_FT_EXPOSURE, + SHADER_FT_GAUSS, + SHADER_FT_SUN, + SHADER_FT_SUN_NO_TEXTURED, + //SHADER_FT_FADE, + SHADER_FT_WATER01, + //SHADER_FT_WATER02, + //SHADER_FT_WATRING, + SHADER_FT_W_PTCL, + SHADER_FT_SNOW_PT, + SHADER_FT_LEAF_PT, + SHADER_FT_STAR, + //SHADER_FT_SNORING, + //SHADER_FT_SN_FOOT, + //SHADER_FT_SN_TSL, + //SHADER_FT_SN_NRM, + SHADER_FT_FLOOR, + SHADER_FT_PUDDLE, + SHADER_FT_S_REFL, + SHADER_FT_S_REFR, + SHADER_FT_RIPEMIT, + SHADER_FT_RAIN, + //SHADER_FT_VOLLIT, + //SHADER_FT_FENCE, + SHADER_FT_RIPPLE, + SHADER_FT_FOGPTCL, + SHADER_FT_PARTICL, + SHADER_FT_GLITTER_PT, + //SHADER_FT_SHOW_VEC, + SHADER_FT_FONT, + SHADER_FT_MOVIE, + SHADER_FT_IMGFILT, + SHADER_FT_SPRITE, + SHADER_FT_END, + SHADER_FT_MAX, +}; + +extern const shader_glsl_table shader_ft_table[]; +extern const size_t shader_ft_table_size; +extern const shader_glsl_bind_func shader_ft_bind_func_table[]; +extern const size_t shader_ft_bind_func_table_size; + +extern shader_glsl_set_data shaders_ft; + +extern int32_t shader_ft_get_index_by_name(const char* name); diff --git a/src/DivaGL/shader_table.cpp b/src/DivaGL/shader_table.cpp new file mode 100644 index 0000000..514c86c --- /dev/null +++ b/src/DivaGL/shader_table.cpp @@ -0,0 +1,237 @@ +/* + by korenkonder + GitHub/GitLab: korenkonder +*/ + +#include "shader_table.hpp" +#include "../KKdLib/mat.hpp" +#include "render_context.hpp" +#include "render_texture.hpp" +#include "shader_glsl_ft.hpp" +#include "types.hpp" +#include "wrap.hpp" + +Shader* shaders = (Shader*)0x000000014CC57C10; +ShaderTable* shader_table = (ShaderTable*)0x0000000140A41D20; +ShaderBindFunc* shader_name_bind_func_table = (ShaderBindFunc*)0x0000000140A40F50; +int32_t* current_vp = (int32_t*)0x000000014CC587B0; +int32_t* current_fp = (int32_t*)0x000000014CC587B4; + +void FASTCALL shader_set(ShaderName name) { + if (!name) { + shader_unbind(); + return; + } + + glProgramEnvParameter4fARB(GL_FRAGMENT_PROGRAM_ARB, 24, + (float)uniform->arr[U_TEXTURE_BLEND], 0.0, 0.0, 0.0); + + Shader* shad = &shaders[name]; + if (shad->bind_func) + shad->bind_func(shad); + else + shader_bind(shad, shad->sub->sub_name); +} + +void FASTCALL shader_bind_blinn(Shader* shad) { + shader_bind(shad, uniform->arr[U_NORMAL] ? BLINN_FRAG : BLINN_VERT); +} + +void FASTCALL shader_bind_cloth(Shader* shad) { + shader_bind(shad, uniform->arr[U_NPR] ? CLOTH_NPR1 + : (uniform->arr[U_ANISO] ? CLOTH_ANISO : CLOTH_DEFAULT)); +} + +void FASTCALL shader_bind_hair(Shader* shad) { + shader_bind(shad, uniform->arr[U_NPR] ? HAIR_NPR1 + : (uniform->arr[U_ANISO] ? HAIR_ANISO : HAIR_DEFAULT)); +} + +void FASTCALL shader_bind_membrane(Shader* shad) { + uniform->arr[U_MEMBRANE] = 3; + if (shader_bind(shad, MEMBRANE) < 0) + return; + + uint32_t(FASTCALL * sub_140192E00)() = (uint32_t(FASTCALL*)())0x0000000140192E00; + uint32_t v1 = sub_140192E00(); + mat4 mat = mat4_identity; + mat4_mul_rotate_x(&mat, (float_t)((v1 & 0x1FF) * (M_PI / 256.0)), &mat); + mat4_mul_rotate_z(&mat, (float_t)((v1 % 0x168) * (M_PI / 180.0)), &mat); + + vec4 vec = { 1.0f, 0.0f, 0.0f, 0.0f }; + mat4_transform_vector(&mat, &vec, &vec); + + glProgramLocalParameter4fARB(GL_FRAGMENT_PROGRAM_ARB, 10, vec.x, vec.y, vec.z, 0.0); +} + +void FASTCALL shader_bind_eye_ball(Shader* shad) { + uniform->arr[U18] = 0; + if (shader_bind(&shaders[_GLASEYE], GLASS_EYE) >= 0) { + float* glass_eye = (float*)0x0000000140CA2D70; + void (FASTCALL * glass_eye_calc)(float* glass_eye) = (void (FASTCALL*)(float* glass_eye))0x00000001405E53D0; + void (FASTCALL * glass_eye_set)(float* glass_eye) = (void (FASTCALL*)(float* glass_eye))0x00000001405E4750; + glass_eye_calc(glass_eye); + glass_eye_set(glass_eye); + } +} + +void FASTCALL shader_bind_tone_map(Shader* shad) { + shader_bind(shad, uniform->arr[U_NPR] == 1 ? TONEMAP_NPR1 : TONEMAP); +} + +int32_t FASTCALL shader_bind(Shader* shad, SubShaderName name) { + int32_t num_sub = shad->num_sub; + int32_t subshader_index = 0; + if (num_sub <= 0) + return -1; + + for (SubShader* i = shad->sub; i->sub_name != name; i++) { + subshader_index++; + if (subshader_index >= num_sub) + return -1; + } + + SubShader* subshader = &shad->sub[subshader_index]; + if (!subshader) + return -1; + + int32_t num_uniform = shad->num_uniform; + int32_t unival_vp_curr = 1; + int32_t unival_fp_curr = 1; + int32_t unival_vp = 0; + int32_t unival_fp = 0; + if (num_uniform > 0) { + int32_t* vp_unival_max = subshader->vp_unival_max; + int32_t* fp_unival_max = subshader->fp_unival_max; + for (size_t i = 0; i < num_uniform; i++) { + int32_t unival = uniform->arr[shad->use_uniform[i]]; + unival_vp += unival_vp_curr * min_def(unival, vp_unival_max[i]); + unival_fp += unival_fp_curr * min_def(unival, fp_unival_max[i]); + unival_vp_curr *= vp_unival_max[i] + 1; + unival_fp_curr *= fp_unival_max[i] + 1; + } + } + + int32_t vp = subshader->vp[unival_vp]; + int32_t fp = subshader->fp[unival_fp]; + if (*current_vp != vp) { + glBindProgramARB(GL_VERTEX_PROGRAM_ARB, vp); + *current_vp = vp; + } + + if (*current_fp != fp) { + glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, fp); + *current_fp = fp; + } + + glEnableDLL(GL_VERTEX_PROGRAM_ARB); + glEnableDLL(GL_FRAGMENT_PROGRAM_ARB); + return 0; +} + +void FASTCALL shader_unbind() { + if (current_vp) { + if (*current_vp) + glDisableDLL(GL_VERTEX_PROGRAM_ARB); + *current_vp = 0; + } + + if (current_fp) { + if (*current_fp) + glDisableDLL(GL_FRAGMENT_PROGRAM_ARB); + *current_fp = 0; + } +} + +void FASTCALL shader_load_all_shaders() { + { + farc f; + f.read("F:\\msys64\\ReDIVA\\bin\\rom\\ft_shaders.farc", true, false); + shaders_ft.load(&f, true, "ft", shader_ft_table, shader_ft_table_size, + shader_ft_bind_func_table, shader_ft_bind_func_table_size, + shader_ft_get_index_by_name); + } + return; + + void (FASTCALL * shader_load_program_file)(GLuint program, const char* file_name, bool vertex_program) + = (void (FASTCALL*)(GLuint program, const char* file_name, bool vertex_program))0x00000001405E52D0; + + ShaderTable* shaders_table = &shader_table[_BLINN]; + Shader* shader = &shaders[_BLINN]; + int32_t curr_shader = SHADER_END - 1; + do { + shader->name = shaders_table->name; + shader->name_index = shaders_table->name_index; + shader->num_sub = shaders_table->num_sub; + int32_t num_sub = shaders_table->num_sub; + + const SubShaderTable* sub_table = shaders_table->sub; + SubShader* sub = (SubShader*)_operator_new(sizeof(SubShader) * num_sub); + memset(sub, 0, sizeof(SubShader) * num_sub); + shader->sub = sub; + shader->num_uniform = shaders_table->num_uniform; + shader->use_uniform = shaders_table->use_uniform; + + for (int32_t i = 0; i < num_sub; i++, sub_table++, sub++) { + sub->sub_name = sub_table->sub_name; + sub->vp_unival_max = (int32_t*)sub_table->vp_unival_max; + sub->fp_unival_max = (int32_t*)sub_table->fp_unival_max; + sub->num_vp = sub_table->num_vp; + sub->num_fp = sub_table->num_fp; + sub->vp = (GLuint*)_operator_new(sizeof(GLuint) * sub_table->num_vp); + sub->fp = (GLuint*)_operator_new(sizeof(GLuint) * sub_table->num_fp); + + glGenProgramsARB((GLsizei)sub_table->num_vp, (GLuint*)sub->vp); + glGenProgramsARB((GLsizei)sub_table->num_fp, (GLuint*)sub->fp); + + for (int32_t j = 0; j < sub_table->num_vp; j++) + shader_load_program_file(sub->vp[j], sub_table->vp[j], true); + + for (int32_t j = 0; j < sub_table->num_fp; j++) + shader_load_program_file(sub->fp[j], sub_table->fp[j], false); + } + shader->bind_func = 0; + + ShaderBindFunc* bind_func_table = shader_name_bind_func_table; + ShaderName bind_func_name = _BLINN; + while (shader->name_index != bind_func_name) { + bind_func_name = (++bind_func_table)->name_index; + if (bind_func_table->name_index == SHADER_END) + break; + } + shader->bind_func = bind_func_table->bind_func; + shader++; + shaders_table++; + curr_shader--; + } while (curr_shader); +} + +void FASTCALL shader_free() { + shaders_ft.unload(); + return; + Shader* shader = &shaders[SHADER_FFP]; + for (int32_t i = 0; i < SHADER_END; i++, shader++) { + if (!shader->sub) + continue; + + for (int32_t j = 0; j < shader->num_sub; j++) { + SubShader* sub = shader->sub; + if (sub[j].vp) { + glDeleteProgramsARB(sub[j].num_vp, sub[j].vp); + _operator_delete(sub[j].vp); + sub[j].vp = 0; + } + + if (sub[j].fp) { + glDeleteProgramsARB(sub[j].num_fp, sub[j].fp); + _operator_delete(sub[j].fp); + sub[j].fp = 0; + } + } + + if (shader->sub) { + _operator_delete(shader->sub); + shader->sub = 0; + } + } +} diff --git a/src/DivaGL/shader_table.hpp b/src/DivaGL/shader_table.hpp new file mode 100644 index 0000000..7f27a4f --- /dev/null +++ b/src/DivaGL/shader_table.hpp @@ -0,0 +1,218 @@ +/* + by korenkonder + GitHub/GitLab: korenkonder +*/ + +#pragma once + +#include "../KKdLib/default.hpp" +#include "gl.hpp" +#include "uniform.hpp" + +enum SubShaderName { + SHADER_SUB_FFP = 0, + BLINN_VERT = 1, + BLINN_FRAG = 2, + ITEM_BLINN = 3, + STAGE_BLINN = 4, + SKIN_DEFAULT = 5, + SSS_SKIN = 6, + SSS_FILTER = 7, + HAIR_DEFAULT = 8, + HAIR_ANISO = 9, + HAIR_NPR1 = 10, + CLOTH_DEFAULT = 11, + CLOTH_ANISO = 12, + CLOTH_NPR1 = 13, + TIGHTS = 14, + SKY_DEFAULT = 15, + EYE_BALL = 16, + EYE_LENS = 17, + GLASS_EYE = 18, + MEMBRANE = 19, + SHADOWMAP = 20, + ESM = 21, + ESM_GAUSS = 22, + ESM_FILTER = 23, + LIT_PROJ = 24, + SIMPLE = 25, + SILHOUETTE = 26, + LAMBERT = 27, + CONSTANT = 28, + PEEL = 29, + TONEMAP = 30, + TONEMAP_NPR1 = 31, + REDUCE_TEX = 32, + MAGNIFY = 33, + MLAA = 34, + CONTOUR = 35, + EXPOSURE = 36, + PP_GAUSS = 37, + SUN = 38, + FADE = 39, + WATER01 = 40, + WATER02 = 41, + WATER_RING = 42, + WATER_PARTICLE = 43, + SNOW_PARTICLE = 44, + LEAF_PARTICLE = 45, + STAR = 46, + SNOW_RING = 47, + SNOW_FOOTPRINT = 48, + SNOW_TEX_SPACE_LIGHT = 49, + SNOW_CALC_NORMAL = 50, + FLOOR = 51, + PUDDLE = 52, + SIMPLE_REFLECT = 53, + SIMPLE_REFRACT = 54, + RIPPLE_EMIT = 55, + RAIN = 56, + VOLUME_LIGHT = 57, + FENCE_ALPHA = 58, + RIPPLE = 59, + FOG_PTCL = 60, + PARTICLE = 61, + GLITTER_PARTICLE = 62, + SHOW_VECTOR = 63, + FONT = 64, + MOVIE = 65, + IMGFILTER = 66, + SPRITE = 67, +}; + +enum ShaderName { + SHADER_FFP = 0, + _BLINN = 1, + _ITEM = 2, + _STAGE = 3, + _SKIN = 4, + _SSS_SKIN = 5, + _SSS_FILT = 6, + _HAIR = 7, + _CLOTH = 8, + _TIGHTS = 9, + _SKY = 10, + _EYEBALL = 11, + _EYELENS = 12, + _GLASEYE = 13, + _MEMBRAN = 14, + _SHDMAP = 15, + _ESM = 16, + _ESMGAUSS = 17, + _ESMFILT = 18, + _LITPROJ = 19, + _SIMPLE = 20, + _SIL = 21, + _LAMBERT = 22, + _CONSTANT = 23, + _PEEL = 24, + _TONEMAP = 25, + _REDUCE = 26, + _MAGNIFY = 27, + _MLAA = 28, + _CONTOUR = 29, + _EXPOSURE = 30, + _GAUSS = 31, + _SUN = 32, + _FADE = 33, + _WATER01 = 34, + _WATER02 = 35, + _WATRING = 36, + _W_PTCL = 37, + _SNOW_PT = 38, + _LEAF_PT = 39, + _STAR = 40, + _SNORING = 41, + _SN_FOOT = 42, + _SN_TSL = 43, + _SN_NRM = 44, + _FLOOR = 45, + _PUDDLE = 46, + _S_REFL = 47, + _S_REFR = 48, + _RIPEMIT = 49, + _RAIN = 50, + _VOLLIT = 51, + _FENCE = 52, + _RIPPLE = 53, + _FOGPTCL = 54, + _PARTICL = 55, + _GLITTER_PT = 56, + _SHOWVEC = 57, + _FONT = 58, + _MOVIE = 59, + _IMGFILT = 60, + _SPRITE = 61, + SHADER_END = 62, +}; + +struct SubShaderTable { + SubShaderName sub_name; + int32_t padding; + const int32_t* vp_unival_max; + const int32_t* fp_unival_max; + int32_t num_vp; + int32_t num_fp; + const char** vp; + const char** fp; +}; + +struct ShaderTable { + const char* name; + ShaderName name_index; + int32_t num_sub; + const SubShaderTable* sub; + int32_t num_uniform; + int32_t padding; + uniform_name* use_uniform; +}; + +struct SubShader { + SubShaderName sub_name; + int32_t padding; + int32_t* vp_unival_max; + int32_t* fp_unival_max; + int32_t num_vp; + int32_t num_fp; + GLuint* vp; + GLuint* fp; +}; + +struct Shader; + +typedef void (FASTCALL* PFNSHADERBINDFUNCPROC)(Shader* shad); + +struct Shader { + const char* name; + ShaderName name_index; + int32_t num_sub; + SubShader* sub; + int32_t num_uniform; + int32_t padding; + uniform_name* use_uniform; + PFNSHADERBINDFUNCPROC bind_func; +}; + +struct ShaderBindFunc { + ShaderName name_index; + int32_t padding; + PFNSHADERBINDFUNCPROC bind_func; +}; + +extern Shader* shaders; +extern ShaderTable* shader_table; +extern ShaderBindFunc* shader_name_bind_func_table; +extern int32_t* current_vp; +extern int32_t* current_fp; + +extern void FASTCALL shader_set(ShaderName name); // 0x00000001405E4CE0 +extern void FASTCALL shader_bind_blinn(Shader* shad); // 0x00000001405E4320 +extern void FASTCALL shader_bind_cloth(Shader* shad); // 0x00000001405E4340 +extern void FASTCALL shader_bind_hair(Shader* shad); // 0x00000001405E4370 +extern void FASTCALL shader_bind_membrane(Shader* shas); // 0x00000001405E43A0 +extern void FASTCALL shader_bind_eye_ball(Shader* shad); // 0x00000001405E4530 +extern void FASTCALL shader_bind_tone_map(Shader* shad); // 0x00000001405E4580 +extern int32_t FASTCALL shader_bind(Shader* shad, SubShaderName name); // 0x00000001405E4B50 +extern void FASTCALL shader_unbind(); // 0x00000001405E5660 +extern void FASTCALL shader_load_all_shaders(); // 0x00000001405E4FC0 +extern void FASTCALL shader_free(); // 0x00000001405E4DB0 diff --git a/src/DivaGL/shadow.cpp b/src/DivaGL/shadow.cpp new file mode 100644 index 0000000..bf9bf20 --- /dev/null +++ b/src/DivaGL/shadow.cpp @@ -0,0 +1,12 @@ +/* + by korenkonder + GitHub/GitLab: korenkonder +*/ + +#include "shadow.hpp" + +Shadow** shadow_ptr = (Shadow**)0x000000014CC587B8; + +Shadow* shadow_ptr_get() { + return *shadow_ptr; +} diff --git a/src/DivaGL/shadow.hpp b/src/DivaGL/shadow.hpp new file mode 100644 index 0000000..7ae5594 --- /dev/null +++ b/src/DivaGL/shadow.hpp @@ -0,0 +1,63 @@ +/* + by korenkonder + GitHub/GitLab: korenkonder +*/ + +#pragma once + +#include "../KKdLib/default.hpp" +#include "../KKdLib/time.hpp" +#include "../KKdLib/vec.hpp" +#include "render_texture.hpp" +#include "shared.hpp" +#include "types.hpp" + +enum shadow_type_enum { + SHADOW_CHARA = 0, + SHADOW_STAGE, + SHADOW_MAX, +}; + +struct Shadow { + void* __vftable; + RenderTexture render_textures[7]; + RenderTexture* curr_render_textures[3]; + float_t view_region; + float_t range; + vec3 view_point[2]; + vec3 interest[2]; + vec3 field_1A8[2]; + float_t field_1C0[2]; + float_t field_1C8[2]; + prj::vector field_1D0[2]; + int32_t field_200[2]; + float_t field_208; + vec3 direction; + vec3 view_point_shared; + vec3 interest_shared; + mat4 view_mat[2]; + int32_t near_blur; + blur_filter_mode blur_filter; + int32_t far_blur; + int32_t field_2BC; + float_t distance; + float_t field_2C4; + float_t z_near; + float_t z_far; + float_t field_2D0; + float_t field_2D4; + float_t field_2D8; + float_t field_2DC; + float_t field_2E0; + float_t ambient; + bool field_2E8; + int32_t field_2EC; + bool field_2F0[2]; + bool self_shadow; + bool blur_filter_enable[2]; + bool field_2F5; +}; + +static_assert(sizeof(Shadow) == 0x2F8, "\"Shadow\" struct should have a size of 0x2F8"); + +extern Shadow* shadow_ptr_get(); diff --git a/src/DivaGL/shared.cpp b/src/DivaGL/shared.cpp new file mode 100644 index 0000000..030c087 --- /dev/null +++ b/src/DivaGL/shared.cpp @@ -0,0 +1,6 @@ +/* + by korenkonder + GitHub/GitLab: korenkonder +*/ + +#include "shared.hpp" diff --git a/src/DivaGL/shared.hpp b/src/DivaGL/shared.hpp new file mode 100644 index 0000000..67a3f23 --- /dev/null +++ b/src/DivaGL/shared.hpp @@ -0,0 +1,19 @@ +/* + by korenkonder + GitHub/GitLab: korenkonder +*/ + +#pragma once + +#include "../KKdLib/default.hpp" +#include "../KKdLib/mat.hpp" +#include "../KKdLib/vec.hpp" +#include "wrap.hpp" + +enum blur_filter_mode { + BLUR_FILTER_4 = 0, + BLUR_FILTER_9, + BLUR_FILTER_16, + BLUR_FILTER_32, + BLUR_FILTER_MAX, +}; diff --git a/src/DivaGL/sprite.cpp b/src/DivaGL/sprite.cpp new file mode 100644 index 0000000..d1c3b0c --- /dev/null +++ b/src/DivaGL/sprite.cpp @@ -0,0 +1,1133 @@ +/* + by korenkonder + GitHub/GitLab: korenkonder +*/ + +#include "sprite.hpp" +#include "render_context.hpp" +#include "shader_glsl_ft.hpp" +#include + +struct sprite_draw_vertex { + vec3 pos; + vec2 uv[2]; + vec4u8 color; +}; + +struct sprite_draw_param { + bool blend; + GLenum blend_src_rgb; + GLenum blend_src_alpha; + GLenum blend_dst_rgb; + GLenum blend_dst_alpha; + + bool copy_texture; + GLint copy_texture_x; + GLint copy_texture_y; + GLint copy_texture_width; + GLint copy_texture_height; + + int32_t shader; + int32_t tex_0_type; + int32_t tex_1_type; + int32_t combiner; + + GLuint texture[2]; + GLuint sampler; + + GLenum mode; + GLint first; + GLsizei count; +}; + +namespace spr { + struct TexCoord { + struct UV { + float_t u; + float_t v; + }; + + TexCoord::UV uv[4]; + }; + + struct TexParam { + texture* texture; + TexCoord texcoord; + int32_t pad[2]; + }; + + struct SpriteManager { + struct RenderData { + std::vector draw_param_buffer; + std::vector vertex_buffer; + GLuint vao; + GLuint vbo; + size_t vbo_vertex_count; + + RenderData(); + ~RenderData(); + + void Clear(); + void Update(); + }; + + prj::map sets; + prj::list reqlist[4][2][SPR_PRIO_MAX]; + float_t aspect[2]; + prj::pair field_1018[2]; + int32_t index; + mat4 view_projection; + mat4 mat; + resolution_mode resolution_mode; + + void Draw(int32_t index, bool font, texture* tex); + }; + + static_assert(sizeof(spr::SpriteManager) == 0x10C8, "\"spr::SpriteManager\" struct should have a size of 0x10C8"); + + static void calc_sprite_vertex(spr::SprArgs* args, vec3* vtx, mat4* mat, bool font); + static int32_t calc_sprite_texture_param(SprArgs* args, spr::TexParam* param, vec3* vtx, bool font); + + static void draw_sprite(SprArgs& args, bool font, const mat4& mat, + int32_t x_min, int32_t y_min, int32_t x_max, int32_t y_max, + std::vector& draw_param_buffer, std::vector& vertex_buffer); + static void draw_sprite_begin(); + static void draw_sprite_end(); + static void draw_sprite_scale(spr::SprArgs* args); +} + +size_t(FASTCALL* sprite_manager_get_reqlist_count)(int32_t index) + = (size_t(FASTCALL*)(int32_t index))0x000000014063FA90; + +spr::SpriteManager* sprite_manager = (spr::SpriteManager*)0x000000014CC611C0; + +static mat4 view_projection_aet; + +static spr::SpriteManager::RenderData* sprite_manager_render_data; + +static const GLenum spr_blend_param[6][4] = { + { GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ZERO, GL_ONE }, + { GL_SRC_ALPHA, GL_ONE_MINUS_SRC_COLOR, GL_ZERO, GL_ONE }, + { GL_SRC_ALPHA, GL_ONE, GL_ZERO, GL_ONE }, + { GL_DST_COLOR, GL_ZERO, GL_ZERO, GL_ONE }, + { GL_ONE, GL_ZERO, GL_ONE, GL_ZERO }, + { GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ZERO, GL_ONE }, +}; + +namespace spr { + void(FASTCALL* put_rgb_cross)(mat4* mat) = (void(FASTCALL*)(mat4 * mat))0x00000001404BC8F0; + + SpriteManager::RenderData::RenderData() { + glGenVertexArrays(1, &vao); + gl_state_bind_vertex_array(vao, true); + + glGenBuffers(1, &vbo); + gl_state_bind_array_buffer(vbo, true); + + vbo_vertex_count = 4096; + + static const GLsizei buffer_size = sizeof(sprite_draw_vertex); + + glBufferData(GL_ARRAY_BUFFER, + (GLsizeiptr)(buffer_size * vbo_vertex_count), 0, GL_DYNAMIC_DRAW); + + glEnableVertexAttribArray(0); + glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, buffer_size, + (void*)offsetof(sprite_draw_vertex, pos)); + glEnableVertexAttribArray(1); + glVertexAttribPointer(1, 4, GL_UNSIGNED_BYTE, GL_TRUE, buffer_size, + (void*)offsetof(sprite_draw_vertex, color)); + glEnableVertexAttribArray(2); + glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, buffer_size, + (void*)offsetof(sprite_draw_vertex, uv[0])); + glEnableVertexAttribArray(3); + glVertexAttribPointer(3, 2, GL_FLOAT, GL_FALSE, buffer_size, + (void*)offsetof(sprite_draw_vertex, uv[1])); + + gl_state_bind_array_buffer(0); + gl_state_bind_vertex_array(0); + } + + SpriteManager::RenderData::~RenderData() { + if (vbo) { + glDeleteBuffers(1, &vbo); + vbo = 0; + } + + if (vao) { + glDeleteVertexArrays(1, &vao); + vao = 0; + } + } + + void SpriteManager::RenderData::Clear() { + draw_param_buffer.clear(); + vertex_buffer.clear(); + } + + void SpriteManager::RenderData::Update() { + static const GLsizei buffer_size = sizeof(sprite_draw_vertex); + + if (vbo_vertex_count < vertex_buffer.size()) { + while (vbo_vertex_count < vertex_buffer.size()) + vbo_vertex_count *= 2; + + glDeleteBuffers(1, &vbo); + glGenBuffers(1, &vbo); + + gl_state_bind_vertex_array(vao, true); + gl_state_bind_array_buffer(vbo, true); + + glBufferData(GL_ARRAY_BUFFER, + (GLsizeiptr)(buffer_size * vbo_vertex_count), 0, GL_DYNAMIC_DRAW); + glBufferSubData(GL_ARRAY_BUFFER, 0, (GLsizeiptr)(buffer_size + * vertex_buffer.size()), vertex_buffer.data()); + + glEnableVertexAttribArray(0); + glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, buffer_size, + (void*)offsetof(sprite_draw_vertex, pos)); + glEnableVertexAttribArray(1); + glVertexAttribPointer(1, 4, GL_UNSIGNED_BYTE, GL_TRUE, buffer_size, + (void*)offsetof(sprite_draw_vertex, color)); + glEnableVertexAttribArray(2); + glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, buffer_size, + (void*)offsetof(sprite_draw_vertex, uv[0])); + glEnableVertexAttribArray(3); + glVertexAttribPointer(3, 2, GL_FLOAT, GL_FALSE, buffer_size, + (void*)offsetof(sprite_draw_vertex, uv[1])); + + gl_state_bind_array_buffer(0); + gl_state_bind_vertex_array(0); + } + else { + gl_state_bind_array_buffer(vbo); + glBufferSubData(GL_ARRAY_BUFFER, 0, (GLsizeiptr)(buffer_size + * vertex_buffer.size()), vertex_buffer.data()); + gl_state_bind_array_buffer(0); + } + } + + void SpriteManager::Draw(int32_t index, bool font, texture* tex) { + draw_sprite_begin(); + + size_t count = 0; + for (auto& i : reqlist[index]) + for (auto& j : i) + count += j.size(); + + ::resolution_mode mode = res_window_get()->resolution_mode; + if (index == 2 && resolution_mode != RESOLUTION_MODE_MAX) + res_window_get()->resolution_mode = resolution_mode; + + GLint v43[4]; + glGetIntegervDLL(GL_VIEWPORT, v43); + + for (int32_t i = 0; i < 2; i++) { + auto reqlist = this->reqlist[index][i]; + + size_t count = 0; + for (uint32_t j = SPR_PRIO_MAX, k = 0; j; j--, k++) + count += reqlist[k].size(); + + if (!count) + continue; + + int32_t x_min; + int32_t y_min; + int32_t x_max; + int32_t y_max; + if (index == 0 || index == 3) { + float_t sprite_half_width = (float_t)res_window_get()->width * 0.5f; + float_t sprite_half_height = (float_t)res_window_get()->height * 0.5f; + + float_t aet_depth = camera_data->aet_depth; + float_t aet_depth_1 = 1.0f / aet_depth; + + float_t v15a = sprite_half_height * aspect[i] * 0.2f * aet_depth_1; + float_t v15b = sprite_half_height * 0.2f * aet_depth_1; + + mat4 proj; + mat4_frustrum(-v15a, v15a, v15b, -v15b, 0.2, 3000.0, &proj); + + vec3 eye = { sprite_half_width, sprite_half_height, aet_depth }; + vec3 target = { sprite_half_width, sprite_half_height, 0.0f }; + vec3 up = { 0.0f, 1.0f, 0.0f }; + + mat4 view; + mat4_look_at(&eye, &target, &up, &view); + mat4_mul(&view, &proj, &view_projection); + mat4_transpose(&view_projection, &view_projection); + + vec2 min; + vec2 max; + resolution_mode_scale_pos(min, mode, field_1018[i].second.pos, field_1018[i].first); + resolution_mode_scale_pos(max, mode, + field_1018[i].second.pos + field_1018[i].second.size, field_1018[i].first); + x_min = (int32_t)min.x; + y_min = (int32_t)min.y; + x_max = (int32_t)(max.x - min.x); + y_max = (int32_t)(max.y - min.y); + glViewportDLL(x_min, y_min, x_max, y_max); + } + else { + view_projection = view_projection_aet; + + x_min = v43[0]; + y_min = v43[1]; + x_max = v43[2]; + y_max = v43[3]; + } + + float_t v23 = (float_t)x_max * 0.5f; + float_t v24 = (float_t)x_min + v23; + float_t v25 = (float_t)y_max * 0.5f; + float_t v26 = (float_t)y_min + v25; + + mat4 mat = view_projection; + mat.row0.x = v23 * view_projection.row0.x + v24 * view_projection.row0.x; + mat.row0.y = v23 * view_projection.row0.y + v24 * view_projection.row0.y; + mat.row0.z = v23 * view_projection.row0.z + v24 * view_projection.row0.z; + mat.row0.w = v23 * view_projection.row0.w + v24 * view_projection.row0.w; + mat.row1.x = v25 * view_projection.row1.x + v26 * view_projection.row1.x; + mat.row1.y = v25 * view_projection.row1.y + v26 * view_projection.row1.y; + mat.row1.z = v25 * view_projection.row1.z + v26 * view_projection.row1.z; + mat.row1.w = v25 * view_projection.row1.w + v26 * view_projection.row1.w; + this->mat = mat; + + mat4_transpose(&mat, &mat); + + sprite_scene_shader_data shader_data = {}; + shader_data.g_framebuffer_size = { + 1.0f / (float_t)tex->width, + 1.0f / (float_t)tex->height, 0.0f, 0.0f + }; + shader_data.g_transform = view_projection; + rctx->sprite_scene_ubo.WriteMemory(shader_data); + + sprite_manager_render_data->Clear(); + + for (uint32_t j = SPR_PRIO_MAX; j; j--, reqlist++) + for (auto& k : *reqlist) + draw_sprite(k, font, mat, x_min, y_min, x_max, y_max, + sprite_manager_render_data->draw_param_buffer, + sprite_manager_render_data->vertex_buffer); + + static const GLsizei buffer_size = sizeof(sprite_draw_vertex); + + sprite_manager_render_data->Update(); + + rctx->sprite_scene_ubo.Bind(0); + + gl_state_active_bind_texture_2d(7, tex->tex); + + gl_state_bind_vertex_array(sprite_manager_render_data->vao); + for (sprite_draw_param& j : sprite_manager_render_data->draw_param_buffer) { + if (j.blend) { + gl_state_enable_blend(); + gl_state_set_blend_func_separate( + j.blend_src_rgb, j.blend_dst_rgb, + j.blend_src_alpha, j.blend_dst_alpha); + + if (j.copy_texture) { + gl_state_active_texture(7); + glCopyTexSubImage2DDLL(GL_TEXTURE_2D, 0, j.copy_texture_x, j.copy_texture_y, + j.copy_texture_x, j.copy_texture_y, j.copy_texture_width, j.copy_texture_height); + } + } + else + gl_state_disable_blend(); + + if (j.shader == SHADER_FT_SPRITE) { + uniform->arr[U_TEX_0_TYPE] = j.tex_0_type; + uniform->arr[U_TEX_1_TYPE] = j.tex_1_type; + uniform->arr[U_COMBINER] = j.combiner; + } + + if (j.texture[0]) { + gl_state_active_bind_texture_2d(0, j.texture[0]); + gl_state_bind_sampler(0, j.sampler); + + if (j.texture[1]) { + gl_state_active_bind_texture_2d(1, j.texture[1]); + gl_state_bind_sampler(1, j.sampler); + } + } + + shaders_ft.set(j.shader); + shaders_ft.draw_arrays(j.mode, j.first, j.count); + } + gl_state_bind_vertex_array(0); + } + + if (index == 2 && resolution_mode != RESOLUTION_MODE_MAX) + res_window_get()->resolution_mode = mode; + + draw_sprite_end(); + } + + static void calc_sprite_vertex(spr::SprArgs* args, vec3* vtx, mat4* mat, bool font) { + vtx[0].x = 0.0f; + vtx[0].y = 0.0f; + vtx[1].x = 0.0f; + vtx[1].y = args->sprite_size.y; + vtx[1].z = 0.0f; + vtx[2].x = args->sprite_size.x; + vtx[2].y = args->sprite_size.y; + vtx[2].z = 0.0f; + vtx[3].x = args->sprite_size.x; + vtx[3].y = 0.0f; + vtx[3].z = 0.0f; + + mat4 m; + SprAttr attr = args->attr; + if (!(attr & SPR_ATTR_MATRIX)) { + if (attr & SPR_ATTR_CTR) { + if (attr & SPR_ATTR_CTR_LT) + args->center = 0.0f; + else if (attr & SPR_ATTR_CTR_LC) { + args->center.x = 0.0f; + args->center.y = args->sprite_size.y * 0.5f; + args->center.z = 0.0f; + } + else if (attr & SPR_ATTR_CTR_LB) { + args->center.x = 0.0f; + args->center.y = args->sprite_size.y; + args->center.z = 0.0f; + } + else if (attr & SPR_ATTR_CTR_CT) { + args->center.x = args->sprite_size.x * 0.5f; + args->center.y = 0.0f; + args->center.z = 0.0f; + } + else if (attr & SPR_ATTR_CTR_CC) { + args->center.x = args->sprite_size.x * 0.5f; + args->center.y = args->sprite_size.y * 0.5f; + args->center.z = 0.0f; + } + else if (attr & SPR_ATTR_CTR_CB) { + args->center.x = args->sprite_size.x * 0.5f; + args->center.y = args->sprite_size.y; + args->center.z = 0.0f; + } + else if (attr & SPR_ATTR_CTR_RT) { + args->center.x = args->sprite_size.x; + args->center.y = 0.0f; + args->center.z = 0.0f; + } + else if (attr & SPR_ATTR_CTR_RC) { + args->center.x = args->sprite_size.x; + args->center.y = args->sprite_size.y * 0.5f; + args->center.z = 0.0f; + } + else if (attr & SPR_ATTR_CTR_RB) { + args->center.x = args->sprite_size.x; + args->center.y = args->sprite_size.y; + args->center.z = 0.0f; + } + } + + if (font) { + if (attr & SPR_ATTR_FLIP_H) { + args->scale.x = -args->scale.x; + args->rot.z = -args->rot.z; + } + if (attr & SPR_ATTR_FLIP_V) { + args->scale.y = -args->scale.y; + args->rot.z = -args->rot.z; + } + } + + if (fabsf(args->skew_angle.x) > 0.000001f) { + float_t skew_width = tanf(args->skew_angle.x) * args->sprite_size.y * 0.5f; + vtx[0].x = vtx[0].x + skew_width; + vtx[1].x = vtx[1].x - skew_width; + vtx[2].x = vtx[2].x - skew_width; + vtx[3].x = vtx[3].x + skew_width; + } + + if (fabsf(args->skew_angle.y) > 0.000001f) { + float_t skew_height = tanf(args->skew_angle.y) * args->sprite_size.x * 0.5f; + vtx[0].y = vtx[0].y - skew_height; + vtx[1].y = vtx[1].y - skew_height; + vtx[2].y = vtx[2].y + skew_height; + vtx[3].y = vtx[3].y + skew_height; + } + + mat4_translate(&args->trans, &m); + if (fabsf(args->rot.x) > 0.000001f) + mat4_mul_rotate_x(&m, args->rot.x, &m); + if (fabsf(args->rot.y) > 0.000001f) + mat4_mul_rotate_y(&m, args->rot.y, &m); + if (fabsf(args->rot.z) > 0.000001f) + mat4_mul_rotate_z(&m, args->rot.z, &m); + mat4_scale_rot(&m, &args->scale, &m); + const vec3 center = -args->center; + mat4_mul_translate(&m, ¢er, &m); + } + else { + mat4_translate(&args->trans, &m); + mat4_scale_rot(&m, &args->scale, &m); + } + + mat4 args_mat; + mat4_transpose(&args->mat, &args_mat); + mat4_mul(&args_mat, &m, &m); + + mat4_transform_point(&m, &vtx[0], &vtx[0]); + mat4_transform_point(&m, &vtx[1], &vtx[1]); + mat4_transform_point(&m, &vtx[2], &vtx[2]); + mat4_transform_point(&m, &vtx[3], &vtx[3]); + + if (mat) + *mat = m; + } + + static int32_t calc_sprite_texture_param(SprArgs* args, spr::TexParam* param, vec3* vtx, bool font) { + int32_t tex_param_count = 0; + texture* tex = args->texture; + while (args) { + param->texture = args->texture; + + float_t width = (float_t)args->texture->width; + float_t height = (float_t)args->texture->height; + + float_t u_scale = 1.0f / width; + float_t v_scale = 1.0f / height; + + if (!args->num_vertex) { + vec2 uv00; + vec2 uv01; + vec2 uv10; + vec2 uv11; + if (args->kind == SPR_KIND_LINE) { + vec3 v42[4]; + mat4 mat; + calc_sprite_vertex(args, v42, &mat, font); + mat4_invert(&mat, &mat); + mat4_transform_point(&mat, &vtx[0], &v42[0]); + mat4_transform_point(&mat, &vtx[1], &v42[1]); + mat4_transform_point(&mat, &vtx[2], &v42[2]); + mat4_transform_point(&mat, &vtx[3], &v42[3]); + uv00 = *(vec2*)&v42[0].x; + uv01 = *(vec2*)&v42[1].x; + uv10 = *(vec2*)&v42[2].x; + uv11 = *(vec2*)&v42[3].x; + } + else { + uv00.x = 0.0f; + uv00.y = 0.0f; + uv01.x = 0.0f; + uv01.y = args->texture_size.y; + uv10.x = args->texture_size.x; + uv10.y = args->texture_size.y; + uv11.x = args->texture_size.x; + uv11.y = 0.0f; + } + + vec2 texture_pos = args->texture_pos; + param->texcoord.uv[0].u = (uv00.x + texture_pos.x) * u_scale; + param->texcoord.uv[0].v = (height - (uv00.y + texture_pos.y)) * v_scale; + param->texcoord.uv[1].u = (uv01.x + texture_pos.x) * u_scale; + param->texcoord.uv[1].v = (height - (uv01.y + texture_pos.y)) * v_scale; + param->texcoord.uv[2].u = (uv10.x + texture_pos.x) * u_scale; + param->texcoord.uv[2].v = (height - (uv10.y + texture_pos.y)) * v_scale; + param->texcoord.uv[3].u = (uv11.x + texture_pos.x) * u_scale; + param->texcoord.uv[3].v = (height - (uv11.y + texture_pos.y)) * v_scale; + } + else if (font) { + SpriteVertex* vtx = args->vertex_array; + for (size_t i = args->num_vertex; i; i--, vtx++) { + vtx->uv.x = vtx->uv.x * u_scale; + vtx->uv.y = (height - vtx->uv.y) * v_scale; + } + } + + args = args->next; + param++; + tex_param_count++; + } + return tex_param_count; + } + + static void draw_sprite(SprArgs& args, bool font, const mat4& mat, + int32_t x_min, int32_t y_min, int32_t x_max, int32_t y_max, + std::vector& draw_param_buffer, std::vector& vertex_buffer) { + if (args.kind == SPR_KIND_LINE) + return; + + // BGRA to RGBA + const vec4u8 color = { args.color.z, args.color.y, args.color.x, args.color.w }; + + if (font) + draw_sprite_scale(&args); + + vec3 vtx[4] = {}; + spr::TexParam tex_param[4] = {}; + + if (args.flags & SprArgs::SPRITE_SIZE) + calc_sprite_vertex(&args, vtx, 0, font); + + int32_t tex_param_count = 0; + if ((args.flags & SprArgs::TEXTURE_POS_SIZE) && args.texture) { + tex_param_count = calc_sprite_texture_param(&args, tex_param, vtx, font); + tex_param_count = min_def(tex_param_count, 2); + } + + mat4 mat_t; + mat4_transpose(&mat, &mat_t); + + draw_param_buffer.push_back({}); + sprite_draw_param& draw_param = draw_param_buffer.back(); + + if (!(args.attr & SPR_ATTR_NOBLEND)) { + const GLenum* blend = spr_blend_param[args.blend]; + draw_param.blend = true; + draw_param.blend_src_rgb = blend[0]; + draw_param.blend_dst_rgb = blend[1]; + draw_param.blend_src_alpha = blend[2]; + draw_param.blend_dst_alpha = blend[3]; + + if (args.blend == 5 && !args.num_vertex && args.kind == SPR_KIND_NORMAL) { + float_t v25 = 0.0f; + float_t v26 = 0.0f; + float_t v27 = 0.0f; + float_t v28 = 0.0f; + for (int32_t i = 0, j = 0; i < 4; i++) { + vec4 v; + *(vec3*)&v = vtx[i]; + v.w = 1.0f; + + float_t v31 = vec4::dot(mat_t.row3, v); + if (v31 * v31 <= 0.0001f) + continue; + + float_t v33 = vec4::dot(mat_t.row0, v) * (1.0f / v31); + float_t v34 = vec4::dot(mat_t.row1, v) * (1.0f / v31); + if (j) { + if (v25 > v33) + v25 = v33; + else if (v27 < v33) + v27 = v33; + + if (v26 > v34) + v26 = v34; + else if (v28 < v34) + v28 = v34; + } + else { + v25 = v33; + v27 = v33; + v26 = v34; + v28 = v34; + } + j++; + } + + int32_t v36 = (int32_t)v27 + 1; + int32_t v37 = (int32_t)v28 + 1; + int32_t v38 = (int32_t)v25 - 1; + int32_t v39 = (int32_t)v26 - 1; + + v36 = clamp_def(v36, x_min, x_min + x_max - 1); + v37 = clamp_def(v37, y_min, y_min + y_max - 1); + v38 = clamp_def(v38, x_min, x_min + x_max - 1); + v39 = clamp_def(v39, y_min, y_min + y_max - 1); + + int32_t v42 = v36 - v38 + 1; + int32_t v43 = v37 - v39 + 1; + if (v42 * v43 > 0) { + draw_param.copy_texture = true; + draw_param.copy_texture_x = v38; + draw_param.copy_texture_y = v39; + draw_param.copy_texture_width = v42; + draw_param.copy_texture_height = v43; + } + } + } + + draw_param.shader = args.shader; + if (draw_param.shader == SHADER_FT_FFP) { + draw_param.shader = SHADER_FT_SPRITE; + draw_param.tex_0_type = 0; + draw_param.tex_1_type = 0; + + if (tex_param_count == 1 || tex_param_count == 2) { + if (tex_param[0].texture->internal_format == GL_COMPRESSED_RED_RGTC1_EXT) + draw_param.tex_0_type = 3; + else if (tex_param[0].texture->internal_format == GL_COMPRESSED_RED_GREEN_RGTC2_EXT) + draw_param.tex_0_type = 2; + else + draw_param.tex_0_type = 1; + + if (tex_param_count == 2) { + if (tex_param[1].texture->internal_format == GL_COMPRESSED_RED_RGTC1_EXT) + draw_param.tex_1_type = 3; + else if (tex_param[1].texture->internal_format == GL_COMPRESSED_RED_GREEN_RGTC2_EXT) + draw_param.tex_1_type = 2; + else + draw_param.tex_1_type = 1; + } + } + + if (args.attr & SPR_ATTR_NOBLEND) + draw_param.combiner = 0; + else if (args.blend != 5) + draw_param.combiner = args.blend == 3 ? 1 : 0; + else + draw_param.combiner = 2; + + } + + switch (tex_param_count) { + case 0: + switch (args.kind) { + case SPR_KIND_LINES: { + if (vtx[0] == 0.0f && vtx[2] == 0.0f) { + draw_param_buffer.pop_back(); + return; + } + + sprite_draw_vertex spr_vtx[4] = {}; + spr_vtx[0].pos = vtx[0]; + spr_vtx[0].color = color; + + spr_vtx[1].pos = vtx[2]; + spr_vtx[1].color = color; + + draw_param.mode = GL_LINES; + draw_param.first = (GLint)vertex_buffer.size(); + draw_param.count = 2; + + vertex_buffer.reserve(2); + vertex_buffer.push_back(spr_vtx[0]); + vertex_buffer.push_back(spr_vtx[1]); + } break; + case SPR_KIND_RECT: { + if (vtx[0] == 0.0f && vtx[1] == 0.0f && vtx[2] == 0.0f && vtx[3] == 0.0f) { + draw_param_buffer.pop_back(); + return; + } + + sprite_draw_vertex spr_vtx[4] = {}; + spr_vtx[0].pos = vtx[0]; + spr_vtx[0].color = color; + + spr_vtx[1].pos = vtx[1]; + spr_vtx[1].color = color; + + spr_vtx[2].pos = vtx[2]; + spr_vtx[2].color = color; + + spr_vtx[3].pos = vtx[3]; + spr_vtx[3].color = color; + + draw_param.mode = GL_TRIANGLES; + draw_param.first = (GLint)vertex_buffer.size(); + draw_param.count = 6; + + vertex_buffer.reserve(6); + vertex_buffer.push_back(spr_vtx[1]); // LT + vertex_buffer.push_back(spr_vtx[0]); // LB + vertex_buffer.push_back(spr_vtx[2]); // RT + vertex_buffer.push_back(spr_vtx[3]); // RB + vertex_buffer.push_back(spr_vtx[2]); // RT + vertex_buffer.push_back(spr_vtx[0]); // LB + } break; + case SPR_KIND_MULTI: { + if (vtx[0] == 0.0f && vtx[1] == 0.0f && vtx[2] == 0.0f && vtx[3] == 0.0f) { + draw_param_buffer.pop_back(); + return; + } + + sprite_draw_vertex spr_vtx[4] = {}; + spr_vtx[0].pos = vtx[0]; + spr_vtx[0].color = color; + + spr_vtx[1].pos = vtx[1]; + spr_vtx[1].color = color; + + spr_vtx[2].pos = vtx[2]; + spr_vtx[2].color = color; + + spr_vtx[3].pos = vtx[3]; + spr_vtx[3].color = color; + + draw_param.mode = GL_LINE_LOOP; + draw_param.first = (GLint)vertex_buffer.size(); + draw_param.count = 4; + + vertex_buffer.reserve(4); + vertex_buffer.push_back(spr_vtx[0]); + vertex_buffer.push_back(spr_vtx[1]); + vertex_buffer.push_back(spr_vtx[2]); + vertex_buffer.push_back(spr_vtx[3]); + } break; + case SPR_KIND_ARROW_B: { + sprite_draw_vertex spr_vtx[2] = {}; + spr_vtx[0].color = color; + spr_vtx[1].color = color; + + if (args.num_vertex) { + size_t vertex_buffer_size = vertex_buffer.size(); + vertex_buffer.reserve(args.num_vertex / 2 * 2); + SpriteVertex* vtx = args.vertex_array; + for (size_t i = args.num_vertex / 2; i; i--, vtx += 2) { + if (vtx[0].pos == 0.0f && vtx[1].pos == 0.0f) + continue; + + spr_vtx[0].pos = vtx[0].pos; + spr_vtx[1].pos = vtx[1].pos; + vertex_buffer.push_back(spr_vtx[0]); + vertex_buffer.push_back(spr_vtx[1]); + } + + if (vertex_buffer_size == vertex_buffer.size()) { + draw_param_buffer.pop_back(); + return; + } + } + else { + if (vtx[0] == 0.0f && vtx[2] == 0.0f) { + draw_param_buffer.pop_back(); + return; + } + + spr_vtx[0].pos = vtx[0]; + spr_vtx[1].pos = vtx[2]; + + vertex_buffer.reserve(2); + vertex_buffer.push_back(spr_vtx[0]); + vertex_buffer.push_back(spr_vtx[1]); + } + } break; + case SPR_KIND_ARROW_AB: { + if (!args.num_vertex) { + draw_param_buffer.pop_back(); + return; + } + + draw_param.mode = GL_LINE_STRIP; + draw_param.first = (GLint)vertex_buffer.size(); + draw_param.count = (GLsizei)args.num_vertex; + + vertex_buffer.reserve(args.num_vertex); + + sprite_draw_vertex spr_vtx = {}; + spr_vtx.color = color; + + SpriteVertex* vtx = args.vertex_array; + for (size_t i = args.num_vertex; i; i--, vtx++) { + spr_vtx.pos = vtx->pos; + vertex_buffer.push_back(spr_vtx); + } + } break; + case SPR_KIND_TRIANGLE: { + if (!args.num_vertex) { + draw_param_buffer.pop_back(); + return; + } + + draw_param.mode = GL_TRIANGLE_STRIP; + draw_param.first = (GLint)vertex_buffer.size(); + draw_param.count = (GLsizei)args.num_vertex; + + vertex_buffer.reserve(args.num_vertex); + + sprite_draw_vertex spr_vtx = {}; + spr_vtx.color = color; + + SpriteVertex* vtx = args.vertex_array; + for (size_t i = args.num_vertex; i; i--, vtx++) { + spr_vtx.pos = vtx->pos; + vertex_buffer.push_back(spr_vtx); + } + } break; + } + break; + case 1: + draw_param.texture[0] = tex_param[0].texture->tex; + draw_param.sampler = rctx->sprite_samplers[0]; + + if (args.num_vertex) { + if (args.kind == SPR_KIND_TRIANGLE) + draw_param.sampler = rctx->sprite_samplers[1]; + + if (args.kind == SPR_KIND_TRIANGLE) { + draw_param.mode = GL_TRIANGLE_STRIP; + draw_param.first = (GLint)vertex_buffer.size(); + draw_param.count = (GLsizei)args.num_vertex; + + vertex_buffer.reserve(args.num_vertex); + + sprite_draw_vertex spr_vtx = {}; + SpriteVertex* vtx = args.vertex_array; + for (size_t i = args.num_vertex; i; i--, vtx++) { + spr_vtx.pos = vtx->pos; + spr_vtx.uv[0] = vtx->uv; + spr_vtx.color = vtx->color; + vertex_buffer.push_back(spr_vtx); + } + } + else { + size_t num_vertex = args.num_vertex / 4 * 6; + + draw_param.mode = GL_TRIANGLES; + draw_param.first = (GLint)vertex_buffer.size(); + draw_param.count = (GLsizei)num_vertex; + + size_t vertex_buffer_size = vertex_buffer.size(); + vertex_buffer.reserve(num_vertex); + + sprite_draw_vertex spr_vtx[4] = {}; + SpriteVertex* vtx = args.vertex_array; + for (size_t i = num_vertex / 6; i; i--, vtx += 4) { + if (vtx[0].pos == 0.0f && vtx[1].pos == 0.0f + && vtx[2].pos == 0.0f && vtx[3].pos == 0.0f) + continue; + + spr_vtx[0].pos = vtx[0].pos; + spr_vtx[0].uv[0] = vtx[0].uv; + spr_vtx[0].color = vtx[0].color; + spr_vtx[1].pos = vtx[1].pos; + spr_vtx[1].uv[0] = vtx[1].uv; + spr_vtx[1].color = vtx[1].color; + spr_vtx[2].pos = vtx[2].pos; + spr_vtx[2].uv[0] = vtx[2].uv; + spr_vtx[2].color = vtx[2].color; + spr_vtx[3].pos = vtx[3].pos; + spr_vtx[3].uv[0] = vtx[3].uv; + spr_vtx[3].color = vtx[3].color; + vertex_buffer.push_back(spr_vtx[1]); // LT + vertex_buffer.push_back(spr_vtx[0]); // LB + vertex_buffer.push_back(spr_vtx[2]); // RT + vertex_buffer.push_back(spr_vtx[3]); // RB + vertex_buffer.push_back(spr_vtx[2]); // RT + vertex_buffer.push_back(spr_vtx[0]); // LB + } + + if (vertex_buffer_size == vertex_buffer.size()) { + draw_param_buffer.pop_back(); + return; + } + } + } + else { + if (vtx[0] == 0.0f && vtx[1] == 0.0f && vtx[2] == 0.0f && vtx[3] == 0.0f) { + draw_param_buffer.pop_back(); + return; + } + + sprite_draw_vertex spr_vtx[4] = {}; + spr_vtx[0].pos = vtx[0]; + spr_vtx[0].uv[0].x = tex_param[0].texcoord.uv[0].u; + spr_vtx[0].uv[0].y = tex_param[0].texcoord.uv[0].v; + spr_vtx[0].color = color; + + spr_vtx[1].pos = vtx[1]; + spr_vtx[1].uv[0].x = tex_param[0].texcoord.uv[1].u; + spr_vtx[1].uv[0].y = tex_param[0].texcoord.uv[1].v; + spr_vtx[1].color = color; + + spr_vtx[2].pos = vtx[2]; + spr_vtx[2].uv[0].x = tex_param[0].texcoord.uv[2].u; + spr_vtx[2].uv[0].y = tex_param[0].texcoord.uv[2].v; + spr_vtx[2].color = color; + + spr_vtx[3].pos = vtx[3]; + spr_vtx[3].uv[0].x = tex_param[0].texcoord.uv[3].u; + spr_vtx[3].uv[0].y = tex_param[0].texcoord.uv[3].v; + spr_vtx[3].color = color; + + draw_param.mode = GL_TRIANGLES; + draw_param.first = (GLint)vertex_buffer.size(); + draw_param.count = 6; + + vertex_buffer.reserve(6); + vertex_buffer.push_back(spr_vtx[1]); // LT + vertex_buffer.push_back(spr_vtx[0]); // LB + vertex_buffer.push_back(spr_vtx[2]); // RT + vertex_buffer.push_back(spr_vtx[3]); // RB + vertex_buffer.push_back(spr_vtx[2]); // RT + vertex_buffer.push_back(spr_vtx[0]); // LB + } + break; + case 2: { + if (vtx[0] == 0.0f && vtx[1] == 0.0f && vtx[2] == 0.0f && vtx[3] == 0.0f) { + draw_param_buffer.pop_back(); + return; + } + + draw_param.texture[0] = tex_param[0].texture->tex; + draw_param.texture[1] = tex_param[1].texture->tex; + draw_param.sampler = rctx->sprite_samplers[2]; + + sprite_draw_vertex spr_vtx[4] = {}; + spr_vtx[0].pos = vtx[0]; + spr_vtx[0].uv[0].x = tex_param[0].texcoord.uv[0].u; + spr_vtx[0].uv[0].y = tex_param[0].texcoord.uv[0].v; + spr_vtx[0].uv[1].x = tex_param[1].texcoord.uv[0].u; + spr_vtx[0].uv[1].y = tex_param[1].texcoord.uv[0].v; + spr_vtx[0].color = color; + + spr_vtx[1].pos = vtx[1]; + spr_vtx[1].uv[0].x = tex_param[0].texcoord.uv[1].u; + spr_vtx[1].uv[0].y = tex_param[0].texcoord.uv[1].v; + spr_vtx[1].uv[1].x = tex_param[1].texcoord.uv[1].u; + spr_vtx[1].uv[1].y = tex_param[1].texcoord.uv[1].v; + spr_vtx[1].color = color; + + spr_vtx[2].pos = vtx[2]; + spr_vtx[2].uv[0].x = tex_param[0].texcoord.uv[2].u; + spr_vtx[2].uv[0].y = tex_param[0].texcoord.uv[2].v; + spr_vtx[2].uv[1].x = tex_param[1].texcoord.uv[2].u; + spr_vtx[2].uv[1].y = tex_param[1].texcoord.uv[2].v; + spr_vtx[2].color = color; + + spr_vtx[3].pos = vtx[3]; + spr_vtx[3].uv[0].x = tex_param[0].texcoord.uv[3].u; + spr_vtx[3].uv[0].y = tex_param[0].texcoord.uv[3].v; + spr_vtx[3].uv[1].x = tex_param[1].texcoord.uv[3].u; + spr_vtx[3].uv[1].y = tex_param[1].texcoord.uv[3].v; + spr_vtx[3].color = color; + + draw_param.mode = GL_TRIANGLES; + draw_param.first = (GLint)vertex_buffer.size(); + draw_param.count = 6; + + vertex_buffer.reserve(6); + vertex_buffer.push_back(spr_vtx[1]); // LT + vertex_buffer.push_back(spr_vtx[0]); // LB + vertex_buffer.push_back(spr_vtx[2]); // RT + vertex_buffer.push_back(spr_vtx[3]); // RB + vertex_buffer.push_back(spr_vtx[2]); // RT + vertex_buffer.push_back(spr_vtx[0]); // LB + } break; + } + + if (draw_param_buffer.size() >= 2) { + sprite_draw_param& draw_param_2 = draw_param_buffer.data()[draw_param_buffer.size() - 2]; + sprite_draw_param& draw_param_1 = draw_param_buffer.data()[draw_param_buffer.size() - 1]; + + if ((args.index == -1 || args.index == 0 || args.index == 3) + && draw_param_2.mode == draw_param_1.mode + && (draw_param_2.first + draw_param_2.count) == draw_param_1.first + && draw_param_2.blend == draw_param_1.blend + && draw_param_2.blend_src_rgb == draw_param_1.blend_src_rgb + && draw_param_2.blend_src_alpha == draw_param_1.blend_src_alpha + && draw_param_2.blend_dst_rgb == draw_param_1.blend_dst_rgb + && draw_param_2.blend_dst_alpha == draw_param_1.blend_dst_alpha + && !draw_param_2.copy_texture && !draw_param_1.copy_texture + && draw_param_2.shader == draw_param_1.shader + && draw_param_2.tex_0_type == draw_param_1.tex_0_type + && draw_param_2.tex_1_type == draw_param_1.tex_1_type + && draw_param_2.combiner == draw_param_1.combiner + && draw_param_2.texture[0] == draw_param_1.texture[0] + && draw_param_2.texture[1] == draw_param_1.texture[1] + && draw_param_2.sampler == draw_param_1.sampler) { + draw_param_2.count += draw_param_1.count; + draw_param_buffer.pop_back(); + } + } + } + + static void draw_sprite_begin() { + gl_state_disable_blend(true); + gl_state_active_bind_texture_2d(0, rctx->empty_texture_2d, true); + gl_state_bind_sampler(0, 0, true); + gl_state_active_bind_texture_2d(1, rctx->empty_texture_2d, true); + gl_state_bind_sampler(1, 0, true); + gl_state_bind_sampler(7, 0, true); + gl_state_set_blend_func_separate(GL_ONE, GL_ZERO, GL_ONE, GL_ZERO, true); + gl_state_bind_vertex_array(0, true); + gl_state_bind_uniform_buffer_base(0, 0, true); + } + + static void draw_sprite_end() { + gl_state_disable_blend(); + gl_state_active_bind_texture_2d(0, 0); + gl_state_bind_sampler(0, 0); + gl_state_active_bind_texture_2d(1, 0); + gl_state_bind_sampler(1, 0); + gl_state_active_bind_texture_2d(7, 0); + gl_state_bind_sampler(7, 0); + gl_state_set_blend_func_separate(GL_ONE, GL_ZERO, GL_ONE, GL_ZERO); + shaders_ft.set(-1); + } + + static void draw_sprite_scale(spr::SprArgs* args) { + int32_t index = args->index; + resolution_mode mode = res_window_get()->resolution_mode; + while (args) { + resolution_mode_scale_data data(args->resolution_mode_screen, mode); + if (args->resolution_mode_screen != RESOLUTION_MODE_MAX + && args->resolution_mode_screen != mode && (index == 0 || index == 3)) { + float_t scale_x = data.scale.x; + float_t scale_y = data.scale.y; + float_t src_res_x = data.src_res.x; + float_t src_res_y = data.src_res.y; + float_t dst_res_x = data.dst_res.x; + float_t dst_res_y = data.dst_res.y; + args->trans.x = (args->trans.x - src_res_x) * scale_x + src_res_x; + args->trans.y = (args->trans.y - src_res_y) * scale_y + src_res_y; + args->trans.z = args->trans.z * scale_y; + + SpriteVertex* vtx = args->vertex_array; + for (size_t i = args->num_vertex; i; i--, vtx++) { + vtx->pos.x = (vtx->pos.x - src_res_x) * scale_x + dst_res_x; + vtx->pos.y = (vtx->pos.y - src_res_y) * scale_y + dst_res_y; + } + } + + if (args->resolution_mode_sprite != RESOLUTION_MODE_MAX) { + vec2 scale = resolution_mode_get_scale(mode, args->resolution_mode_sprite); + args->scale.x = scale.x * args->scale.x; + args->scale.y = scale.y * args->scale.y; + } + args = args->next; + } + } +} + + +void sprite_manager_init() { + if (!sprite_manager_render_data) + sprite_manager_render_data = new spr::SpriteManager::RenderData; +} + +void sprite_manager_draw(int32_t index, bool font, texture* tex) { + sprite_manager->Draw(index, font, tex); +} + +void sprite_manager_set_res(double_t aspect, int32_t width, int32_t height) { + sprite_manager->aspect[0] = (float_t)aspect; + sprite_manager->field_1018[0].second = { { 0.0f, 0.0f }, { (float_t)width, (float_t)height } }; + sprite_manager->aspect[1] = (float_t)aspect; + sprite_manager->field_1018[1].second = { { 0.0f, 0.0f }, { (float_t)width, (float_t)height } }; +} + +void sprite_manager_set_view_projection(bool aet_3d) { + view_projection_aet = aet_3d + ? camera_data->view_projection_aet_3d_matrix + : camera_data->view_projection_aet_2d_matrix; +} + +void sprite_manager_free() { + if (sprite_manager_render_data) { + delete sprite_manager_render_data; + sprite_manager_render_data = 0; + } +} + +HOOK(void, FASTCALL, sprite_manager_draw, 0x000000014063F870, int32_t index, bool font, texture* tex) { + sprite_manager_draw(index, font, tex); +} + + +HOOK(void, FASTCALL, sprite_manager_set_view_projection, 0x00000001401F9590, bool aet_3d) { + sprite_manager_set_view_projection(aet_3d); +} + +void sprite_patch() { + INSTALL_HOOK(sprite_manager_draw); + INSTALL_HOOK(sprite_manager_set_view_projection); +} diff --git a/src/DivaGL/sprite.hpp b/src/DivaGL/sprite.hpp new file mode 100644 index 0000000..6ca135e --- /dev/null +++ b/src/DivaGL/sprite.hpp @@ -0,0 +1,201 @@ +/* + by korenkonder + GitHub/GitLab: korenkonder +*/ + +#pragma once + +#include "../KKdLib/default.hpp" +#include "../KKdLib/mat.hpp" +#include "../KKdLib/vec.hpp" +#include "gl_state.hpp" +#include "render_context.hpp" +#include "resolution_mode.hpp" +#include "texture.hpp" +#include "types.hpp" + +struct rectangle { + vec2 pos; + vec2 size; +}; + +struct spr_info { + uint16_t index; + uint16_t set_index; +}; + +struct SpriteHeaderFile { + uint32_t flag; + uint32_t texofs; + int32_t num_of_texture; + int32_t num_of_sprite; + uint32_t sprinfo_offset; + uint32_t texname_offset; + uint32_t sprname_offset; + uint32_t sprdata_offset; +}; + +struct SpriteHeader { + uint32_t flag; + uint32_t texofs; + int32_t num_of_texture; + int32_t num_of_sprite; + spr::SprInfo* sprinfo; + const char** texname; + const char** sprname; + SpriteData* sprdata; +}; + +struct shared_ptr_prj__stack_allocator { + void* ptr; + void* ref; +}; + +struct SprSet { + void* vftable; + int32_t flag; + int32_t index; + SpriteHeaderFile* header_file; + SpriteHeader* header; + texture** textures; + int32_t load_count; + void* file_handler; + bool ready; + shared_ptr_prj__stack_allocator alloc_handler; + prj::string file; +}; + +namespace spr { + enum SprAttr : uint32_t { + SPR_ATTR_FLIP_H = 0x00010000, + SPR_ATTR_FLIP_V = 0x00020000, + SPR_ATTR_CTR_LT = 0x00040000, + SPR_ATTR_CTR_CT = 0x00080000, + SPR_ATTR_CTR_RT = 0x00100000, + SPR_ATTR_CTR_LC = 0x00200000, + SPR_ATTR_CTR_CC = 0x00400000, + SPR_ATTR_CTR_RC = 0x00800000, + SPR_ATTR_CTR_LB = 0x01000000, + SPR_ATTR_CTR_CB = 0x02000000, + SPR_ATTR_CTR_RB = 0x04000000, + SPR_ATTR_MATRIX = 0x08000000, + SPR_ATTR_10000000 = 0x10000000, + SPR_ATTR_NOBLEND = 0x20000000, + + SPR_ATTR_CTR = 0x07FC0000, + }; + + enum SprKind { + SPR_KIND_NORMAL = 0, + SPR_KIND_LINE, + SPR_KIND_LINES, + SPR_KIND_RECT, + SPR_KIND_MULTI, + SPR_KIND_ARROW_A, + SPR_KIND_ARROW_B, + SPR_KIND_ARROW_AB, + SPR_KIND_TRIANGLE, + SPR_KIND_CIRCLE, + }; + + enum SprPrio { + SPR_PRIO_00 = 0, + SPR_PRIO_01, + SPR_PRIO_02, + SPR_PRIO_03, + SPR_PRIO_04, + SPR_PRIO_05, + SPR_PRIO_06, + SPR_PRIO_07, + SPR_PRIO_08, + SPR_PRIO_09, + SPR_PRIO_10, + SPR_PRIO_11, + SPR_PRIO_12, + SPR_PRIO_13, + SPR_PRIO_14, + SPR_PRIO_15, + SPR_PRIO_16, + SPR_PRIO_17, + SPR_PRIO_18, + SPR_PRIO_19, + SPR_PRIO_20, + SPR_PRIO_21, + SPR_PRIO_22, + SPR_PRIO_23, + SPR_PRIO_24, + SPR_PRIO_25, + SPR_PRIO_26, + SPR_PRIO_27, + SPR_PRIO_28, + SPR_PRIO_29, + SPR_PRIO_30, + SPR_PRIO_31, + SPR_PRIO_MAX, + }; + + struct SpriteVertex { + vec3 pos; + vec2 uv; + vec4u8 color; + }; + + struct SprArgs { + enum Flags : uint32_t { + SPRITE_SIZE = 0x01, + TEXTURE_POS_SIZE = 0x02, + }; + + union IDUnion { + int32_t index; + uint32_t id; + spr_info info; + + IDUnion() { + index = -1; + id = -1; + info = {}; + } + }; + + SprKind kind; + IDUnion id; + vec4u8 color; + SprAttr attr; + int32_t blend; + int32_t index; + int32_t layer; + SprPrio prio; + resolution_mode resolution_mode_screen; + resolution_mode resolution_mode_sprite; + vec3 center; + vec3 trans; + vec3 scale; + vec3 rot; + vec2 skew_angle; + mat4 mat; + texture* texture; + int32_t shader; + SpriteVertex* vertex_array; + size_t num_vertex; + Flags flags; + vec2 sprite_size; + int32_t field_CC; + vec2 texture_pos; + vec2 texture_size; + spr::SprArgs* next; + }; + + + extern void(FASTCALL* put_rgb_cross)(mat4* mat); +} + +extern size_t(FASTCALL* sprite_manager_get_reqlist_count)(int32_t index); + +extern void sprite_manager_init(); +extern void sprite_manager_draw(int32_t index, bool font, texture* tex); +extern void sprite_manager_set_res(double_t aspect, int32_t width, int32_t height); +extern void sprite_manager_set_view_projection(bool aet_3d); +extern void sprite_manager_free(); + +extern void sprite_patch(); diff --git a/src/DivaGL/stage.cpp b/src/DivaGL/stage.cpp new file mode 100644 index 0000000..a38f185 --- /dev/null +++ b/src/DivaGL/stage.cpp @@ -0,0 +1,206 @@ +/* + by korenkonder + GitHub/GitLab: korenkonder +*/ + +#include "stage.hpp" +#include "../KKdLib/mat.hpp" +#include "../KKdLib/vec.hpp" +#include "object.hpp" +#include "render_context.hpp" +#include + +enum stage_data_flags { + STAGE_DATA_FLAG_1 = 0x01, + STAGE_DATA_LIGHT_CHARA_AMBIENT = 0x02, + STAGE_DATA_FLAG_4 = 0x04, + STAGE_DATA_FLAG_8 = 0x08, +}; + +struct stage_data_reflect { + reflect_refract_resolution_mode mode; + int32_t blur_num; + blur_filter_mode blur_filter; +}; + +static_assert(sizeof(stage_data_reflect) == 0x0C, "\"stage_data_reflect\" struct should have a size of 0x0C"); + +struct stage_data_refract { + reflect_refract_resolution_mode mode; +}; + +static_assert(sizeof(stage_data_refract) == 0x04, "\"stage_data_refract\" struct should have a size of 0x04"); + +struct stage_data { + const char* name; + const char* auth_3d_name; + int32_t object_set_id; + object_info object_ground; + object_info object_ring; + object_info object_sky; + object_info object_shadow; + object_info object_reflect; + object_info object_refract; + uint32_t lens_flare_texture; + uint32_t lens_shaft_texture; + uint32_t lens_ghost_texture; + float_t lens_shaft_inv_scale; + uint32_t field_3C; + uint32_t render_texture; + uint32_t movie_texture; + const char* collision_file_path; + stage_data_reflect_type reflect_type; + bool refract; + stage_data_reflect* reflect_data; + stage_data_refract* refract_data; + stage_data_flags flags; + float_t ring_rectangle_x; + float_t ring_rectangle_y; + float_t ring_rectangle_width; + float_t ring_rectangle_height; + float_t ring_height; + float_t ring_out_height; + int32_t field_84; +}; + +static_assert(sizeof(stage_data) == 0x88, "\"stage_data\" struct should have a size of 0x88"); + +struct stage { + int32_t index; + uint16_t counter; + int32_t state; + stage_data* stage_data; + bool stage_display; + bool lens_flare; + bool ground; + bool ring; + bool sky; + bool auth_3d_loaded; + mat4 mat; + float_t rot_y; + uint32_t obj_set; +}; + +static_assert(sizeof(stage) == 0x68, "\"stage\" struct should have a size of 0x68"); + + +static bool object_bounding_sphere_check_visibility_shadow(obj_bounding_sphere* sphere, mat4* mat); +static bool object_bounding_sphere_check_visibility_shadow_chara(obj_bounding_sphere* sphere); +static bool object_bounding_sphere_check_visibility_shadow_stage(obj_bounding_sphere* sphere); + +HOOK(void, FASTCALL, stage__disp, 0x0000000140649560, stage* s) { + if (s->state != 6 || !s->stage_display) + return; + + mdl::DispManager& disp_manager = *::disp_manager; + + mat4 mat; + mat4_rotate_y(s->rot_y, &mat); + + if (s->stage_data->object_ground.not_null() && s->ground) + disp_manager.entry_obj_by_object_info(&mat, s->stage_data->object_ground); + + if (s->stage_data->object_ring.not_null() && s->ring) + disp_manager.entry_obj_by_object_info(&mat, s->stage_data->object_ring); + + if (s->stage_data->object_reflect.not_null()) { + disp_manager.set_obj_flags((mdl::ObjFlags)(mdl::OBJ_NO_TRANSLUCENCY | mdl::OBJ_REFLECT)); + disp_manager.entry_obj_by_object_info(&mat, s->stage_data->object_reflect); + disp_manager.set_obj_flags(); + } + + if (s->stage_data->object_refract.not_null()) { + disp_manager.set_obj_flags((mdl::ObjFlags)(mdl::OBJ_NO_TRANSLUCENCY | mdl::OBJ_REFRACT)); + disp_manager.entry_obj_by_object_info(&mat, s->stage_data->object_refract); + disp_manager.set_obj_flags(); + } + + if (s->stage_data->object_sky.not_null() && s->sky) { + mat4 t = s->mat; + mat4_mul(&t, &mat, &t); + disp_manager.entry_obj_by_object_info(&t, s->stage_data->object_sky); + } + + if (s->stage_data->lens_flare_texture != -1 && s->lens_flare) { + int32_t object_set_id = s->stage_data->object_set_id; + rndr::Render* rend = render; + rend->lens_flare_texture = obj_database_get_obj_set_texture( + object_set_id, s->stage_data->lens_flare_texture); + if (rend->lens_flare_texture) { + rend->lens_shaft_texture = obj_database_get_obj_set_texture( + object_set_id, s->stage_data->lens_shaft_texture); + rend->lens_ghost_texture = obj_database_get_obj_set_texture( + object_set_id, s->stage_data->lens_ghost_texture); + rend->lens_ghost_count = 16; + rend->lens_shaft_inv_scale = s->stage_data->lens_shaft_inv_scale; + } + } +} + +static void stage__disp_shadow_object(object_info object, mat4* mat) { + mdl::DispManager& disp_manager = *::disp_manager; + + for (int32_t i = SHADOW_CHARA; i < SHADOW_MAX; i++) { + disp_manager.set_shadow_type((shadow_type_enum)i); + disp_manager.set_culling_finc(i == SHADOW_CHARA + ? object_bounding_sphere_check_visibility_shadow_chara + : object_bounding_sphere_check_visibility_shadow_stage); + disp_manager.set_obj_flags((mdl::ObjFlags)(mdl::OBJ_NO_TRANSLUCENCY | mdl::OBJ_SHADOW_OBJECT)); + disp_manager.entry_obj_by_object_info(mat, object); + } + + disp_manager.set_obj_flags(); + disp_manager.set_culling_finc(); + disp_manager.set_shadow_type(); +} + + +HOOK(void, FASTCALL, stage__disp_shadow, 0x00000001406497C0, stage* s) { + if (s->state != 6 || !s->stage_display) + return; + + mat4 mat; + mat4_rotate_y(s->rot_y, &mat); + if (s->stage_data->object_shadow.not_null()) + stage__disp_shadow_object(s->stage_data->object_shadow, &mat); +} + +void stage_patch() { + INSTALL_HOOK(stage__disp); + INSTALL_HOOK(stage__disp_shadow); +} + +static bool object_bounding_sphere_check_visibility_shadow(obj_bounding_sphere* sphere, mat4* mat) { + mat4 view_matrix; + mat4_transpose(&camera_data->view_matrix, &view_matrix); + + vec3 center; + mat4_transform_point(mat, &sphere->center, ¢er); + mat4_transform_point(&view_matrix, ¢er, ¢er); + float_t radius = sphere->radius; + + Shadow* shad = shadow_ptr_get(); + float_t v9 = shad->view_region * shad->range; + if ((center.x + radius) < -v9 + || (center.x - radius) > v9 + || (center.y + radius) < -v9 + || (center.y - radius) > v9 + || (center.z - radius) > -shad->z_near + || (center.z + radius) < -shad->z_far) + return false; + return true; +} + +static bool object_bounding_sphere_check_visibility_shadow_chara(obj_bounding_sphere* sphere) { + mat4 mat; + Shadow* shad = shadow_ptr_get(); + mat4_look_at(&shad->view_point[0], &shad->interest[0], &mat); + return object_bounding_sphere_check_visibility_shadow(sphere, &mat); +} + +static bool object_bounding_sphere_check_visibility_shadow_stage(obj_bounding_sphere* sphere) { + mat4 mat; + Shadow* shad = shadow_ptr_get(); + mat4_look_at(&shad->view_point[1], &shad->interest[1], &mat); + return object_bounding_sphere_check_visibility_shadow(sphere, &mat); +} diff --git a/src/DivaGL/stage.hpp b/src/DivaGL/stage.hpp new file mode 100644 index 0000000..25f44aa --- /dev/null +++ b/src/DivaGL/stage.hpp @@ -0,0 +1,10 @@ +/* + by korenkonder + GitHub/GitLab: korenkonder +*/ + +#pragma once + +#include "../KKdLib/default.hpp" + +extern void stage_patch(); diff --git a/src/DivaGL/stage_param.cpp b/src/DivaGL/stage_param.cpp new file mode 100644 index 0000000..eee9d05 --- /dev/null +++ b/src/DivaGL/stage_param.cpp @@ -0,0 +1,8 @@ +/* + by korenkonder + GitHub/GitLab: korenkonder +*/ + +#include "stage_param.hpp" + +stage_param_data_litproj** stage_param_data_litproj_current = (stage_param_data_litproj**)0x0000000141194D80; diff --git a/src/DivaGL/stage_param.hpp b/src/DivaGL/stage_param.hpp new file mode 100644 index 0000000..c38b9ee --- /dev/null +++ b/src/DivaGL/stage_param.hpp @@ -0,0 +1,172 @@ +/* + by korenkonder + GitHub/GitLab: korenkonder +*/ + +#pragma once + +#include "../KKdLib/default.hpp" +#include "../KKdLib/vec.hpp" +#include "object.hpp" +#include "types.hpp" + +/*struct stage_param_data_coli { + int32_t pv_id; + prj::map stage_ring_data; + prj::map mhd_id_ring_data; + prj::map stage_wind_file; +}; + +static_assert(sizeof(stage_param_data_coli) == 0x38, "\"stage_param_data_coli\" struct should have a size of 0x38");*/ + +struct stage_param_data_fog_ring { + int32_t num_ptcls; + float_t ring_size; + vec3 wind_dir; + int32_t tex_id; + vec4 color; + float_t ptcl_size; + float_t density; + float_t density_offset; +}; + +static_assert(sizeof(stage_param_data_fog_ring) == 0x34, "\"stage_param_data_fog_ring\" struct should have a size of 0x34"); + +struct stage_param_data_leaf_lie_plane_xz { + float_t min_x; + float_t max_x; + float_t min_z; + float_t max_z; +}; + +static_assert(sizeof(stage_param_data_leaf_lie_plane_xz) == 0x10, "\"stage_param_data_fog_ring\" struct should have a size of 0x10"); + +struct stage_param_data_leaf { + int32_t tex_id; + vec4 color; + float_t psize; + int32_t num_initial_ptcls; + float_t frame_speed_coef; + float_t emit_interval; + vec3 wind; + vec3 range; + vec3 offset; + stage_param_data_leaf_lie_plane_xz lie_plane_xz; + bool split_tex; +}; + +static_assert(sizeof(stage_param_data_leaf) == 0x5C, "\"stage_param_data_leaf\" struct should have a size of 0x5C"); + +struct stage_param_data_litproj { + int32_t tex_id; +}; + +static_assert(sizeof(stage_param_data_litproj) == 0x04, "\"stage_param_data_litproj\" struct should have a size of 0x04"); + +struct stage_param_data_rain { + int32_t tex_id; + int32_t num_rain; + vec4 color; + vec3 velocity; + vec3 vel_range; + vec2 psize; + vec3 range; + vec3 offset; +}; + +static_assert(sizeof(stage_param_data_rain) == 0x50, "\"stage_param_data_rain\" struct should have a size of 0x50"); + +struct stage_param_data_ripple { + size_t rain_ripple_num; + float_t rain_ripple_min_value; + float_t rain_ripple_max_value; + float_t ground_y; + float_t emit_pos_scale; + float_t emit_pos_ofs_x; + float_t emit_pos_ofs_z; + float_t wake_attn; + float_t speed; + int32_t ripple_tex_id; + bool use_float_ripplemap; + float_t rob_emitter_size; + vec3* emitter_list; + size_t emitter_num; + float_t emitter_size; +}; + +static_assert(sizeof(stage_param_data_ripple) == 0x50, "\"stage_param_data_ripple\" struct should have a size of 0x50"); + +struct stage_param_data_snow_colli_ground { + float_t min_x; + float_t max_x; + float_t min_z; + float_t max_z; + float_t y; +}; + +static_assert(sizeof(stage_param_data_snow_colli_ground) == 0x14, "\"stage_param_data_snow_colli_ground\" struct should have a size of 0x14"); + +struct stage_param_data_snow { + int32_t tex_id; + int32_t num_snow; + int32_t num_snow_gpu; + vec4 color; + vec3 velocity; + vec3 vel_range; + vec3 range; + vec3 range_gpu; + vec3 offset; + vec3 offset_gpu; + stage_param_data_snow_colli_ground colli_ground; +}; + +static_assert(sizeof(stage_param_data_snow) == 0x78, "\"stage_param_data_snow\" struct should have a size of 0x78"); + +struct stage_param_data_splash { + int32_t splash_tex_id; + object_info splash_obj_id; + float_t particle_size; + int32_t emit_num; + float_t emission_ratio_attn; + float_t emission_velocity_scale; + float_t ripple_emission; + vec4 color; + bool in_water; + bool blink; +}; + +static_assert(sizeof(stage_param_data_splash) == 0x30, "\"stage_param_data_splash\" struct should have a size of 0x30"); + +struct stage_param_data_star_utc { + int32_t year; + int32_t month; + int32_t day; + int32_t hour; + int32_t minute; + float_t second; +}; + +static_assert(sizeof(stage_param_data_star_utc) == 0x18, "\"stage_param_data_star_utc\" struct should have a size of 0x18"); + +struct stage_param_data_star_modifiers { + float_t color_scale; + float_t pos_scale; + float_t offset_scale; + float_t threshold; + float_t size_max; +}; + +static_assert(sizeof(stage_param_data_star_modifiers) == 0x14, "\"stage_param_data_star_modifiers\" struct should have a size of 0x14"); + +struct stage_param_data_star { + int32_t tex_id; + stage_param_data_star_utc utc; + float_t rotation_y_deg; + float_t observer_north_latitude_deg; + float_t observer_east_longitude_deg; + stage_param_data_star_modifiers modifiers[2]; +}; + +static_assert(sizeof(stage_param_data_star) == 0x50, "\"stage_param_data_star\" struct should have a size of 0x50"); + +extern stage_param_data_litproj** stage_param_data_litproj_current; diff --git a/src/DivaGL/texture.cpp b/src/DivaGL/texture.cpp new file mode 100644 index 0000000..eaef4ad --- /dev/null +++ b/src/DivaGL/texture.cpp @@ -0,0 +1,106 @@ +/* + by korenkonder + GitHub/GitLab: korenkonder +*/ + +#include "texture.hpp" +#include "../KKdLib/mat.hpp" +#include "../KKdLib/txp.hpp" +#include "gl_state.hpp" +#include + +static void texture_bind(GLenum target, GLuint texture); + +texture* (FASTCALL* _texture_init)(texture_id id) + = (texture * (FASTCALL*)(texture_id id))0x000000014069A390; +texture* (FASTCALL* _texture_copy)(texture_id id, texture* org_tex) + = (texture * (FASTCALL*)(texture_id id, texture * org_tex))0x000000014069B550; +texture* (FASTCALL* texture_load_tex_cubemap)(uint32_t id, GLenum internal_format, + int32_t width, int32_t height, int32_t max_mipmap_level, void** data_ptr) + = (texture * (FASTCALL*)(uint32_t id, GLenum internal_format, int32_t width, + int32_t height, int32_t max_mipmap_level, void** data_ptr))0x000000014069B860; +texture* (FASTCALL* texture_load_tex_2d)(texture_id id, GLenum internal_format, + int32_t width, int32_t height, int32_t max_mipmap_level, void** data_ptr, bool use_high_anisotropy) + = (texture * (FASTCALL*)(texture_id id, GLenum internal_format, int32_t width, int32_t height, + int32_t max_mipmap_level, void** data_ptr, bool use_high_anisotropy))0x000000014069B8E0; +void(FASTCALL* texture_free)(texture* tex) + = (void(FASTCALL*)(texture * tex))0x000000014069DA70; +int32_t(FASTCALL* texture_info_get_id)(const char* name) + = (int32_t(FASTCALL*)(const char* name))0x000000014069CBD0; +texture* (FASTCALL* texture_handler_get_texture)(uint32_t id) + = (texture * (FASTCALL*)(uint32_t id))0x000000014069CD70; + +void texture_set_params(GLenum target, int32_t max_mipmap_level, bool use_high_anisotropy) { + glTexParameteriDLL(target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); + glTexParameteriDLL(target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); + glTexParameteriDLL(target, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE); + static const vec4 border_color = 0.0f; + glTexParameterfvDLL(target, GL_TEXTURE_BORDER_COLOR, (GLfloat*)&border_color); + glTexParameteriDLL(target, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + glTexParameteriDLL(target, GL_TEXTURE_MIN_FILTER, + max_mipmap_level > 0 ? GL_LINEAR_MIPMAP_LINEAR : GL_LINEAR); + glTexParameteriDLL(target, GL_TEXTURE_BASE_LEVEL, 0); + glTexParameteriDLL(target, GL_TEXTURE_MAX_LEVEL, max_mipmap_level); + + float_t max_anisotropy; + if (use_high_anisotropy) + max_anisotropy = 16.0f; + else + max_anisotropy = 1.0f; + glTexParameterfDLL(target, GL_TEXTURE_MAX_ANISOTROPY_EXT, max_anisotropy); +} + +void texture_params_get(GLuint tex_0, texture_param* tex_0_param, + GLuint tex_1, texture_param* tex_1_param, GLuint tex_2, texture_param* tex_2_param) { + gl_state_disable_depth_test(); + if (tex_0_param) { + tex_0_param->width = 0; + tex_0_param->height = 0; + if (tex_0) { + gl_state_bind_texture_2d(tex_0); + glGetTexLevelParameterivDLL(GL_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &tex_0_param->width); + glGetTexLevelParameterivDLL(GL_TEXTURE_2D, 0, GL_TEXTURE_HEIGHT, &tex_0_param->height); + } + } + + if (tex_1_param) { + tex_1_param->width = 0; + tex_1_param->height = 0; + if (tex_1) { + gl_state_bind_texture_2d(tex_1); + glGetTexLevelParameterivDLL(GL_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &tex_1_param->width); + glGetTexLevelParameterivDLL(GL_TEXTURE_2D, 0, GL_TEXTURE_HEIGHT, &tex_1_param->height); + } + } + + if (tex_2_param) { + tex_2_param->width = 0; + tex_2_param->height = 0; + if (tex_2) { + gl_state_bind_texture_2d(tex_2); + glGetTexLevelParameterivDLL(GL_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &tex_2_param->width); + glGetTexLevelParameterivDLL(GL_TEXTURE_2D, 0, GL_TEXTURE_HEIGHT, &tex_2_param->height); + } + } + gl_state_bind_texture_2d(0); + + if (tex_0_param) + glViewportDLL(0, 0, tex_0_param->width, tex_0_param->height); +} + +void texture_params_restore(texture_param* tex_0_param, + texture_param* tex_1_param, texture_param* tex_2_param) { + for (int32_t i = 0; i < 4; i++) + gl_state_active_bind_texture_2d(i, 0); +} + +inline static void texture_bind(GLenum target, GLuint texture) { + switch (target) { + case GL_TEXTURE_2D: + gl_state_bind_texture_2d(texture, true); + break; + case GL_TEXTURE_CUBE_MAP: + gl_state_bind_texture_cube_map(texture, true); + break; + } +} diff --git a/src/DivaGL/texture.hpp b/src/DivaGL/texture.hpp new file mode 100644 index 0000000..5b16489 --- /dev/null +++ b/src/DivaGL/texture.hpp @@ -0,0 +1,95 @@ +/* + by korenkonder + GitHub/GitLab: korenkonder +*/ + +#pragma once + +#include "../KKdLib/default.hpp" +#include "../KKdLib/image.hpp" +#include "../KKdLib/txp.hpp" +#include "wrap.hpp" + +enum texture_flags { + TEXTURE_BLOCK_COMPRESSION = 0x01, +}; + +struct texture_id { + uint32_t index : 24; + uint32_t id : 8; + + inline texture_id() { + id = 0; + index = 0; + } + + inline texture_id(uint8_t id, uint32_t index) { + this->id = id; + this->index = index; + } +}; + +inline bool operator >(const texture_id& left, const texture_id& right) { + return left.id > right.id && left.index > right.index; +} + +inline bool operator <(const texture_id& left, const texture_id& right) { + return left.id < right.id && left.index < right.index; +} + +inline bool operator >=(const texture_id& left, const texture_id& right) { + return left.id >= right.id && left.index >= right.index; +} + +inline bool operator <=(const texture_id& left, const texture_id& right) { + return left.id <= right.id && left.index <= right.index; +} + +inline bool operator ==(const texture_id& left, const texture_id& right) { + return left.id == right.id && left.index == right.index; +} + +inline bool operator !=(const texture_id& left, const texture_id& right) { + return left.id != right.id || left.index != right.index; +} + +static_assert(sizeof(texture_id) == 0x04, "\"texture_id\" struct should have a size of 0x04"); + +struct texture { + int32_t init_count; + texture_id id; + texture_flags flags; + int16_t width; + int16_t height; + GLuint tex; + GLenum target; + GLenum internal_format; + int32_t max_mipmap_level; + int32_t size; +}; + +static_assert(sizeof(texture) == 0x24, "\"texture\" struct should have a size of 0x24"); + +struct texture_param { + GLint width; + GLint height; +}; + +static_assert(sizeof(texture_param) == 0x08, "\"texture_param\" struct should have a size of 0x08"); + +extern texture* (FASTCALL* texture_init)(texture_id id); +extern texture* (FASTCALL* texture_copy)(texture_id id, texture* org_tex); +extern texture* (FASTCALL* texture_load_tex_cubemap)(uint32_t id, GLenum internal_format, + int32_t width, int32_t height, int32_t max_mipmap_level, void** data_ptr); +extern texture* (FASTCALL* texture_load_tex_2d)(texture_id id, GLenum internal_format, + int32_t width, int32_t height, int32_t max_mipmap_level, void** data_ptr, bool use_high_anisotropy); +extern void(FASTCALL* texture_free)(texture* tex); +extern int32_t(FASTCALL* texture_info_get_id)(const char* name); +extern texture* (FASTCALL* texture_handler_get_texture)(uint32_t id); + +extern void texture_set_params(GLenum target, int32_t max_mipmap_level, bool use_high_anisotropy); + +extern void texture_params_get(GLuint tex_0 = 0, texture_param* tex_0_param = 0, + GLuint tex_1 = 0, texture_param* tex_1_param = 0, GLuint tex_2 = 0, texture_param* tex_2_param = 0); +extern void texture_params_restore(texture_param* tex_0_param = 0, + texture_param* tex_1_param = 0, texture_param* tex_2_param = 0); diff --git a/src/DivaGL/types.hpp b/src/DivaGL/types.hpp new file mode 100644 index 0000000..3265e2a --- /dev/null +++ b/src/DivaGL/types.hpp @@ -0,0 +1,72 @@ +/* + by korenkonder + GitHub/GitLab: korenkonder + + Original: Allocator.h, Types.h by blueskythlikesclouds from DivaModLoader +*/ + +#include "../KKdLib/default.hpp" +#include +#include +#include + +#pragma once + +typedef enum HeapCMallocType { + HeapCMallocSystem = 0x00, + HeapCMallocTemp = 0x01, + HeapCMallocMode = 0x02, + HeapCMallocEvent = 0x03, + HeapCMallocDebug = 0x04, + HeapCMallocMax = 0x05, +} HeapCMallocType; + +static void* (*HeapCMallocAllocate)(HeapCMallocType type, size_t size, const char* name) + = (void* (*)(HeapCMallocType, size_t, const char*))0x00000001403F2A00; +static void(*HeapCMallocFree)(HeapCMallocType type, void* data) + = (void(*)(HeapCMallocType, void*))0x00000001403F2960; +static void* (*_operator_new)(size_t) = (void* (*)(size_t))0x000000014084530C; +static void(*_operator_delete)(void*) = (void(*)(void*))0x0000000140845378; + +template +class Allocator { +public: + using value_type = T; + + Allocator() noexcept {} + template Allocator(Allocator const&) noexcept {} + + value_type* allocate(std::size_t n) { + return reinterpret_cast(_operator_new(n * sizeof(value_type))); + } + + void deallocate(value_type* p, std::size_t) noexcept { + _operator_delete(reinterpret_cast(p)); + } +}; + +template +bool operator==(Allocator const&, Allocator const&) noexcept { + return true; +} + +template +bool operator!=(Allocator const& x, Allocator const& y) noexcept { + return !(x == y); +} + +namespace prj { + using string = std::basic_string, Allocator>; + + template + using vector = std::vector>; + + template + using list = std::list>; + + template + using map = std::map>>; + + template + using pair = std::pair; +} diff --git a/src/DivaGL/uniform.cpp b/src/DivaGL/uniform.cpp new file mode 100644 index 0000000..33fb947 --- /dev/null +++ b/src/DivaGL/uniform.cpp @@ -0,0 +1,10 @@ +/* + by korenkonder + GitHub/GitLab: korenkonder +*/ + +#include "uniform.hpp" + +uniform_value* uniform = (uniform_value*)0x000000014CC57AF0; + +void(FASTCALL* uniform_value_reset)() = (void(FASTCALL*)())0x0000000140443400; diff --git a/src/DivaGL/uniform.hpp b/src/DivaGL/uniform.hpp new file mode 100644 index 0000000..93d6bbe --- /dev/null +++ b/src/DivaGL/uniform.hpp @@ -0,0 +1,91 @@ +/* + by korenkonder + GitHub/GitLab: korenkonder +*/ + +#pragma once + +#include "../KKdLib/default.hpp" + +enum uniform_name { + U_NONE = 0x00, + U_ALPHA_MASK = 0x01, + U_ALPHA_TEST = 0x02, + U_ANISO = 0x03, + U_AET_BACK = 0x04, + U_TEXTURE_BLEND = 0x05, + U_CHARA_COLOR = 0x06, + U_CLIP_PLANE = 0x07, + U08 = 0x08, + U_DEPTH_PEEL = 0x09, + U0A = 0x0A, + U0B = 0x0B, + U_ALPHA_BLEND = 0x0C, + U_RIPPLE_EMIT = 0x0D, + U_ESM_FILTER = 0x0E, + U_EXPOSURE = 0x0F, + U_SCENE_FADE = 0x10, + U_FADE = 0x11, + U12 = 0x12, + U_FLARE = 0x13, + U_FOG_HEIGHT = 0x14, + U_FOG = 0x15, + U16 = 0x16, + U_GAUSS = 0x17, + U18 = 0x18, + U_IMAGE_FILTER = 0x19, + U_INSTANCE = 0x1A, + U_TONE_CURVE = 0x1B, + U_LIGHT_PROJ = 0x1C, + U_MAGNIFY = 0x1D, + U_MEMBRANE = 0x1E, + U_MLAA = 0x1F, + U_MLAA_SEARCH = 0x20, + U_MORPH_COLOR = 0x21, + U_MORPH = 0x22, + U_MOVIE = 0x23, + U24 = 0x24, + U25 = 0x25, + U26 = 0x26, + U_NPR = 0x27, + U_LIGHT_1 = 0x28, + U_REFLECT = 0x29, + U_REDUCE = 0x2A, + U_SELF_SHADOW = 0x2B, + U_SHADOW = 0x2C, + U2D = 0x2D, + U2E = 0x2E, + U_SHOW_VECTOR = 0x2F, + U_BONE_MAT = 0x30, + U_SNOW_PARTICLE = 0x31, + U_SPECULAR_IBL = 0x32, + U_COMBINER = 0x33, + U_TEX_0_TYPE = 0x34, + U_TEX_1_TYPE = 0x35, + U_SSS_FILTER = 0x36, + U37 = 0x37, + U_STAR = 0x38, + U_TEXTURE_COUNT = 0x39, + U_ENV_MAP = 0x3A, + U_RIPPLE = 0x3B, + U_TRANSLUCENCY = 0x3C, + U_NORMAL = 0x3D, + U_TRANSPARENCY = 0x3E, + U_WATER_REFLECT = 0x3F, + U40 = 0x40, + U41 = 0x41, + U_LIGHT_0 = 0x42, + U_SPECULAR = 0x43, + U_TONE_MAP = 0x44, + U45 = 0x45, + U_MAX = 0x46, + U_INVALID = 0xFFFFFFFF, +}; + +struct uniform_value { + int32_t arr[U_MAX]; +}; + +extern uniform_value* uniform; + +extern void(FASTCALL* uniform_value_reset)(); diff --git a/src/DivaGL/wrap.cpp b/src/DivaGL/wrap.cpp new file mode 100644 index 0000000..52a0ee1 --- /dev/null +++ b/src/DivaGL/wrap.cpp @@ -0,0 +1,2580 @@ +/* + by korenkonder + GitHub/GitLab: korenkonder +*/ + +#include "wrap.hpp" +#include "../KKdLib/half_t.hpp" +#include "../KKdLib/mat.hpp" +#include "../KKdLib/vec.hpp" +#include "inject.hpp" +#include "print.hpp" +#include "shader_glsl_ft.hpp" +#include +#include + +struct func_struct { + size_t address; + size_t orig_func; + size_t func; +}; + +#define GLALPHAFUNCDLL 0 +#define GLBEGINDLL 1 +#define GLBINDTEXTUREDLL 2 +#define GLCLEARDLL 3 +#define GLCLEARCOLORDLL 4 +#define GLCLEARDEPTHDLL 5 +#define GLCLEARSTENCILDLL 6 +#define GLCOLOR3FDLL 7 +#define GLCOLOR4FDLL 8 +#define GLCOLOR4UBDLL 9 +#define GLCOLOR4UBVDLL 10 +#define GLCOLORPOINTERDLL 11 +#define GLCOPYTEXIMAGE2DDLL 12 +#define GLCOPYTEXSUBIMAGE2DDLL 13 +#define GLCULLFACEDLL 14 +#define GLDEPTHFUNCDLL 15 +#define GLDISABLEDLL 16 +#define GLDISABLECLIENTSTATEDLL 17 +#define GLDRAWARRAYSDLL 18 +#define GLDRAWBUFFERDLL 19 +#define GLDRAWELEMENTSDLL 20 +#define GLENABLEDLL 21 +#define GLENABLECLIENTSTATEDLL 22 +#define GLENDDLL 23 +#define GLFOGFDLL 24 +#define GLFOGFVDLL 25 +#define GLFOGIDLL 26 +#define GLFRONTFACEDLL 27 +#define GLFRUSTUMDLL 28 +#define GLGETBOOLEANVDLL 29 +#define GLGETERRORDLL 30 +#define GLGETFLOATVDLL 31 +#define GLGETINTEGERVDLL 32 +#define GLGETMATERIALFVDLL 33 +#define GLGETTEXIMAGEDLL 34 +#define GLGETTEXLEVELPARAMETERIVDLL 35 +#define GLGETTEXPARAMETERIVDLL 36 +#define GLISENABLEDDLL 37 +#define GLLIGHTFVDLL 38 +#define GLLIGHTMODELFVDLL 39 +#define GLLINEWIDTHDLL 40 +#define GLLOADIDENTITYDLL 41 +#define GLLOADMATRIXFDLL 42 +#define GLMATERIALFDLL 43 +#define GLMATERIALFVDLL 44 +#define GLMATRIXMODEDLL 45 +#define GLMULTMATRIXDDLL 46 +#define GLNORMAL3FDLL 47 +#define GLNORMALPOINTERDLL 48 +#define GLORTHODLL 49 +#define GLPIXELSTOREIDLL 50 +#define GLPOINTSIZEDLL 51 +#define GLPOLYGONMODEDLL 52 +#define GLPOPATTRIBDLL 53 +#define GLPOPCLIENTATTRIBDLL 54 +#define GLPOPMATRIXDLL 55 +#define GLPUSHATTRIBDLL 56 +#define GLPUSHCLIENTATTRIBDLL 57 +#define GLPUSHMATRIXDLL 58 +#define GLREADBUFFERDLL 59 +#define GLREADPIXELSDLL 60 +#define GLROTATEFDLL 61 +#define GLSCALEFDLL 62 +#define GLSHADEMODELDLL 63 +#define GLTEXCOORD2FDLL 64 +#define GLTEXCOORDPOINTERDLL 65 +#define GLTEXENVFDLL 66 +#define GLTEXENVIDLL 67 +#define GLTEXIMAGE1DDLL 68 +#define GLTEXIMAGE2DDLL 69 +#define GLTEXPARAMETERFDLL 70 +#define GLTEXPARAMETERFVDLL 71 +#define GLTEXPARAMETERIDLL 72 +#define GLTEXSUBIMAGE2DDLL 73 +#define GLTRANSLATEFDLL 74 +#define GLVERTEX3FDLL 75 +#define GLVERTEX3FVDLL 76 +#define GLVERTEXPOINTERDLL 77 + +#define GLACTIVETEXTURE 0 +#define GLBINDBUFFERARB 1 +#define GLBINDBUFFERBASENV 2 +#define GLBINDFRAMEBUFFEREXT 3 +#define GLBINDMULTITEXTUREEXT 4 +#define GLBINDRENDERBUFFEREXT 5 +#define GLBUFFERDATAARB 6 +#define GLCLAMPCOLORARB 7 +#define GLCLIENTACTIVETEXTURE 8 +#define GLCOPYMULTITEXSUBIMAGE2DEXT 9 +#define GLDELETEBUFFERSARB 10 +#define GLDELETEFRAMEBUFFERSEXT 11 +#define GLDELETERENDERBUFFERSEXT 12 +#define GLDELETETEXTURES 13 +#define GLDISABLEVERTEXATTRIBARRAYARB 14 +#define GLDRAWRANGEELEMENTS 15 +#define GLENABLEVERTEXATTRIBARRAY 16 +#define GLENABLEVERTEXATTRIBARRAYARB 17 +#define GLFRAMEBUFFERRENDERBUFFEREXT 18 +#define GLFRAMEBUFFERTEXTURE2DEXT 19 +#define GLGENFRAMEBUFFERSEXT 20 +#define GLGENRENDERBUFFERSEXT 21 +#define GLGENTEXTURES 22 +#define GLGETPROGRAMENVPARAMETERFVARB 23 +#define GLGETPROGRAMIVARB 24 +#define GLGETTEXTUREIMAGEEXT 25 +#define GLISBUFFERARB 26 +#define GLLOADTRANSPOSEMATRIXF 27 +#define GLMAPNAMEDBUFFEREXT 28 +#define GLMULTITEXCOORD2F 29 +#define GLMULTITEXCOORD2FV 30 +#define GLMULTTRANSPOSEMATRIXF 31 +#define GLNAMEDBUFFERDATAEXT 32 +#define GLNAMEDBUFFERSUBDATAEXT 33 +#define GLPOINTPARAMETERF 34 +#define GLPOINTPARAMETERFV 35 +#define GLPOINTPARAMETERI 36 +#define GLPRIMITIVERESTARTINDEXNV 37 +#define GLPROGRAMBUFFERPARAMETERSFVNV 38 +#define GLPROGRAMENVPARAMETER4FARB 39 +#define GLPROGRAMENVPARAMETER4FVARB 40 +#define GLPROGRAMENVPARAMETERS4FVEXT 41 +#define GLPROGRAMLOCALPARAMETER4FARB 42 +#define GLPROGRAMLOCALPARAMETER4FVARB 43 +#define GLPROGRAMLOCALPARAMETERS4FVEXT 44 +#define GLRENDERBUFFERSTORAGEEXT 45 +#define GLRENDERBUFFERSTORAGEMULTISAMPLECOVERAGENV 46 +#define GLUNMAPNAMEDBUFFEREXT 47 +#define GLUSEPROGRAM 48 +#define GLVERTEXATTRIBPOINTERARB 49 + +#define GLBEGINGLUT 0 +#define GLBITMAPGLUT 1 +#define GLDRAWBUFFERGLUT 2 +#define GLENABLEGLUT 3 +#define GLENDGLUT 4 +#define GLEVALMESH2GLUT 5 +#define GLGETERRORGLUT 6 +#define GLGETINTEGERVGLUT 7 +#define GLGETSTRINGGLUT 8 +#define GLMAP2FGLUT 9 +#define GLMAPGRID2FGLUT 10 +#define GLNORMAL3FGLUT 11 +#define GLNORMAL3FVGLUT 12 +#define GLPIXELSTOREIGLUT 13 +#define GLPOLYGONMODEGLUT 14 +#define GLPOPATTRIBGLUT 15 +#define GLPOPMATRIXGLUT 16 +#define GLPUSHATTRIBGLUT 17 +#define GLPUSHMATRIXGLUT 18 +#define GLREADBUFFERGLUT 19 +#define GLROTATEFGLUT 20 +#define GLSCALEFGLUT 21 +#define GLTRANSLATEFGLUT 22 +#define GLVERTEX2FGLUT 23 +#define GLVERTEX3FGLUT 24 +#define GLVERTEX3FVGLUT 25 +#define WGLCREATECONTEXTGLUT 26 + +typedef void (GLAPIENTRY* PFNGLALPHAFUNCDLLPROC)(GLenum func, GLfloat ref); +typedef void (GLAPIENTRY* PFNGLBEGINDLLPROC)(GLenum mode); +typedef void (GLAPIENTRY* PFNGLBINDTEXTUREDLLPROC)(GLenum target, GLuint texture); +typedef void (GLAPIENTRY* PFNGLCLEARDLLPROC)(GLbitfield mask); +typedef void (GLAPIENTRY* PFNGLCLEARCOLORDLLPROC)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +typedef void (GLAPIENTRY* PFNGLCLEARDEPTHDLLPROC)(GLdouble depth); +typedef void (GLAPIENTRY* PFNGLCLEARSTENCILDLLPROC)(GLint s); +typedef void (GLAPIENTRY* PFNGLCOLOR3FDLLPROC)(GLfloat red, GLfloat green, GLfloat blue); +typedef void (GLAPIENTRY* PFNGLCOLOR4FDLLPROC)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +typedef void (GLAPIENTRY* PFNGLCOLOR4UBDLLPROC)(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha); +typedef void (GLAPIENTRY* PFNGLCOLOR4UBVDLLPROC)(GLubyte const * v); +typedef void (GLAPIENTRY* PFNGLCOLORPOINTERDLLPROC)(GLint size, GLenum type, GLsizei stride, const void * pointer); +typedef void (GLAPIENTRY* PFNGLCOPYTEXIMAGE2DDLLPROC)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); +typedef void (GLAPIENTRY* PFNGLCOPYTEXSUBIMAGE2DDLLPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); +typedef void (GLAPIENTRY* PFNGLCULLFACEDLLPROC)(GLenum mode); +typedef void (GLAPIENTRY* PFNGLDEPTHFUNCDLLPROC)(GLenum func); +typedef void (GLAPIENTRY* PFNGLDISABLEDLLPROC)(GLenum cap); +typedef void (GLAPIENTRY* PFNGLDISABLECLIENTSTATEDLLPROC)(GLenum array); +typedef void (GLAPIENTRY* PFNGLDRAWARRAYSDLLPROC)(GLenum mode, GLint first, GLsizei count); +typedef void (GLAPIENTRY* PFNGLDRAWBUFFERDLLPROC)(GLenum buf); +typedef void (GLAPIENTRY* PFNGLDRAWELEMENTSDLLPROC)(GLenum mode, GLsizei count, GLenum type, const void * indices); +typedef void (GLAPIENTRY* PFNGLENABLEDLLPROC)(GLenum cap); +typedef void (GLAPIENTRY* PFNGLENABLECLIENTSTATEDLLPROC)(GLenum array); +typedef void (GLAPIENTRY* PFNGLENDDLLPROC)(); +typedef void (GLAPIENTRY* PFNGLFOGFDLLPROC)(GLenum pname, GLfloat param); +typedef void (GLAPIENTRY* PFNGLFOGFVDLLPROC)(GLenum pname, GLfloat const * params); +typedef void (GLAPIENTRY* PFNGLFOGIDLLPROC)(GLenum pname, GLint param); +typedef void (GLAPIENTRY* PFNGLFRONTFACEDLLPROC)(GLenum mode); +typedef void (GLAPIENTRY* PFNGLFRUSTUMDLLPROC)(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); +typedef void (GLAPIENTRY* PFNGLGETBOOLEANVDLLPROC)(GLenum pname, GLboolean * data); +typedef GLenum (GLAPIENTRY* PFNGLGETERRORDLLPROC)(); +typedef void (GLAPIENTRY* PFNGLGETFLOATVDLLPROC)(GLenum pname, GLfloat * data); +typedef void (GLAPIENTRY* PFNGLGETINTEGERVDLLPROC)(GLenum pname, GLint * data); +typedef void (GLAPIENTRY* PFNGLGETMATERIALFVDLLPROC)(GLenum face, GLenum pname, GLfloat * params); +typedef void (GLAPIENTRY* PFNGLGETTEXIMAGEDLLPROC)(GLenum target, GLint level, GLenum format, GLenum type, void * pixels); +typedef void (GLAPIENTRY* PFNGLGETTEXLEVELPARAMETERIVDLLPROC)(GLenum target, GLint level, GLenum pname, GLint * params); +typedef void (GLAPIENTRY* PFNGLGETTEXPARAMETERIVDLLPROC)(GLenum target, GLenum pname, GLint * params); +typedef GLboolean (GLAPIENTRY* PFNGLISENABLEDDLLPROC)(GLenum cap); +typedef void (GLAPIENTRY* PFNGLLIGHTFVDLLPROC)(GLenum light, GLenum pname, GLfloat const * params); +typedef void (GLAPIENTRY* PFNGLLIGHTMODELFVDLLPROC)(GLenum pname, GLfloat const * params); +typedef void (GLAPIENTRY* PFNGLLINEWIDTHDLLPROC)(GLfloat width); +typedef void (GLAPIENTRY* PFNGLLOADIDENTITYDLLPROC)(); +typedef void (GLAPIENTRY* PFNGLLOADMATRIXFDLLPROC)(GLfloat const * m); +typedef void (GLAPIENTRY* PFNGLMATERIALFDLLPROC)(GLenum face, GLenum pname, GLfloat param); +typedef void (GLAPIENTRY* PFNGLMATERIALFVDLLPROC)(GLenum face, GLenum pname, GLfloat const * params); +typedef void (GLAPIENTRY* PFNGLMATRIXMODEDLLPROC)(GLenum mode); +typedef void (GLAPIENTRY* PFNGLMULTMATRIXDDLLPROC)(GLdouble const * m); +typedef void (GLAPIENTRY* PFNGLNORMAL3FDLLPROC)(GLfloat nx, GLfloat ny, GLfloat nz); +typedef void (GLAPIENTRY* PFNGLNORMALPOINTERDLLPROC)(GLenum type, GLsizei stride, const void * pointer); +typedef void (GLAPIENTRY* PFNGLORTHODLLPROC)(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); +typedef void (GLAPIENTRY* PFNGLPIXELSTOREIDLLPROC)(GLenum pname, GLint param); +typedef void (GLAPIENTRY* PFNGLPOINTSIZEDLLPROC)(GLfloat size); +typedef void (GLAPIENTRY* PFNGLPOLYGONMODEDLLPROC)(GLenum face, GLenum mode); +typedef void (GLAPIENTRY* PFNGLPOPATTRIBDLLPROC)(); +typedef void (GLAPIENTRY* PFNGLPOPCLIENTATTRIBDLLPROC)(); +typedef void (GLAPIENTRY* PFNGLPOPMATRIXDLLPROC)(); +typedef void (GLAPIENTRY* PFNGLPUSHATTRIBDLLPROC)(GLbitfield mask); +typedef void (GLAPIENTRY* PFNGLPUSHCLIENTATTRIBDLLPROC)(GLbitfield mask); +typedef void (GLAPIENTRY* PFNGLPUSHMATRIXDLLPROC)(); +typedef void (GLAPIENTRY* PFNGLREADBUFFERDLLPROC)(GLenum src); +typedef void (GLAPIENTRY* PFNGLREADPIXELSDLLPROC)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void * pixels); +typedef void (GLAPIENTRY* PFNGLROTATEFDLLPROC)(GLfloat angle, GLfloat x, GLfloat y, GLfloat z); +typedef void (GLAPIENTRY* PFNGLSCALEFDLLPROC)(GLfloat x, GLfloat y, GLfloat z); +typedef void (GLAPIENTRY* PFNGLSHADEMODELDLLPROC)(GLenum mode); +typedef void (GLAPIENTRY* PFNGLTEXCOORD2FDLLPROC)(GLfloat s, GLfloat t); +typedef void (GLAPIENTRY* PFNGLTEXCOORDPOINTERDLLPROC)(GLint size, GLenum type, GLsizei stride, const void * pointer); +typedef void (GLAPIENTRY* PFNGLTEXENVFDLLPROC)(GLenum target, GLenum pname, GLfloat param); +typedef void (GLAPIENTRY* PFNGLTEXENVIDLLPROC)(GLenum target, GLenum pname, GLint param); +typedef void (GLAPIENTRY* PFNGLTEXIMAGE1DDLLPROC)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void * pixels); +typedef void (GLAPIENTRY* PFNGLTEXIMAGE2DDLLPROC)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void * pixels); +typedef void (GLAPIENTRY* PFNGLTEXPARAMETERFDLLPROC)(GLenum target, GLenum pname, GLfloat param); +typedef void (GLAPIENTRY* PFNGLTEXPARAMETERFVDLLPROC)(GLenum target, GLenum pname, GLfloat const * params); +typedef void (GLAPIENTRY* PFNGLTEXPARAMETERIDLLPROC)(GLenum target, GLenum pname, GLint param); +typedef void (GLAPIENTRY* PFNGLTEXSUBIMAGE2DDLLPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void * pixels); +typedef void (GLAPIENTRY* PFNGLTRANSLATEFDLLPROC)(GLfloat x, GLfloat y, GLfloat z); +typedef void (GLAPIENTRY* PFNGLVERTEX3FDLLPROC)(GLfloat x, GLfloat y, GLfloat z); +typedef void (GLAPIENTRY* PFNGLVERTEX3FVDLLPROC)(GLfloat const * v); +typedef void (GLAPIENTRY* PFNGLVERTEXPOINTERDLLPROC)(GLint size, GLenum type, GLsizei stride, const void * pointer); + +typedef void (GLAPIENTRY* PFNGLACTIVETEXTUREPROC)(GLenum texture); +typedef void (GLAPIENTRY* PFNGLBINDBUFFERARBPROC)(GLenum target, GLuint buffer); +typedef void (GLAPIENTRY* PFNGLBINDBUFFERBASENVPROC)(GLenum target, GLuint index, GLuint buffer); +typedef void (GLAPIENTRY* PFNGLBINDFRAMEBUFFEREXTPROC)(GLenum target, GLuint framebuffer); +typedef void (GLAPIENTRY* PFNGLBINDMULTITEXTUREEXTPROC)(GLenum texunit, GLenum target, GLuint texture); +typedef void (GLAPIENTRY* PFNGLBINDRENDERBUFFEREXTPROC)(GLenum target, GLuint renderbuffer); +typedef void (GLAPIENTRY* PFNGLBUFFERDATAARBPROC)(GLenum target, GLsizeiptrARB size, const void * data, GLenum usage); +typedef void (GLAPIENTRY* PFNGLCLAMPCOLORARBPROC)(GLenum target, GLenum clamp); +typedef void (GLAPIENTRY* PFNGLCLIENTACTIVETEXTUREPROC)(GLenum texture); +typedef void (GLAPIENTRY* PFNGLCOPYMULTITEXSUBIMAGE2DEXTPROC)(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); +typedef void (GLAPIENTRY* PFNGLDELETEBUFFERSARBPROC)(GLsizei n, GLuint const * buffers); +typedef void (GLAPIENTRY* PFNGLDELETEFRAMEBUFFERSEXTPROC)(GLsizei n, GLuint const * framebuffers); +typedef void (GLAPIENTRY* PFNGLDELETERENDERBUFFERSEXTPROC)(GLsizei n, GLuint const * renderbuffers); +typedef void (GLAPIENTRY* PFNGLDELETETEXTURESPROC)(GLsizei n, GLuint const * textures); +typedef void (GLAPIENTRY* PFNGLDISABLEVERTEXATTRIBARRAYARBPROC)(GLuint index); +typedef void (GLAPIENTRY* PFNGLDRAWRANGEELEMENTSPROC)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void * indices); +typedef void (GLAPIENTRY* PFNGLENABLEVERTEXATTRIBARRAYPROC)(GLuint index); +typedef void (GLAPIENTRY* PFNGLENABLEVERTEXATTRIBARRAYARBPROC)(GLuint index); +typedef void (GLAPIENTRY* PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC)(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer); +typedef void (GLAPIENTRY* PFNGLFRAMEBUFFERTEXTURE2DEXTPROC)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +typedef void (GLAPIENTRY* PFNGLGENFRAMEBUFFERSEXTPROC)(GLsizei n, GLuint * framebuffers); +typedef void (GLAPIENTRY* PFNGLGENRENDERBUFFERSEXTPROC)(GLsizei n, GLuint * renderbuffers); +typedef void (GLAPIENTRY* PFNGLGENTEXTURESPROC)(GLsizei n, GLuint * textures); +typedef void (GLAPIENTRY* PFNGLGETPROGRAMENVPARAMETERFVARBPROC)(GLenum target, GLuint index, GLfloat * params); +typedef void (GLAPIENTRY* PFNGLGETPROGRAMIVARBPROC)(GLenum target, GLenum pname, GLint * params); +typedef void (GLAPIENTRY* PFNGLGETTEXTUREIMAGEEXTPROC)(GLuint texture, GLenum target, GLint level, GLenum format, GLenum type, void * pixels); +typedef GLboolean (GLAPIENTRY* PFNGLISBUFFERARBPROC)(GLuint buffer); +typedef void (GLAPIENTRY* PFNGLLOADTRANSPOSEMATRIXFPROC)(GLfloat const * m); +typedef void * (GLAPIENTRY* PFNGLMAPNAMEDBUFFEREXTPROC)(GLuint buffer, GLenum access); +typedef void (GLAPIENTRY* PFNGLMULTITEXCOORD2FPROC)(GLenum target, GLfloat s, GLfloat t); +typedef void (GLAPIENTRY* PFNGLMULTITEXCOORD2FVPROC)(GLenum target, GLfloat const * v); +typedef void (GLAPIENTRY* PFNGLMULTTRANSPOSEMATRIXFPROC)(GLfloat const * m); +typedef void (GLAPIENTRY* PFNGLNAMEDBUFFERDATAEXTPROC)(GLuint buffer, GLsizeiptr size, const void * data, GLenum usage); +typedef void (GLAPIENTRY* PFNGLNAMEDBUFFERSUBDATAEXTPROC)(GLuint buffer, GLintptr offset, GLsizeiptr size, const void * data); +typedef void (GLAPIENTRY* PFNGLPOINTPARAMETERFPROC)(GLenum pname, GLfloat param); +typedef void (GLAPIENTRY* PFNGLPOINTPARAMETERFVPROC)(GLenum pname, GLfloat const * params); +typedef void (GLAPIENTRY* PFNGLPOINTPARAMETERIPROC)(GLenum pname, GLint param); +typedef void (GLAPIENTRY* PFNGLPRIMITIVERESTARTINDEXNVPROC)(GLuint index); +typedef void (GLAPIENTRY* PFNGLPROGRAMBUFFERPARAMETERSFVNVPROC)(GLenum target, GLuint bindingIndex, GLuint wordIndex, GLsizei count, GLfloat const * params); +typedef void (GLAPIENTRY* PFNGLPROGRAMENVPARAMETER4FARBPROC)(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +typedef void (GLAPIENTRY* PFNGLPROGRAMENVPARAMETER4FVARBPROC)(GLenum target, GLuint index, GLfloat const * params); +typedef void (GLAPIENTRY* PFNGLPROGRAMENVPARAMETERS4FVEXTPROC)(GLenum target, GLuint index, GLsizei count, GLfloat const * params); +typedef void (GLAPIENTRY* PFNGLPROGRAMLOCALPARAMETER4FARBPROC)(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +typedef void (GLAPIENTRY* PFNGLPROGRAMLOCALPARAMETER4FVARBPROC)(GLenum target, GLuint index, GLfloat const * params); +typedef void (GLAPIENTRY* PFNGLPROGRAMLOCALPARAMETERS4FVEXTPROC)(GLenum target, GLuint index, GLsizei count, GLfloat const * params); +typedef void (GLAPIENTRY* PFNGLRENDERBUFFERSTORAGEEXTPROC)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height); +typedef void (GLAPIENTRY* PFNGLRENDERBUFFERSTORAGEMULTISAMPLECOVERAGENVPROC)(GLenum target, GLsizei coverageSamples, GLsizei colorSamples, GLenum internalformat, GLsizei width, GLsizei height); +typedef GLboolean (GLAPIENTRY* PFNGLUNMAPNAMEDBUFFEREXTPROC)(GLuint buffer); +typedef void (GLAPIENTRY* PFNGLUSEPROGRAMPROC)(GLuint program); +typedef void (GLAPIENTRY* PFNGLVERTEXATTRIBPOINTERARBPROC)(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void * pointer); + +typedef void (GLAPIENTRY* PFNGLBEGINGLUTPROC)(GLenum mode); +typedef void (GLAPIENTRY* PFNGLBITMAPGLUTPROC)(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, GLubyte const * bitmap); +typedef void (GLAPIENTRY* PFNGLDRAWBUFFERGLUTPROC)(GLenum buf); +typedef void (GLAPIENTRY* PFNGLENABLEGLUTPROC)(GLenum cap); +typedef void (GLAPIENTRY* PFNGLENDGLUTPROC)(); +typedef void (GLAPIENTRY* PFNGLEVALMESH2GLUTPROC)(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2); +typedef GLenum (GLAPIENTRY* PFNGLGETERRORGLUTPROC)(); +typedef void (GLAPIENTRY* PFNGLGETINTEGERVGLUTPROC)(GLenum pname, GLint * data); +typedef GLubyte const * (GLAPIENTRY* PFNGLGETSTRINGGLUTPROC)(GLenum name); +typedef void (GLAPIENTRY* PFNGLMAP2FGLUTPROC)(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, GLfloat const * points); +typedef void (GLAPIENTRY* PFNGLMAPGRID2FGLUTPROC)(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2); +typedef void (GLAPIENTRY* PFNGLNORMAL3FGLUTPROC)(GLfloat nx, GLfloat ny, GLfloat nz); +typedef void (GLAPIENTRY* PFNGLNORMAL3FVGLUTPROC)(GLfloat const * v); +typedef void (GLAPIENTRY* PFNGLPIXELSTOREIGLUTPROC)(GLenum pname, GLint param); +typedef void (GLAPIENTRY* PFNGLPOLYGONMODEGLUTPROC)(GLenum face, GLenum mode); +typedef void (GLAPIENTRY* PFNGLPOPATTRIBGLUTPROC)(); +typedef void (GLAPIENTRY* PFNGLPOPMATRIXGLUTPROC)(); +typedef void (GLAPIENTRY* PFNGLPUSHATTRIBGLUTPROC)(GLbitfield mask); +typedef void (GLAPIENTRY* PFNGLPUSHMATRIXGLUTPROC)(); +typedef void (GLAPIENTRY* PFNGLREADBUFFERGLUTPROC)(GLenum src); +typedef void (GLAPIENTRY* PFNGLROTATEFGLUTPROC)(GLfloat angle, GLfloat x, GLfloat y, GLfloat z); +typedef void (GLAPIENTRY* PFNGLSCALEFGLUTPROC)(GLfloat x, GLfloat y, GLfloat z); +typedef void (GLAPIENTRY* PFNGLTRANSLATEFGLUTPROC)(GLfloat x, GLfloat y, GLfloat z); +typedef void (GLAPIENTRY* PFNGLVERTEX2FGLUTPROC)(GLfloat x, GLfloat y); +typedef void (GLAPIENTRY* PFNGLVERTEX3FGLUTPROC)(GLfloat x, GLfloat y, GLfloat z); +typedef void (GLAPIENTRY* PFNGLVERTEX3FVGLUTPROC)(GLfloat const * v); +typedef HGLRC (GLAPIENTRY* PFNWGLCREATECONTEXTGLUTPROC)(HDC hDc); + +extern size_t glut_handle; + +func_struct wrap_addr_dll[78] = { + { 0x0000000140965A00, 0, (size_t)&glAlphaFuncDLL, }, // glAlphaFunc + { 0x0000000140965A70, 0, (size_t)&glBeginDLL, }, // glBegin + { 0x0000000140965BF8, 0, (size_t)&glBindTextureDLL, }, // glBindTexture + { 0x0000000140965C58, 0, (size_t)&glClearDLL, }, // glClear + { 0x0000000140965C38, 0, (size_t)&glClearColorDLL, }, // glClearColor + { 0x0000000140965C08, 0, (size_t)&glClearDepthDLL, }, // glClearDepth + { 0x0000000140965C10, 0, (size_t)&glClearStencilDLL, }, // glClearStencil + { 0x0000000140965A88, 0, (size_t)&glColor3fDLL, }, // glColor3f + { 0x0000000140965A90, 0, (size_t)&glColor4fDLL, }, // glColor4f + { 0x0000000140965B88, 0, (size_t)&glColor4ubDLL, }, // glColor4ub + { 0x0000000140965B90, 0, (size_t)&glColor4ubvDLL, }, // glColor4ubv + { 0x0000000140965C30, 0, (size_t)&glColorPointerDLL, }, // glColorPointer + { 0x0000000140965B40, 0, (size_t)&glCopyTexImage2DDLL, }, // glCopyTexImage2D + { 0x0000000140965A98, 0, (size_t)&glCopyTexSubImage2DDLL, }, // glCopyTexSubImage2D + { 0x0000000140965C18, 0, (size_t)&glCullFaceDLL, }, // glCullFace + { 0x0000000140965C40, 0, (size_t)&glDepthFuncDLL, }, // glDepthFunc + { 0x0000000140965C48, 0, (size_t)&glDisableDLL, }, // glDisable + { 0x0000000140965C28, 0, (size_t)&glDisableClientStateDLL, }, // glDisableClientState + { 0x0000000140965BF0, 0, (size_t)&glDrawArraysDLL, }, // glDrawArrays + { 0x0000000140965B60, 0, (size_t)&glDrawBufferDLL, }, // glDrawBuffer + { 0x0000000140965A48, 0, (size_t)&glDrawElementsDLL, }, // glDrawElements + { 0x0000000140965C50, 0, (size_t)&glEnableDLL, }, // glEnable + { 0x0000000140965BE8, 0, (size_t)&glEnableClientStateDLL, }, // glEnableClientState + { 0x0000000140965A78, 0, (size_t)&glEndDLL, }, // glEnd + { 0x0000000140965A58, 0, (size_t)&glFogfDLL, }, // glFogf + { 0x0000000140965A60, 0, (size_t)&glFogfvDLL, }, // glFogfv + { 0x0000000140965A68, 0, (size_t)&glFogiDLL, }, // glFogi + { 0x0000000140965BB0, 0, (size_t)&glFrontFaceDLL, }, // glFrontFace + { 0x0000000140965C98, 0, (size_t)&glFrustumDLL, }, // glFrustum + { 0x0000000140965AF0, 0, (size_t)&glGetBooleanvDLL, }, // glGetBooleanv + { 0x0000000140965BA8, 0, (size_t)&glGetErrorDLL, }, // glGetError + { 0x0000000140965C90, 0, (size_t)&glGetFloatvDLL, }, // glGetFloatv + { 0x0000000140965AF8, 0, (size_t)&glGetIntegervDLL, }, // glGetIntegerv + { 0x0000000140965CB0, 0, (size_t)&glGetMaterialfvDLL, }, // glGetMaterialfv + { 0x0000000140965C00, 0, (size_t)&glGetTexImageDLL, }, // glGetTexImage + { 0x0000000140965AA0, 0, (size_t)&glGetTexLevelParameterivDLL, }, // glGetTexLevelParameteriv + { 0x0000000140965AA8, 0, (size_t)&glGetTexParameterivDLL, }, // glGetTexParameteriv + { 0x0000000140965B08, 0, (size_t)&glIsEnabledDLL, }, // glIsEnabled + { 0x0000000140965AC8, 0, (size_t)&glLightfvDLL, }, // glLightfv + { 0x0000000140965AC0, 0, (size_t)&glLightModelfvDLL, }, // glLightModelfv + { 0x0000000140965B10, 0, (size_t)&glLineWidthDLL, }, // glLineWidth + { 0x0000000140965C88, 0, (size_t)&glLoadIdentityDLL, }, // glLoadIdentity + { 0x0000000140965A50, 0, (size_t)&glLoadMatrixfDLL, }, // glLoadMatrixf + { 0x0000000140965A08, 0, (size_t)&glMaterialfDLL, }, // glMaterialf + { 0x0000000140965A80, 0, (size_t)&glMaterialfvDLL, }, // glMaterialfv + { 0x0000000140965C80, 0, (size_t)&glMatrixModeDLL, }, // glMatrixMode + { 0x0000000140965B48, 0, (size_t)&glMultMatrixdDLL, }, // glMultMatrixd + { 0x0000000140965B18, 0, (size_t)&glNormal3fDLL, }, // glNormal3f + { 0x0000000140965B20, 0, (size_t)&glNormalPointerDLL, }, // glNormalPointer + { 0x0000000140965B50, 0, (size_t)&glOrthoDLL, }, // glOrtho + { 0x0000000140965BA0, 0, (size_t)&glPixelStoreiDLL, }, // glPixelStorei + { 0x0000000140965BE0, 0, (size_t)&glPointSizeDLL, }, // glPointSize + { 0x0000000140965B98, 0, (size_t)&glPolygonModeDLL, }, // glPolygonMode + { 0x0000000140965BD8, 0, (size_t)&glPopAttribDLL, }, // glPopAttrib + { 0x0000000140965BD0, 0, (size_t)&glPopClientAttribDLL, }, // glPopClientAttrib + { 0x0000000140965CA8, 0, (size_t)&glPopMatrixDLL, }, // glPopMatrix + { 0x0000000140965BC8, 0, (size_t)&glPushAttribDLL, }, // glPushAttrib + { 0x0000000140965BC0, 0, (size_t)&glPushClientAttribDLL, }, // glPushClientAttrib + { 0x0000000140965CA0, 0, (size_t)&glPushMatrixDLL, }, // glPushMatrix + { 0x0000000140965B70, 0, (size_t)&glReadBufferDLL, }, // glReadBuffer + { 0x0000000140965B78, 0, (size_t)&glReadPixelsDLL, }, // glReadPixels + { 0x0000000140965C70, 0, (size_t)&glRotatefDLL, }, // glRotatef + { 0x0000000140965C68, 0, (size_t)&glScalefDLL, }, // glScalef + { 0x0000000140965C20, 0, (size_t)&glShadeModelDLL, }, // glShadeModel + { 0x0000000140965B80, 0, (size_t)&glTexCoord2fDLL, }, // glTexCoord2f + { 0x0000000140965A30, 0, (size_t)&glTexCoordPointerDLL, }, // glTexCoordPointer + { 0x0000000140965B28, 0, (size_t)&glTexEnvfDLL, }, // glTexEnvf + { 0x0000000140965BB8, 0, (size_t)&glTexEnviDLL, }, // glTexEnvi + { 0x0000000140965B58, 0, (size_t)&glTexImage1DDLL, }, // glTexImage1D + { 0x0000000140965AE0, 0, (size_t)&glTexImage2DDLL, }, // glTexImage2D + { 0x0000000140965AE8, 0, (size_t)&glTexParameterfDLL, }, // glTexParameterf + { 0x0000000140965A10, 0, (size_t)&glTexParameterfvDLL, }, // glTexParameterfv + { 0x0000000140965A18, 0, (size_t)&glTexParameteriDLL, }, // glTexParameteri + { 0x0000000140965AB0, 0, (size_t)&glTexSubImage2DDLL, }, // glTexSubImage2D + { 0x0000000140965C60, 0, (size_t)&glTranslatefDLL, }, // glTranslatef + { 0x0000000140965AB8, 0, (size_t)&glVertex3fDLL, }, // glVertex3f + { 0x0000000140965B30, 0, (size_t)&glVertex3fvDLL, }, // glVertex3fv + { 0x0000000140965B00, 0, (size_t)&glVertexPointerDLL, }, // glVertexPointer +}; + +func_struct wrap_addr[50] = { + { 0x00000001411A3DB8, 0, (size_t)&glActiveTexture, }, // glActiveTexture + { 0x00000001411A4B10, 0, (size_t)&glBindBufferARB, }, // glBindBufferARB + { 0x00000001411A3578, 0, (size_t)&glBindBufferBaseNV, }, // glBindBufferBaseNV + { 0x00000001411A54D8, 0, (size_t)&glBindFramebufferEXT, }, // glBindFramebufferEXT + { 0x00000001411A3818, 0, (size_t)&glBindMultiTextureEXT, }, // glBindMultiTextureEXT + { 0x00000001411A54A8, 0, (size_t)&glBindRenderbufferEXT, }, // glBindRenderbufferEXT + { 0x00000001411A4B30, 0, (size_t)&glBufferDataARB, }, // glBufferDataARB + { 0x00000001411A4D00, 0, (size_t)&glClampColorARB, }, // glClampColorARB + { 0x00000001411A3DC8, 0, (size_t)&glClientActiveTexture, }, // glClientActiveTexture + { 0x00000001411A37D0, 0, (size_t)&glCopyMultiTexSubImage2DEXT, }, // glCopyMultiTexSubImage2DEXT + { 0x00000001411A4B18, 0, (size_t)&glDeleteBuffersARB, }, // glDeleteBuffersARB + { 0x00000001411A54E0, 0, (size_t)&glDeleteFramebuffersEXT, }, // glDeleteFramebuffersEXT + { 0x00000001411A54B0, 0, (size_t)&glDeleteRenderbuffersEXT, }, // glDeleteRenderbuffersEXT + { 0x00000001411A1A30, 0, (size_t)&glDeleteTextures, }, // glDeleteTextures + { 0x00000001411A4A50, 0, (size_t)&glDisableVertexAttribArrayARB, }, // glDisableVertexAttribArrayARB + { 0x00000001411A3B78, 0, (size_t)&glDrawRangeElements, }, // glDrawRangeElements + { 0x00000001411A42A8, 0, (size_t)&glEnableVertexAttribArray, }, // glEnableVertexAttribArray + { 0x00000001411A4A48, 0, (size_t)&glEnableVertexAttribArrayARB, }, // glEnableVertexAttribArrayARB + { 0x00000001411A5510, 0, (size_t)&glFramebufferRenderbufferEXT, }, // glFramebufferRenderbufferEXT + { 0x00000001411A5500, 0, (size_t)&glFramebufferTexture2DEXT, }, // glFramebufferTexture2DEXT + { 0x00000001411A54E8, 0, (size_t)&glGenFramebuffersEXT, }, // glGenFramebuffersEXT + { 0x00000001411A54B8, 0, (size_t)&glGenRenderbuffersEXT, }, // glGenRenderbuffersEXT + { 0x00000001411A1A38, 0, (size_t)&glGenTextures, }, // glGenTextures + { 0x00000001411A4AC0, 0, (size_t)&glGetProgramEnvParameterfvARB, }, // glGetProgramEnvParameterfvARB + { 0x00000001411A4AD8, 0, (size_t)&glGetProgramivARB, }, // glGetProgramivARB + { 0x00000001411A3738, 0, (size_t)&glGetTextureImageEXT, }, // glGetTextureImageEXT + { 0x00000001411A4B28, 0, (size_t)&glIsBufferARB, }, // glIsBufferARB + { 0x00000001411A3FD8, 0, (size_t)&glLoadTransposeMatrixf, }, // glLoadTransposeMatrixf + { 0x00000001411A3B20, 0, (size_t)&glMapNamedBufferEXT, }, // glMapNamedBufferEXT + { 0x00000001411A3E78, 0, (size_t)&glMultiTexCoord2f, }, // glMultiTexCoord2f + { 0x00000001411A3E88, 0, (size_t)&glMultiTexCoord2fv, }, // glMultiTexCoord2fv + { 0x00000001411A3FE8, 0, (size_t)&glMultTransposeMatrixf, }, // glMultTransposeMatrixf + { 0x00000001411A3B10, 0, (size_t)&glNamedBufferDataEXT, }, // glNamedBufferDataEXT + { 0x00000001411A3B18, 0, (size_t)&glNamedBufferSubDataEXT, }, // glNamedBufferSubDataEXT + { 0x00000001411A4078, 0, (size_t)&glPointParameterf, }, // glPointParameterf + { 0x00000001411A4080, 0, (size_t)&glPointParameterfv, }, // glPointParameterfv + { 0x00000001411A4088, 0, (size_t)&glPointParameteri, }, // glPointParameteri + { 0x00000001411A5488, 0, (size_t)&glPrimitiveRestartIndexNV, }, // glPrimitiveRestartIndexNV + { 0x00000001411A3508, 0, (size_t)&glProgramBufferParametersfvNV, }, // glProgramBufferParametersfvNV + { 0x00000001411A4A88, 0, (size_t)&glProgramEnvParameter4fARB, }, // glProgramEnvParameter4fARB + { 0x00000001411A4A90, 0, (size_t)&glProgramEnvParameter4fvARB, }, // glProgramEnvParameter4fvARB + { 0x00000001411A5548, 0, (size_t)&glProgramEnvParameters4fvEXT, }, // glProgramEnvParameters4fvEXT + { 0x00000001411A4AA8, 0, (size_t)&glProgramLocalParameter4fARB, }, // glProgramLocalParameter4fARB + { 0x00000001411A4AB0, 0, (size_t)&glProgramLocalParameter4fvARB, }, // glProgramLocalParameter4fvARB + { 0x00000001411A5550, 0, (size_t)&glProgramLocalParameters4fvEXT, }, // glProgramLocalParameters4fvEXT + { 0x00000001411A54C0, 0, (size_t)&glRenderbufferStorageEXT, }, // glRenderbufferStorageEXT + { 0x00000001411A3500, 0, (size_t)&glRenderbufferStorageMultisampleCoverageNV, }, // glRenderbufferStorageMultisampleCoverageNV + { 0x00000001411A3B28, 0, (size_t)&glUnmapNamedBufferEXT, }, // glUnmapNamedBufferEXT + { 0x00000001411A4350, 0, (size_t)&glUseProgram, }, // glUseProgram + { 0x00000001411A4A40, 0, (size_t)&glVertexAttribPointerARB, }, // glVertexAttribPointerARB +}; + +func_struct wrap_addr_glut[27] = { + { 0x000000000002A380, 0, (size_t)&glBeginGLUT, }, // glBegin + { 0x000000000002A348, 0, (size_t)&glBitmapGLUT, }, // glBitmap + { 0x000000000002A370, 0, (size_t)&glDrawBufferGLUT, }, // glDrawBuffer + { 0x000000000002A3D8, 0, (size_t)&glEnableGLUT, }, // glEnable + { 0x000000000002A388, 0, (size_t)&glEndGLUT, }, // glEnd + { 0x000000000002A3E0, 0, (size_t)&glEvalMesh2GLUT, }, // glEvalMesh2 + { 0x000000000002A418, 0, (size_t)&glGetErrorGLUT, }, // glGetError + { 0x000000000002A450, 0, (size_t)&glGetIntegervGLUT, }, // glGetIntegerv + { 0x000000000002A360, 0, (size_t)&glGetStringGLUT, }, // glGetString + { 0x000000000002A3E8, 0, (size_t)&glMap2fGLUT, }, // glMap2f + { 0x000000000002A3F0, 0, (size_t)&glMapGrid2fGLUT, }, // glMapGrid2f + { 0x000000000002A390, 0, (size_t)&glNormal3fGLUT, }, // glNormal3f + { 0x000000000002A398, 0, (size_t)&glNormal3fvGLUT, }, // glNormal3fv + { 0x000000000002A350, 0, (size_t)&glPixelStoreiGLUT, }, // glPixelStorei + { 0x000000000002A3A0, 0, (size_t)&glPolygonModeGLUT, }, // glPolygonMode + { 0x000000000002A3A8, 0, (size_t)&glPopAttribGLUT, }, // glPopAttrib + { 0x000000000002A3F8, 0, (size_t)&glPopMatrixGLUT, }, // glPopMatrix + { 0x000000000002A3B0, 0, (size_t)&glPushAttribGLUT, }, // glPushAttrib + { 0x000000000002A400, 0, (size_t)&glPushMatrixGLUT, }, // glPushMatrix + { 0x000000000002A378, 0, (size_t)&glReadBufferGLUT, }, // glReadBuffer + { 0x000000000002A408, 0, (size_t)&glRotatefGLUT, }, // glRotatef + { 0x000000000002A410, 0, (size_t)&glScalefGLUT, }, // glScalef + { 0x000000000002A3C8, 0, (size_t)&glTranslatefGLUT, }, // glTranslatef + { 0x000000000002A3D0, 0, (size_t)&glVertex2fGLUT, }, // glVertex2f + { 0x000000000002A3B8, 0, (size_t)&glVertex3fGLUT, }, // glVertex3f + { 0x000000000002A3C0, 0, (size_t)&glVertex3fvGLUT, }, // glVertex3fv + { 0x000000000002A440, 0, (size_t)&wglCreateContextGLUT, }, // wglCreateContext +}; + +gl_func_struct gl_addr_dll[9] = { + { 0x0000000140965A20, 0, }, // glBlendFunc + { 0x0000000140965A38, 0, }, // glColorMask + { 0x0000000140965AD0, 0, }, // glDeleteTextures + { 0x0000000140965A28, 0, }, // glDepthMask + { 0x0000000140965B68, 0, }, // glFinish + { 0x0000000140965AD8, 0, }, // glGenTextures + { 0x0000000140965A40, 0, }, // glScissor + { 0x0000000140965C78, 0, }, // glViewport + { 0x0000000140965B38, 0, }, // wglGetProcAddress +}; + +gl_func_struct gl_addr[1057] = { + { 0x00000001411A52D0, 0, }, // glActiveStencilFaceEXT + { 0x00000001411A4720, 0, }, // glActiveTextureARB + { 0x00000001411A3588, 0, }, // glActiveVaryingNV + { 0x00000001411A5088, 0, }, // glAreProgramsResidentNV + { 0x00000001411A4E30, 0, }, // glAreTexturesResidentEXT + { 0x00000001411A4E60, 0, }, // glArrayElementEXT + { 0x00000001411A4BE0, 0, }, // glAttachObjectARB + { 0x00000001411A4260, 0, }, // glAttachShader + { 0x00000001411A45B0, 0, }, // glBeginConditionalRender + { 0x00000001411A35F0, 0, }, // glBeginConditionalRenderNV + { 0x00000001411A52A0, 0, }, // glBeginOcclusionQueryNV + { 0x00000001411A41B8, 0, }, // glBeginQuery + { 0x00000001411A4B80, 0, }, // glBeginQueryARB + { 0x00000001411A4580, 0, }, // glBeginTransformFeedback + { 0x00000001411A3550, 0, }, // glBeginTransformFeedbackNV + { 0x00000001411A4268, 0, }, // glBindAttribLocation + { 0x00000001411A4CE0, 0, }, // glBindAttribLocationARB + { 0x00000001411A41E0, 0, }, // glBindBuffer + { 0x0000001411A4598, 0, }, // glBindBufferBase + { 0x00000001411A3570, 0, }, // glBindBufferOffsetNV + { 0x00000001411A4590, 0, }, // glBindBufferRange + { 0x00000001411A3568, 0, }, // glBindBufferRangeNV + { 0x00000001411A4680, 0, }, // glBindFragDataLocation + { 0x00000001411A56C0, 0, }, // glBindFragDataLocationEXT + { 0x00000001411A4D50, 0, }, // glBindFramebuffer + { 0x00000001411A4A60, 0, }, // glBindProgramARB + { 0x00000001411A5090, 0, }, // glBindProgramNV + { 0x00000001411A4D20, 0, }, // glBindRenderbuffer + { 0x00000001411A3FA0, 0, }, // glBindSampler + { 0x00000001411A4E38, 0, }, // glBindTextureEXT + { 0x00000001411A4DF0, 0, }, // glBindVertexArray + { 0x00000001411A3B58, 0, }, // glBlendColor + { 0x00000001411A4E10, 0, }, // glBlendColorEXT + { 0x00000001411A3B68, 0, }, // glBlendEquation + { 0x00000001411A4EA8, 0, }, // glBlendEquationEXT + { 0x00000001411A4238, 0, }, // glBlendEquationSeparate + { 0x00000001411A5498, 0, }, // glBlendEquationSeparateEXT + { 0x00000001411A4038, 0, }, // glBlendFuncSeparate + { 0x00000001411A4FC0, 0, }, // glBlendFuncSeparateEXT + { 0x00000001411A4DA0, 0, }, // glBlitFramebuffer + { 0x00000001411A5528, 0, }, // glBlitFramebufferEXT + { 0x00000001411A4200, 0, }, // glBufferData + { 0x00000001411A4208, 0, }, // glBufferSubData + { 0x00000001411A4B38, 0, }, // glBufferSubDataARB + { 0x00000001411A4D68, 0, }, // glCheckFramebufferStatus + { 0x00000001411A54F0, 0, }, // glCheckFramebufferStatusEXT + { 0x00000001411A3B80, 0, }, // glCheckNamedFramebufferStatusEXT + { 0x00000001411A4708, 0, }, // glClearBufferfi + { 0x00000001411A4700, 0, }, // glClearBufferfv + { 0x00000001411A46F0, 0, }, // glClearBufferiv + { 0x00000001411A46F8, 0, }, // glClearBufferuiv + { 0x00000001411A35E0, 0, }, // glClearColorIiEXT + { 0x00000001411A35E8, 0, }, // glClearColorIuiEXT + { 0x00000001411A34F0, 0, }, // glClearDepthdNV + { 0x00000001411A4728, 0, }, // glClientActiveTextureARB + { 0x00000001411A3630, 0, }, // glClientAttribDefaultEXT + { 0x00000001411A5350, 0, }, // glColor3hNV + { 0x00000001411A5358, 0, }, // glColor3hvNV + { 0x00000001411A5360, 0, }, // glColor4hNV + { 0x00000001411A5368, 0, }, // glColor4hvNV + { 0x00000001411A4550, 0, }, // glColorMaski + { 0x00000001411A3520, 0, }, // glColorMaskIndexedEXT + { 0x00000001411A4E68, 0, }, // glColorPointerEXT + { 0x00000001411A3BF8, 0, }, // glColorSubTable + { 0x00000001411A4EC0, 0, }, // glColorSubTableEXT + { 0x00000001411A3B88, 0, }, // glColorTable + { 0x00000001411A4EC8, 0, }, // glColorTableEXT + { 0x00000001411A3B98, 0, }, // glColorTableParameterfv + { 0x00000001411A3BA8, 0, }, // glColorTableParameteriv + { 0x00000001411A4FF8, 0, }, // glCombinerInputNV + { 0x00000001411A5000, 0, }, // glCombinerOutputNV + { 0x00000001411A4FE0, 0, }, // glCombinerParameterfNV + { 0x00000001411A4FD8, 0, }, // glCombinerParameterfvNV + { 0x00000001411A4FF0, 0, }, // glCombinerParameteriNV + { 0x00000001411A4FE8, 0, }, // glCombinerParameterivNV + { 0x00000001411A5078, 0, }, // glCombinerStageParameterfvNV + { 0x00000001411A4270, 0, }, // glCompileShader + { 0x00000001411A4BD0, 0, }, // glCompileShaderARB + { 0x00000001411A3910, 0, }, // glCompressedMultiTexImage1DEXT + { 0x00000001411A3908, 0, }, // glCompressedMultiTexImage2DEXT + { 0x00000001411A3900, 0, }, // glCompressedMultiTexImage3DEXT + { 0x00000001411A3928, 0, }, // glCompressedMultiTexSubImage1DEXT + { 0x00000001411A3920, 0, }, // glCompressedMultiTexSubImage2DEXT + { 0x00000001411A3918, 0, }, // glCompressedMultiTexSubImage3DEXT + { 0x00000001411A4010, 0, }, // glCompressedTexImage1D + { 0x00000001411A4868, 0, }, // glCompressedTexImage1DARB + { 0x00000001411A4008, 0, }, // glCompressedTexImage2D + { 0x00000001411A4860, 0, }, // glCompressedTexImage2DARB + { 0x00000001411A4000, 0, }, // glCompressedTexImage3D + { 0x00000001411A4858, 0, }, // glCompressedTexImage3DARB + { 0x00000001411A4028, 0, }, // glCompressedTexSubImage1D + { 0x00000001411A4880, 0, }, // glCompressedTexSubImage1DARB + { 0x00000001411A4020, 0, }, // glCompressedTexSubImage2D + { 0x00000001411A4878, 0, }, // glCompressedTexSubImage2DARB + { 0x00000001411A4018, 0, }, // glCompressedTexSubImage3D + { 0x00000001411A4870, 0, }, // glCompressedTexSubImage3DARB + { 0x00000001411A38D8, 0, }, // glCompressedTextureImage1DEXT + { 0x00000001411A38D0, 0, }, // glCompressedTextureImage2DEXT + { 0x00000001411A38C8, 0, }, // glCompressedTextureImage3DEXT + { 0x00000001411A38F0, 0, }, // glCompressedTextureSubImage1DEXT + { 0x00000001411A38E8, 0, }, // glCompressedTextureSubImage2DEXT + { 0x00000001411A38E0, 0, }, // glCompressedTextureSubImage3DEXT + { 0x00000001411A3C18, 0, }, // glConvolutionFilter1D + { 0x00000001411A3C28, 0, }, // glConvolutionFilter2D + { 0x00000001411A3C38, 0, }, // glConvolutionParameterf + { 0x00000001411A3C48, 0, }, // glConvolutionParameterfv + { 0x00000001411A3C58, 0, }, // glConvolutionParameteri + { 0x00000001411A3C68, 0, }, // glConvolutionParameteriv + { 0x00000001411A3C08, 0, }, // glCopyColorSubTable + { 0x00000001411A3BB8, 0, }, // glCopyColorTable + { 0x00000001411A3C78, 0, }, // glCopyConvolutionFilter1D + { 0x00000001411A3C88, 0, }, // glCopyConvolutionFilter2D + { 0x00000001411A4718, 0, }, // glCopyImageSubData + { 0x00000001411A37B8, 0, }, // glCopyMultiTexImage1DEXT + { 0x00000001411A37C0, 0, }, // glCopyMultiTexImage2DEXT + { 0x00000001411A37C8, 0, }, // glCopyMultiTexSubImage1DEXT + { 0x00000001411A3810, 0, }, // glCopyMultiTexSubImage3DEXT + { 0x00000001411A3DA8, 0, }, // glCopyTexSubImage3D + { 0x00000001411A4E28, 0, }, // glCopyTexSubImage3DEXT + { 0x00000001411A3718, 0, }, // glCopyTextureImage1DEXT + { 0x00000001411A3720, 0, }, // glCopyTextureImage2DEXT + { 0x00000001411A3728, 0, }, // glCopyTextureSubImage1DEXT + { 0x00000001411A3730, 0, }, // glCopyTextureSubImage2DEXT + { 0x00000001411A3770, 0, }, // glCopyTextureSubImage3DEXT + { 0x00000001411A4278, 0, }, // glCreateProgram + { 0x00000001411A4BD8, 0, }, // glCreateProgramObjectARB + { 0x00000001411A4280, 0, }, // glCreateShader + { 0x00000001411A4BC0, 0, }, // glCreateShaderObjectARB + { 0x00000001411A41E8, 0, }, // glDeleteBuffers + { 0x00000001411A5040, 0, }, // glDeleteFencesNV + { 0x00000001411A4D58, 0, }, // glDeleteFramebuffers + { 0x00000001411A4BA8, 0, }, // glDeleteObjectARB + { 0x00000001411A5290, 0, }, // glDeleteOcclusionQueriesNV + { 0x00000001411A4288, 0, }, // glDeleteProgram + { 0x00000001411A4A68, 0, }, // glDeleteProgramsARB + { 0x00000001411A5098, 0, }, // glDeleteProgramsNV + { 0x00000001411A41A8, 0, }, // glDeleteQueries + { 0x00000001411A4B70, 0, }, // glDeleteQueriesARB + { 0x00000001411A4D28, 0, }, // glDeleteRenderbuffers + { 0x00000001411A3F90, 0, }, // glDeleteSamplers + { 0x00000001411A4290, 0, }, // glDeleteShader + { 0x00000001411A4E40, 0, }, // glDeleteTexturesEXT + { 0x00000001411A4DF8, 0, }, // glDeleteVertexArrays + { 0x00000001411A34F8, 0, }, // glDepthBoundsdNV + { 0x00000001411A5490, 0, }, // glDepthBoundsEXT + { 0x00000001411A34E8, 0, }, // glDepthRangedNV + { 0x00000001411A4BB8, 0, }, // glDetachObjectARB + { 0x00000001411A4298, 0, }, // glDetachShader + { 0x00000001411A3828, 0, }, // glDisableClientStateIndexedEXT + { 0x00000001411A4570, 0, }, // glDisablei + { 0x00000001411A3540, 0, }, // glDisableIndexedEXT + { 0x00000001411A42A0, 0, }, // glDisableVertexAttribArray + { 0x00000001411A4E70, 0, }, // glDrawArraysEXT + { 0x00000001411A4D08, 0, }, // glDrawArraysInstancedARB + { 0x00000001411A5710, 0, }, // glDrawArraysInstancedEXT + { 0x00000001411A4240, 0, }, // glDrawBuffers + { 0x00000001411A4CF8, 0, }, // glDrawBuffersARB + { 0x00000001411A52D8, 0, }, // glDrawBuffersATI + { 0x00000001411A4D10, 0, }, // glDrawElementsInstancedARB + { 0x00000001411A5718, 0, }, // glDrawElementsInstancedEXT + { 0x00000001411A4EF8, 0, }, // glDrawRangeElementsEXT + { 0x00000001411A4E78, 0, }, // glEdgeFlagPointerEXT + { 0x00000001411A3820, 0, }, // glEnableClientStateIndexedEXT + { 0x00000001411A4568, 0, }, // glEnablei + { 0x00000001411A3538, 0, }, // glEnableIndexedEXT + { 0x00000001411A45B8, 0, }, // glEndConditionalRender + { 0x00000001411A35F8, 0, }, // glEndConditionalRenderNV + { 0x00000001411A52A8, 0, }, // glEndOcclusionQueryNV + { 0x00000001411A41C0, 0, }, // glEndQuery + { 0x00000001411A4B88, 0, }, // glEndQueryARB + { 0x00000001411A4588, 0, }, // glEndTransformFeedback + { 0x00000001411A3558, 0, }, // glEndTransformFeedbackNV + { 0x00000001411A50A0, 0, }, // glExecuteProgramNV + { 0x00000001411A5008, 0, }, // glFinalCombinerInputNV + { 0x00000001411A5068, 0, }, // glFinishFenceNV + { 0x00000001411A4DE0, 0, }, // glFlushMappedBufferRange + { 0x00000001411A5478, 0, }, // glFlushPixelDataRangeNV + { 0x00000001411A4FC8, 0, }, // glFlushVertexArrayRangeNV + { 0x00000001411A4050, 0, }, // glFogCoordd + { 0x00000001411A4FA8, 0, }, // glFogCoorddEXT + { 0x00000001411A4058, 0, }, // glFogCoorddv + { 0x00000001411A4FB0, 0, }, // glFogCoorddvEXT + { 0x00000001411A4040, 0, }, // glFogCoordf + { 0x00000001411A4F98, 0, }, // glFogCoordfEXT + { 0x00000001411A4048, 0, }, // glFogCoordfv + { 0x00000001411A4FA0, 0, }, // glFogCoordfvEXT + { 0x00000001411A53F0, 0, }, // glFogCoordhNV + { 0x00000001411A53F8, 0, }, // glFogCoordhvNV + { 0x00000001411A4060, 0, }, // glFogCoordPointer + { 0x00000001411A4FB8, 0, }, // glFogCoordPointerEXT + { 0x00000001411A3C00, 0, }, // glFramebufferDrawBufferEXT + { 0x00000001411A3C10, 0, }, // glFramebufferDrawBuffersEXT + { 0x00000001411A3C20, 0, }, // glFramebufferReadBufferEXT + { 0x00000001411A4D88, 0, }, // glFramebufferRenderbuffer + { 0x00000001411A3F50, 0, }, // glFramebufferTexture + { 0x00000001411A4D70, 0, }, // glFramebufferTexture1D + { 0x00000001411A54F8, 0, }, // glFramebufferTexture1DEXT + { 0x00000001411A4D78, 0, }, // glFramebufferTexture2D + { 0x00000001411A4D80, 0, }, // glFramebufferTexture3D + { 0x00000001411A5508, 0, }, // glFramebufferTexture3DEXT + { 0x00000001411A4DC0, 0, }, // glFramebufferTextureARB + { 0x00000001411A55E0, 0, }, // glFramebufferTextureEXT + { 0x00000001411A4DD0, 0, }, // glFramebufferTextureFaceARB + { 0x00000001411A55F0, 0, }, // glFramebufferTextureFaceEXT + { 0x00000001411A4DB0, 0, }, // glFramebufferTextureLayer + { 0x00000001411A4DC8, 0, }, // glFramebufferTextureLayerARB + { 0x00000001411A55E8, 0, }, // glFramebufferTextureLayerEXT + { 0x00000001411A41F0, 0, }, // glGenBuffers + { 0x00000001411A4B20, 0, }, // glGenBuffersARB + { 0x00000001411A4D98, 0, }, // glGenerateMipmap + { 0x00000001411A5520, 0, }, // glGenerateMipmapEXT + { 0x00000001411A3BF0, 0, }, // glGenerateMultiTexMipmapEXT + { 0x00000001411A3BE0, 0, }, // glGenerateTextureMipmapEXT + { 0x00000001411A5048, 0, }, // glGenFencesNV + { 0x00000001411A4D60, 0, }, // glGenFramebuffers + { 0x00000001411A5288, 0, }, // glGenOcclusionQueriesNV + { 0x00000001411A4A70, 0, }, // glGenProgramsARB + { 0x00000001411A50A8, 0, }, // glGenProgramsNV + { 0x00000001411A41A0, 0, }, // glGenQueries + { 0x00000001411A4B68, 0, }, // glGenQueriesARB + { 0x00000001411A4D30, 0, }, // glGenRenderbuffers + { 0x00000001411A3F80, 0, }, // glGenSamplers + { 0x00000001411A4E48, 0, }, // glGenTexturesEXT + { 0x00000001411A4E00, 0, }, // glGenVertexArrays + { 0x00000001411A42B0, 0, }, // glGetActiveAttrib + { 0x00000001411A4CE8, 0, }, // glGetActiveAttribARB + { 0x00000001411A42B8, 0, }, // glGetActiveUniform + { 0x00000001411A4CC0, 0, }, // glGetActiveUniformARB + { 0x00000001411A3598, 0, }, // glGetActiveVaryingNV + { 0x00000001411A4CB0, 0, }, // glGetAttachedObjectsARB + { 0x00000001411A42C0, 0, }, // glGetAttachedShaders + { 0x00000001411A42C8, 0, }, // glGetAttribLocation + { 0x00000001411A4CF0, 0, }, // glGetAttribLocationARB + { 0x00000001411A4558, 0, }, // glGetBooleani_v + { 0x00000001411A3528, 0, }, // glGetBooleanIndexedvEXT + { 0x00000001411A4228, 0, }, // glGetBufferParameteriv + { 0x00000001411A4B58, 0, }, // glGetBufferParameterivARB + { 0x00000001411A4230, 0, }, // glGetBufferPointerv + { 0x00000001411A4B60, 0, }, // glGetBufferPointervARB + { 0x00000001411A4210, 0, }, // glGetBufferSubData + { 0x00000001411A4B40, 0, }, // glGetBufferSubDataARB + { 0x00000001411A3BC8, 0, }, // glGetColorTable + { 0x00000001411A4ED0, 0, }, // glGetColorTableEXT + { 0x00000001411A3BD8, 0, }, // glGetColorTableParameterfv + { 0x00000001411A4EE0, 0, }, // glGetColorTableParameterfvEXT + { 0x00000001411A3BE8, 0, }, // glGetColorTableParameteriv + { 0x00000001411A4ED8, 0, }, // glGetColorTableParameterivEXT + { 0x00000001411A5010, 0, }, // glGetCombinerInputParameterfvNV + { 0x00000001411A5018, 0, }, // glGetCombinerInputParameterivNV + { 0x00000001411A5020, 0, }, // glGetCombinerOutputParameterfvNV + { 0x00000001411A5028, 0, }, // glGetCombinerOutputParameterivNV + { 0x00000001411A5080, 0, }, // glGetCombinerStageParameterfvNV + { 0x00000001411A3930, 0, }, // glGetCompressedMultiTexImageEXT + { 0x00000001411A4030, 0, }, // glGetCompressedTexImage + { 0x00000001411A4888, 0, }, // glGetCompressedTexImageARB + { 0x00000001411A38F8, 0, }, // glGetCompressedTextureImageEXT + { 0x00000001411A3C98, 0, }, // glGetConvolutionFilter + { 0x00000001411A3CA8, 0, }, // glGetConvolutionParameterfv + { 0x00000001411A3CB8, 0, }, // glGetConvolutionParameteriv + { 0x00000001411A38B8, 0, }, // glGetDoubleIndexedvEXT + { 0x00000001411A5060, 0, }, // glGetFenceivNV + { 0x00000001411A5030, 0, }, // glGetFinalCombinerInputParameterfvNV + { 0x00000001411A5038, 0, }, // glGetFinalCombinerInputParameterivNV + { 0x00000001411A38B0, 0, }, // glGetFloatIndexedvEXT + { 0x00000001411A4688, 0, }, // glGetFragDataLocation + { 0x00000001411A56C8, 0, }, // glGetFragDataLocationEXT + { 0x00000001411A4D90, 0, }, // glGetFramebufferAttachmentParameteriv + { 0x00000001411A5518, 0, }, // glGetFramebufferAttachmentParameterivEXT + { 0x00000001411A3C30, 0, }, // glGetFramebufferParameterivEXT + { 0x00000001411A4BB0, 0, }, // glGetHandleARB + { 0x00000001411A3CE8, 0, }, // glGetHistogram + { 0x00000001411A3CF8, 0, }, // glGetHistogramParameterfv + { 0x00000001411A3D08, 0, }, // glGetHistogramParameteriv + { 0x00000001411A4CA8, 0, }, // glGetInfoLogARB + { 0x00000001411A4560, 0, }, // glGetIntegeri_v + { 0x00000001411A3530, 0, }, // glGetIntegerIndexedvEXT + { 0x00000001411A3D18, 0, }, // glGetMinmax + { 0x00000001411A3D28, 0, }, // glGetMinmaxParameterfv + { 0x00000001411A3D38, 0, }, // glGetMinmaxParameteriv + { 0x00000001411A3CB0, 0, }, // glGetMultisamplefvNV + { 0x00000001411A3888, 0, }, // glGetMultiTexEnvfvEXT + { 0x00000001411A3890, 0, }, // glGetMultiTexEnvivEXT + { 0x00000001411A3898, 0, }, // glGetMultiTexGendvEXT + { 0x00000001411A38A0, 0, }, // glGetMultiTexGenfvEXT + { 0x00000001411A38A8, 0, }, // glGetMultiTexGenivEXT + { 0x00000001411A37D8, 0, }, // glGetMultiTexImageEXT + { 0x00000001411A37F0, 0, }, // glGetMultiTexLevelParameterfvEXT + { 0x00000001411A37F8, 0, }, // glGetMultiTexLevelParameterivEXT + { 0x00000001411A37E0, 0, }, // glGetMultiTexParameterfvEXT + { 0x00000001411A39F8, 0, }, // glGetMultiTexParameterIivEXT + { 0x00000001411A3A00, 0, }, // glGetMultiTexParameterIuivEXT + { 0x00000001411A37E8, 0, }, // glGetMultiTexParameterivEXT + { 0x00000001411A3B30, 0, }, // glGetNamedBufferParameterivEXT + { 0x00000001411A3B38, 0, }, // glGetNamedBufferPointervEXT + { 0x00000001411A3B40, 0, }, // glGetNamedBufferSubDataEXT + { 0x00000001411A3BD0, 0, }, // glGetNamedFramebufferAttachmentParameterivEXT + { 0x00000001411A3970, 0, }, // glGetNamedProgramivEXT + { 0x00000001411A3960, 0, }, // glGetNamedProgramLocalParameterdvEXT + { 0x00000001411A3968, 0, }, // glGetNamedProgramLocalParameterfvEXT + { 0x00000001411A39B8, 0, }, // glGetNamedProgramLocalParameterIivEXT + { 0x00000001411A39C0, 0, }, // glGetNamedProgramLocalParameterIuivEXT + { 0x00000001411A3978, 0, }, // glGetNamedProgramStringEXT + { 0x00000001411A3B70, 0, }, // glGetNamedRenderbufferParameterivEXT + { 0x00000001411A4C98, 0, }, // glGetObjectParameterfvARB + { 0x00000001411A4CA0, 0, }, // glGetObjectParameterivARB + { 0x00000001411A52B0, 0, }, // glGetOcclusionQueryivNV + { 0x00000001411A52B8, 0, }, // glGetOcclusionQueryuivNV + { 0x00000001411A38C0, 0, }, // glGetPointerIndexedvEXT + { 0x00000001411A4E80, 0, }, // glGetPointervEXT + { 0x00000001411A4AB8, 0, }, // glGetProgramEnvParameterdvARB + { 0x00000001411A55C8, 0, }, // glGetProgramEnvParameterIivNV + { 0x00000001411A55D0, 0, }, // glGetProgramEnvParameterIuivNV + { 0x00000001411A42D8, 0, }, // glGetProgramInfoLog + { 0x00000001411A42D0, 0, }, // glGetProgramiv + { 0x00000001411A50C0, 0, }, // glGetProgramivNV + { 0x00000001411A4AC8, 0, }, // glGetProgramLocalParameterdvARB + { 0x00000001411A4AD0, 0, }, // glGetProgramLocalParameterfvARB + { 0x00000001411A55B8, 0, }, // glGetProgramLocalParameterIivNV + { 0x00000001411A55C0, 0, }, // glGetProgramLocalParameterIuivNV + { 0x00000001411A5308, 0, }, // glGetProgramNamedParameterdvNV + { 0x00000001411A5300, 0, }, // glGetProgramNamedParameterfvNV + { 0x00000001411A50B0, 0, }, // glGetProgramParameterdvNV + { 0x00000001411A50B8, 0, }, // glGetProgramParameterfvNV + { 0x00000001411A4AE0, 0, }, // glGetProgramStringARB + { 0x00000001411A50C8, 0, }, // glGetProgramStringNV + { 0x00000001411A41C8, 0, }, // glGetQueryiv + { 0x00000001411A4B90, 0, }, // glGetQueryivARB + { 0x00000001411A5538, 0, }, // glGetQueryObjecti64vEXT + { 0x00000001411A41D0, 0, }, // glGetQueryObjectiv + { 0x00000001411A4B98, 0, }, // glGetQueryObjectivARB + { 0x00000001411A3F40, 0, }, // glGetQueryObjectui64v + { 0x00000001411A5540, 0, }, // glGetQueryObjectui64vEXT + { 0x00000001411A41D8, 0, }, // glGetQueryObjectuiv + { 0x00000001411A4BA0, 0, }, // glGetQueryObjectuivARB + { 0x00000001411A4D40, 0, }, // glGetRenderbufferParameteriv + { 0x00000001411A54C8, 0, }, // glGetRenderbufferParameterivEXT + { 0x00000001411A3CC8, 0, }, // glGetSeparableFilter + { 0x00000001411A42E8, 0, }, // glGetShaderInfoLog + { 0x00000001411A42E0, 0, }, // glGetShaderiv + { 0x00000001411A42F0, 0, }, // glGetShaderSource + { 0x00000001411A4CD8, 0, }, // glGetShaderSourceARB + { 0x00000001411A4710, 0, }, // glGetStringi + { 0x00000001411A46E0, 0, }, // glGetTexParameterIiv + { 0x00000001411A35D0, 0, }, // glGetTexParameterIivEXT + { 0x00000001411A46E8, 0, }, // glGetTexParameterIuiv + { 0x00000001411A35D8, 0, }, // glGetTexParameterIuivEXT + { 0x00000001411A3750, 0, }, // glGetTextureLevelParameterfvEXT + { 0x00000001411A3758, 0, }, // glGetTextureLevelParameterivEXT + { 0x00000001411A3740, 0, }, // glGetTextureParameterfvEXT + { 0x00000001411A39D8, 0, }, // glGetTextureParameterIivEXT + { 0x00000001411A39E0, 0, }, // glGetTextureParameterIuivEXT + { 0x00000001411A3748, 0, }, // glGetTextureParameterivEXT + { 0x00000001411A50D0, 0, }, // glGetTrackMatrixivNV + { 0x00000001411A45A8, 0, }, // glGetTransformFeedbackVarying + { 0x00000001411A35A0, 0, }, // glGetTransformFeedbackVaryingNV + { 0x00000001411A35B0, 0, }, // glGetUniformBufferSizeEXT + { 0x00000001411A4300, 0, }, // glGetUniformfv + { 0x00000001411A4CC8, 0, }, // glGetUniformfvARB + { 0x00000001411A4308, 0, }, // glGetUniformiv + { 0x00000001411A4CD0, 0, }, // glGetUniformivARB + { 0x00000001411A42F8, 0, }, // glGetUniformLocation + { 0x00000001411A4CB8, 0, }, // glGetUniformLocationARB + { 0x00000001411A35B8, 0, }, // glGetUniformOffsetEXT + { 0x00000001411A4678, 0, }, // glGetUniformuiv + { 0x00000001411A56B8, 0, }, // glGetUniformuivEXT + { 0x00000001411A3590, 0, }, // glGetVaryingLocationNV + { 0x00000001411A4310, 0, }, // glGetVertexAttribdv + { 0x00000001411A4AE8, 0, }, // glGetVertexAttribdvARB + { 0x00000001411A50D8, 0, }, // glGetVertexAttribdvNV + { 0x00000001411A4318, 0, }, // glGetVertexAttribfv + { 0x00000001411A4AF0, 0, }, // glGetVertexAttribfvARB + { 0x00000001411A50E0, 0, }, // glGetVertexAttribfvNV + { 0x00000001411A4668, 0, }, // glGetVertexAttribIiv + { 0x00000001411A56A8, 0, }, // glGetVertexAttribIivEXT + { 0x00000001411A4670, 0, }, // glGetVertexAttribIuiv + { 0x00000001411A56B0, 0, }, // glGetVertexAttribIuivEXT + { 0x00000001411A4320, 0, }, // glGetVertexAttribiv + { 0x00000001411A4AF8, 0, }, // glGetVertexAttribivARB + { 0x00000001411A50E8, 0, }, // glGetVertexAttribivNV + { 0x00000001411A4328, 0, }, // glGetVertexAttribPointerv + { 0x00000001411A4B00, 0, }, // glGetVertexAttribPointervARB + { 0x00000001411A50F0, 0, }, // glGetVertexAttribPointervNV + { 0x00000001411A3620, 0, }, // glGetVideoi64vNV + { 0x00000001411A3610, 0, }, // glGetVideoivNV + { 0x00000001411A3628, 0, }, // glGetVideoui64vNV + { 0x00000001411A3618, 0, }, // glGetVideouivNV + { 0x00000001411A3D48, 0, }, // glHistogram + { 0x00000001411A4E88, 0, }, // glIndexPointerEXT + { 0x00000001411A41F8, 0, }, // glIsBuffer + { 0x00000001411A4578, 0, }, // glIsEnabledi + { 0x00000001411A3548, 0, }, // glIsEnabledIndexedEXT + { 0x00000001411A5050, 0, }, // glIsFenceNV + { 0x00000001411A4D48, 0, }, // glIsFramebuffer + { 0x00000001411A54D0, 0, }, // glIsFramebufferEXT + { 0x00000001411A5298, 0, }, // glIsOcclusionQueryNV + { 0x00000001411A4330, 0, }, // glIsProgram + { 0x00000001411A4B08, 0, }, // glIsProgramARB + { 0x00000001411A50F8, 0, }, // glIsProgramNV + { 0x00000001411A41B0, 0, }, // glIsQuery + { 0x00000001411A4B78, 0, }, // glIsQueryARB + { 0x00000001411A4D18, 0, }, // glIsRenderbuffer + { 0x00000001411A54A0, 0, }, // glIsRenderbufferEXT + { 0x00000001411A4338, 0, }, // glIsShader + { 0x00000001411A4E50, 0, }, // glIsTextureEXT + { 0x00000001411A4E08, 0, }, // glIsVertexArray + { 0x00000001411A4340, 0, }, // glLinkProgram + { 0x00000001411A4BE8, 0, }, // glLinkProgramARB + { 0x00000001411A5100, 0, }, // glLoadProgramNV + { 0x00000001411A3FE0, 0, }, // glLoadTransposeMatrixd + { 0x00000001411A4838, 0, }, // glLoadTransposeMatrixdARB + { 0x00000001411A4830, 0, }, // glLoadTransposeMatrixfARB + { 0x00000001411A4EE8, 0, }, // glLockArraysEXT + { 0x00000001411A4218, 0, }, // glMapBuffer + { 0x00000001411A4B48, 0, }, // glMapBufferARB + { 0x00000001411A4DD8, 0, }, // glMapBufferRange + { 0x00000001411A3698, 0, }, // glMatrixFrustumEXT + { 0x00000001411A3648, 0, }, // glMatrixLoaddEXT + { 0x00000001411A3640, 0, }, // glMatrixLoadfEXT + { 0x00000001411A3660, 0, }, // glMatrixLoadIdentityEXT + { 0x00000001411A36C0, 0, }, // glMatrixLoadTransposedEXT + { 0x00000001411A36B8, 0, }, // glMatrixLoadTransposefEXT + { 0x00000001411A3658, 0, }, // glMatrixMultdEXT + { 0x00000001411A3650, 0, }, // glMatrixMultfEXT + { 0x00000001411A36D0, 0, }, // glMatrixMultTransposedEXT + { 0x00000001411A36C8, 0, }, // glMatrixMultTransposefEXT + { 0x00000001411A36A0, 0, }, // glMatrixOrthoEXT + { 0x00000001411A36A8, 0, }, // glMatrixPopEXT + { 0x00000001411A36B0, 0, }, // glMatrixPushEXT + { 0x00000001411A3670, 0, }, // glMatrixRotatedEXT + { 0x00000001411A3668, 0, }, // glMatrixRotatefEXT + { 0x00000001411A3680, 0, }, // glMatrixScaledEXT + { 0x00000001411A3678, 0, }, // glMatrixScalefEXT + { 0x00000001411A3690, 0, }, // glMatrixTranslatedEXT + { 0x00000001411A3688, 0, }, // glMatrixTranslatefEXT + { 0x00000001411A3D58, 0, }, // glMinmax + { 0x00000001411A4068, 0, }, // glMultiDrawArrays + { 0x00000001411A4F88, 0, }, // glMultiDrawArraysEXT + { 0x00000001411A4070, 0, }, // glMultiDrawElements + { 0x00000001411A4F90, 0, }, // glMultiDrawElementsEXT + { 0x00000001411A3B50, 0, }, // glMultiTexBufferEXT + { 0x00000001411A3DD8, 0, }, // glMultiTexCoord1d + { 0x00000001411A4730, 0, }, // glMultiTexCoord1dARB + { 0x00000001411A3DE8, 0, }, // glMultiTexCoord1dv + { 0x00000001411A4738, 0, }, // glMultiTexCoord1dvARB + { 0x00000001411A3DF8, 0, }, // glMultiTexCoord1f + { 0x00000001411A4740, 0, }, // glMultiTexCoord1fARB + { 0x00000001411A3E08, 0, }, // glMultiTexCoord1fv + { 0x00000001411A4748, 0, }, // glMultiTexCoord1fvARB + { 0x00000001411A53B0, 0, }, // glMultiTexCoord1hNV + { 0x00000001411A53B8, 0, }, // glMultiTexCoord1hvNV + { 0x00000001411A3E18, 0, }, // glMultiTexCoord1i + { 0x00000001411A4750, 0, }, // glMultiTexCoord1iARB + { 0x00000001411A3E28, 0, }, // glMultiTexCoord1iv + { 0x00000001411A4758, 0, }, // glMultiTexCoord1ivARB + { 0x00000001411A3E38, 0, }, // glMultiTexCoord1s + { 0x00000001411A4760, 0, }, // glMultiTexCoord1sARB + { 0x00000001411A3E48, 0, }, // glMultiTexCoord1sv + { 0x00000001411A4768, 0, }, // glMultiTexCoord1svARB + { 0x00000001411A3E58, 0, }, // glMultiTexCoord2d + { 0x00000001411A4770, 0, }, // glMultiTexCoord2dARB + { 0x00000001411A3E68, 0, }, // glMultiTexCoord2dv + { 0x00000001411A4778, 0, }, // glMultiTexCoord2dvARB + { 0x00000001411A4780, 0, }, // glMultiTexCoord2fARB + { 0x00000001411A4788, 0, }, // glMultiTexCoord2fvARB + { 0x00000001411A53C0, 0, }, // glMultiTexCoord2hNV + { 0x00000001411A53C8, 0, }, // glMultiTexCoord2hvNV + { 0x00000001411A3E98, 0, }, // glMultiTexCoord2i + { 0x00000001411A4790, 0, }, // glMultiTexCoord2iARB + { 0x00000001411A3EA8, 0, }, // glMultiTexCoord2iv + { 0x00000001411A4798, 0, }, // glMultiTexCoord2ivARB + { 0x00000001411A3EB8, 0, }, // glMultiTexCoord2s + { 0x00000001411A47A0, 0, }, // glMultiTexCoord2sARB + { 0x00000001411A3EC8, 0, }, // glMultiTexCoord2sv + { 0x00000001411A47A8, 0, }, // glMultiTexCoord2svARB + { 0x00000001411A3ED8, 0, }, // glMultiTexCoord3d + { 0x00000001411A47B0, 0, }, // glMultiTexCoord3dARB + { 0x00000001411A3EE8, 0, }, // glMultiTexCoord3dv + { 0x00000001411A47B8, 0, }, // glMultiTexCoord3dvARB + { 0x00000001411A3EF8, 0, }, // glMultiTexCoord3f + { 0x00000001411A47C0, 0, }, // glMultiTexCoord3fARB + { 0x00000001411A3F08, 0, }, // glMultiTexCoord3fv + { 0x00000001411A47C8, 0, }, // glMultiTexCoord3fvARB + { 0x00000001411A53D0, 0, }, // glMultiTexCoord3hNV + { 0x00000001411A53D8, 0, }, // glMultiTexCoord3hvNV + { 0x00000001411A3F18, 0, }, // glMultiTexCoord3i + { 0x00000001411A47D0, 0, }, // glMultiTexCoord3iARB + { 0x00000001411A3F28, 0, }, // glMultiTexCoord3iv + { 0x00000001411A47D8, 0, }, // glMultiTexCoord3ivARB + { 0x00000001411A3F38, 0, }, // glMultiTexCoord3s + { 0x00000001411A47E0, 0, }, // glMultiTexCoord3sARB + { 0x00000001411A3F48, 0, }, // glMultiTexCoord3sv + { 0x00000001411A47E8, 0, }, // glMultiTexCoord3svARB + { 0x00000001411A3F58, 0, }, // glMultiTexCoord4d + { 0x00000001411A47F0, 0, }, // glMultiTexCoord4dARB + { 0x00000001411A3F68, 0, }, // glMultiTexCoord4dv + { 0x00000001411A47F8, 0, }, // glMultiTexCoord4dvARB + { 0x00000001411A3F78, 0, }, // glMultiTexCoord4f + { 0x00000001411A4800, 0, }, // glMultiTexCoord4fARB + { 0x00000001411A3F88, 0, }, // glMultiTexCoord4fv + { 0x00000001411A4808, 0, }, // glMultiTexCoord4fvARB + { 0x00000001411A53E0, 0, }, // glMultiTexCoord4hNV + { 0x00000001411A53E8, 0, }, // glMultiTexCoord4hvNV + { 0x00000001411A3F98, 0, }, // glMultiTexCoord4i + { 0x00000001411A4810, 0, }, // glMultiTexCoord4iARB + { 0x00000001411A3FA8, 0, }, // glMultiTexCoord4iv + { 0x00000001411A4818, 0, }, // glMultiTexCoord4ivARB + { 0x00000001411A3FB8, 0, }, // glMultiTexCoord4s + { 0x00000001411A4820, 0, }, // glMultiTexCoord4sARB + { 0x00000001411A3FC8, 0, }, // glMultiTexCoord4sv + { 0x00000001411A4828, 0, }, // glMultiTexCoord4svARB + { 0x00000001411A3830, 0, }, // glMultiTexCoordPointerEXT + { 0x00000001411A3838, 0, }, // glMultiTexEnvfEXT + { 0x00000001411A3840, 0, }, // glMultiTexEnvfvEXT + { 0x00000001411A3848, 0, }, // glMultiTexEnviEXT + { 0x00000001411A3850, 0, }, // glMultiTexEnvivEXT + { 0x00000001411A3858, 0, }, // glMultiTexGendEXT + { 0x00000001411A3860, 0, }, // glMultiTexGendvEXT + { 0x00000001411A3868, 0, }, // glMultiTexGenfEXT + { 0x00000001411A3870, 0, }, // glMultiTexGenfvEXT + { 0x00000001411A3878, 0, }, // glMultiTexGeniEXT + { 0x00000001411A3880, 0, }, // glMultiTexGenivEXT + { 0x00000001411A3798, 0, }, // glMultiTexImage1DEXT + { 0x00000001411A37A0, 0, }, // glMultiTexImage2DEXT + { 0x00000001411A3800, 0, }, // glMultiTexImage3DEXT + { 0x00000001411A3778, 0, }, // glMultiTexParameterfEXT + { 0x00000001411A3780, 0, }, // glMultiTexParameterfvEXT + { 0x00000001411A3788, 0, }, // glMultiTexParameteriEXT + { 0x00000001411A39E8, 0, }, // glMultiTexParameterIivEXT + { 0x00000001411A39F0, 0, }, // glMultiTexParameterIuivEXT + { 0x00000001411A3790, 0, }, // glMultiTexParameterivEXT + { 0x00000001411A3CA0, 0, }, // glMultiTexRenderbufferEXT + { 0x00000001411A37A8, 0, }, // glMultiTexSubImage1DEXT + { 0x00000001411A37B0, 0, }, // glMultiTexSubImage2DEXT + { 0x00000001411A3808, 0, }, // glMultiTexSubImage3DEXT + { 0x00000001411A3FF0, 0, }, // glMultTransposeMatrixd + { 0x00000001411A4848, 0, }, // glMultTransposeMatrixdARB + { 0x00000001411A4840, 0, }, // glMultTransposeMatrixfARB + { 0x00000001411A3BC0, 0, }, // glNamedFramebufferRenderbufferEXT + { 0x00000001411A3B90, 0, }, // glNamedFramebufferTexture1DEXT + { 0x00000001411A3BA0, 0, }, // glNamedFramebufferTexture2DEXT + { 0x00000001411A3BB0, 0, }, // glNamedFramebufferTexture3DEXT + { 0x00000001411A3C60, 0, }, // glNamedFramebufferTextureEXT + { 0x00000001411A3C80, 0, }, // glNamedFramebufferTextureFaceEXT + { 0x00000001411A3C70, 0, }, // glNamedFramebufferTextureLayerEXT + { 0x00000001411A3940, 0, }, // glNamedProgramLocalParameter4dEXT + { 0x00000001411A3948, 0, }, // glNamedProgramLocalParameter4dvEXT + { 0x00000001411A3950, 0, }, // glNamedProgramLocalParameter4fEXT + { 0x00000001411A3958, 0, }, // glNamedProgramLocalParameter4fvEXT + { 0x00000001411A3988, 0, }, // glNamedProgramLocalParameterI4iEXT + { 0x00000001411A3990, 0, }, // glNamedProgramLocalParameterI4ivEXT + { 0x00000001411A39A0, 0, }, // glNamedProgramLocalParameterI4uiEXT + { 0x00000001411A39A8, 0, }, // glNamedProgramLocalParameterI4uivEXT + { 0x00000001411A3980, 0, }, // glNamedProgramLocalParameters4fvEXT + { 0x00000001411A3998, 0, }, // glNamedProgramLocalParametersI4ivEXT + { 0x00000001411A39B0, 0, }, // glNamedProgramLocalParametersI4uivEXT + { 0x00000001411A3938, 0, }, // glNamedProgramStringEXT + { 0x00000001411A3B60, 0, }, // glNamedRenderbufferStorageEXT + { 0x00000001411A3C50, 0, }, // glNamedRenderbufferStorageMultisampleCoverageEXT + { 0x00000001411A3C40, 0, }, // glNamedRenderbufferStorageMultisampleEXT + { 0x00000001411A5340, 0, }, // glNormal3hNV + { 0x00000001411A5348, 0, }, // glNormal3hvNV + { 0x00000001411A4E90, 0, }, // glNormalPointerEXT + { 0x00000001411A5470, 0, }, // glPixelDataRangeNV + { 0x00000001411A4890, 0, }, // glPointParameterfARB + { 0x00000001411A4EB0, 0, }, // glPointParameterfEXT + { 0x00000001411A4898, 0, }, // glPointParameterfvARB + { 0x00000001411A4EB8, 0, }, // glPointParameterfvEXT + { 0x00000001411A52C0, 0, }, // glPointParameteriNV + { 0x00000001411A4090, 0, }, // glPointParameteriv + { 0x00000001411A52C8, 0, }, // glPointParameterivNV + { 0x00000001411A3608, 0, }, // glPresentFrameDualFillNV + { 0x00000001411A3600, 0, }, // glPresentFrameKeyedNV + { 0x00000001411A5480, 0, }, // glPrimitiveRestartNV + { 0x00000001411A4E58, 0, }, // glPrioritizeTexturesEXT + { 0x00000001411A3510, 0, }, // glProgramBufferParametersIivNV + { 0x00000001411A3518, 0, }, // glProgramBufferParametersIuivNV + { 0x00000001411A4A78, 0, }, // glProgramEnvParameter4dARB + { 0x00000001411A4A80, 0, }, // glProgramEnvParameter4dvARB + { 0x00000001411A5588, 0, }, // glProgramEnvParameterI4iNV + { 0x00000001411A5590, 0, }, // glProgramEnvParameterI4ivNV + { 0x00000001411A55A0, 0, }, // glProgramEnvParameterI4uiNV + { 0x00000001411A55A8, 0, }, // glProgramEnvParameterI4uivNV + { 0x00000001411A5598, 0, }, // glProgramEnvParametersI4ivNV + { 0x00000001411A55B0, 0, }, // glProgramEnvParametersI4uivNV + { 0x00000001411A4A98, 0, }, // glProgramLocalParameter4dARB + { 0x00000001411A4AA0, 0, }, // glProgramLocalParameter4dvARB + { 0x00000001411A5558, 0, }, // glProgramLocalParameterI4iNV + { 0x00000001411A5560, 0, }, // glProgramLocalParameterI4ivNV + { 0x00000001411A5570, 0, }, // glProgramLocalParameterI4uiNV + { 0x00000001411A5578, 0, }, // glProgramLocalParameterI4uivNV + { 0x00000001411A5568, 0, }, // glProgramLocalParametersI4ivNV + { 0x00000001411A5580, 0, }, // glProgramLocalParametersI4uivNV + { 0x00000001411A52E8, 0, }, // glProgramNamedParameter4dNV + { 0x00000001411A52F8, 0, }, // glProgramNamedParameter4dvNV + { 0x00000001411A52E0, 0, }, // glProgramNamedParameter4fNV + { 0x00000001411A52F0, 0, }, // glProgramNamedParameter4fvNV + { 0x00000001411A5108, 0, }, // glProgramParameter4dNV + { 0x00000001411A5110, 0, }, // glProgramParameter4dvNV + { 0x00000001411A5118, 0, }, // glProgramParameter4fNV + { 0x00000001411A5120, 0, }, // glProgramParameter4fvNV + { 0x00000001411A4DB8, 0, }, // glProgramParameteriARB + { 0x00000001411A55F8, 0, }, // glProgramParameteriEXT + { 0x00000001411A5128, 0, }, // glProgramParameters4dvNV + { 0x00000001411A5130, 0, }, // glProgramParameters4fvNV + { 0x00000001411A4A58, 0, }, // glProgramStringARB + { 0x00000001411A3A08, 0, }, // glProgramUniform1fEXT + { 0x00000001411A3A48, 0, }, // glProgramUniform1fvEXT + { 0x00000001411A3A28, 0, }, // glProgramUniform1iEXT + { 0x00000001411A3A68, 0, }, // glProgramUniform1ivEXT + { 0x00000001411A3AD0, 0, }, // glProgramUniform1uiEXT + { 0x00000001411A3AF0, 0, }, // glProgramUniform1uivEXT + { 0x00000001411A3A10, 0, }, // glProgramUniform2fEXT + { 0x00000001411A3A50, 0, }, // glProgramUniform2fvEXT + { 0x00000001411A3A30, 0, }, // glProgramUniform2iEXT + { 0x00000001411A3A70, 0, }, // glProgramUniform2ivEXT + { 0x00000001411A3AD8, 0, }, // glProgramUniform2uiEXT + { 0x00000001411A3AF8, 0, }, // glProgramUniform2uivEXT + { 0x00000001411A3A18, 0, }, // glProgramUniform3fEXT + { 0x00000001411A3A58, 0, }, // glProgramUniform3fvEXT + { 0x00000001411A3A38, 0, }, // glProgramUniform3iEXT + { 0x00000001411A3A78, 0, }, // glProgramUniform3ivEXT + { 0x00000001411A3AE0, 0, }, // glProgramUniform3uiEXT + { 0x00000001411A3B00, 0, }, // glProgramUniform3uivEXT + { 0x00000001411A3A20, 0, }, // glProgramUniform4fEXT + { 0x00000001411A3A60, 0, }, // glProgramUniform4fvEXT + { 0x00000001411A3A40, 0, }, // glProgramUniform4iEXT + { 0x00000001411A3A80, 0, }, // glProgramUniform4ivEXT + { 0x00000001411A3AE8, 0, }, // glProgramUniform4uiEXT + { 0x00000001411A3B08, 0, }, // glProgramUniform4uivEXT + { 0x00000001411A3A88, 0, }, // glProgramUniformMatrix2fvEXT + { 0x00000001411A3AA0, 0, }, // glProgramUniformMatrix2x3fvEXT + { 0x00000001411A3AB0, 0, }, // glProgramUniformMatrix2x4fvEXT + { 0x00000001411A3A90, 0, }, // glProgramUniformMatrix3fvEXT + { 0x00000001411A3AA8, 0, }, // glProgramUniformMatrix3x2fvEXT + { 0x00000001411A3AC0, 0, }, // glProgramUniformMatrix3x4fvEXT + { 0x00000001411A3A98, 0, }, // glProgramUniformMatrix4fvEXT + { 0x00000001411A3AB8, 0, }, // glProgramUniformMatrix4x2fvEXT + { 0x00000001411A3AC8, 0, }, // glProgramUniformMatrix4x3fvEXT + { 0x00000001411A55D8, 0, }, // glProgramVertexLimitNV + { 0x00000001411A3638, 0, }, // glPushClientAttribDefaultEXT + { 0x00000001411A3F30, 0, }, // glQueryCounter + { 0x00000001411A4D38, 0, }, // glRenderbufferStorage + { 0x00000001411A4DA8, 0, }, // glRenderbufferStorageMultisample + { 0x00000001411A5530, 0, }, // glRenderbufferStorageMultisampleEXT + { 0x00000001411A5138, 0, }, // glRequestResidentProgramsNV + { 0x00000001411A3D68, 0, }, // glResetHistogram + { 0x00000001411A3D78, 0, }, // glResetMinmax + { 0x00000001411A3FF8, 0, }, // glSampleCoverage + { 0x00000001411A4850, 0, }, // glSampleCoverageARB + { 0x00000001411A3CC0, 0, }, // glSampleMaskIndexedNV + { 0x00000001411A3FC0, 0, }, // glSamplerParameterf + { 0x00000001411A3FD0, 0, }, // glSamplerParameterfv + { 0x00000001411A3FB0, 0, }, // glSamplerParameteri + { 0x00000001411A4098, 0, }, // glSecondaryColor3b + { 0x00000001411A4F00, 0, }, // glSecondaryColor3bEXT + { 0x00000001411A40A0, 0, }, // glSecondaryColor3bv + { 0x00000001411A4F08, 0, }, // glSecondaryColor3bvEXT + { 0x00000001411A40A8, 0, }, // glSecondaryColor3d + { 0x00000001411A4F10, 0, }, // glSecondaryColor3dEXT + { 0x00000001411A40B0, 0, }, // glSecondaryColor3dv + { 0x00000001411A4F18, 0, }, // glSecondaryColor3dvEXT + { 0x00000001411A40B8, 0, }, // glSecondaryColor3f + { 0x00000001411A4F20, 0, }, // glSecondaryColor3fEXT + { 0x00000001411A40C0, 0, }, // glSecondaryColor3fv + { 0x00000001411A4F28, 0, }, // glSecondaryColor3fvEXT + { 0x00000001411A5400, 0, }, // glSecondaryColor3hNV + { 0x00000001411A5408, 0, }, // glSecondaryColor3hvNV + { 0x00000001411A40C8, 0, }, // glSecondaryColor3i + { 0x00000001411A4F30, 0, }, // glSecondaryColor3iEXT + { 0x00000001411A40D0, 0, }, // glSecondaryColor3iv + { 0x00000001411A4F38, 0, }, // glSecondaryColor3ivEXT + { 0x00000001411A40D8, 0, }, // glSecondaryColor3s + { 0x00000001411A4F40, 0, }, // glSecondaryColor3sEXT + { 0x00000001411A40E0, 0, }, // glSecondaryColor3sv + { 0x00000001411A4F48, 0, }, // glSecondaryColor3svEXT + { 0x00000001411A40E8, 0, }, // glSecondaryColor3ub + { 0x00000001411A4F50, 0, }, // glSecondaryColor3ubEXT + { 0x00000001411A40F0, 0, }, // glSecondaryColor3ubv + { 0x00000001411A4F58, 0, }, // glSecondaryColor3ubvEXT + { 0x00000001411A40F8, 0, }, // glSecondaryColor3ui + { 0x00000001411A4F60, 0, }, // glSecondaryColor3uiEXT + { 0x00000001411A4100, 0, }, // glSecondaryColor3uiv + { 0x00000001411A4F68, 0, }, // glSecondaryColor3uivEXT + { 0x00000001411A4108, 0, }, // glSecondaryColor3us + { 0x00000001411A4F70, 0, }, // glSecondaryColor3usEXT + { 0x00000001411A4110, 0, }, // glSecondaryColor3usv + { 0x00000001411A4F78, 0, }, // glSecondaryColor3usvEXT + { 0x00000001411A4118, 0, }, // glSecondaryColorPointer + { 0x00000001411A4F80, 0, }, // glSecondaryColorPointerEXT + { 0x00000001411A3CD8, 0, }, // glSeparableFilter2D + { 0x00000001411A5070, 0, }, // glSetFenceNV + { 0x00000001411A4348, 0, }, // glShaderSource + { 0x00000001411A4BC8, 0, }, // glShaderSourceARB + { 0x00000001411A4250, 0, }, // glStencilFuncSeparate + { 0x00000001411A4258, 0, }, // glStencilMaskSeparate + { 0x00000001411A4248, 0, }, // glStencilOpSeparate + { 0x00000001411A5058, 0, }, // glTestFenceNV + { 0x00000001411A4DE8, 0, }, // glTexBufferARB + { 0x00000001411A34E0, 0, }, // glTexBufferEXT + { 0x00000001411A5370, 0, }, // glTexCoord1hNV + { 0x00000001411A5378, 0, }, // glTexCoord1hvNV + { 0x00000001411A5380, 0, }, // glTexCoord2hNV + { 0x00000001411A5388, 0, }, // glTexCoord2hvNV + { 0x00000001411A5390, 0, }, // glTexCoord3hNV + { 0x00000001411A5398, 0, }, // glTexCoord3hvNV + { 0x00000001411A53A0, 0, }, // glTexCoord4hNV + { 0x00000001411A53A8, 0, }, // glTexCoord4hvNV + { 0x00000001411A4E98, 0, }, // glTexCoordPointerEXT + { 0x00000001411A3D88, 0, }, // glTexImage3D + { 0x00000001411A4E18, 0, }, // glTexImage3DEXT + { 0x00000001411A46D0, 0, }, // glTexParameterIiv + { 0x00000001411A35C0, 0, }, // glTexParameterIivEXT + { 0x00000001411A46D8, 0, }, // glTexParameterIuiv + { 0x00000001411A35C8, 0, }, // glTexParameterIuivEXT + { 0x00000001411A3CD0, 0, }, // glTexRenderbufferNV + { 0x00000001411A3F60, 0, }, // glTexStorage2D + { 0x00000001411A3D98, 0, }, // glTexSubImage3D + { 0x00000001411A4E20, 0, }, // glTexSubImage3DEXT + { 0x00000001411A3CE0, 0, }, // glTextureBarrierNV + { 0x00000001411A3B48, 0, }, // glTextureBufferEXT + { 0x00000001411A36F8, 0, }, // glTextureImage1DEXT + { 0x00000001411A3700, 0, }, // glTextureImage2DEXT + { 0x00000001411A3760, 0, }, // glTextureImage3DEXT + { 0x00000001411A36D8, 0, }, // glTextureParameterfEXT + { 0x00000001411A36E0, 0, }, // glTextureParameterfvEXT + { 0x00000001411A36E8, 0, }, // glTextureParameteriEXT + { 0x00000001411A39C8, 0, }, // glTextureParameterIivEXT + { 0x00000001411A39D0, 0, }, // glTextureParameterIuivEXT + { 0x00000001411A36F0, 0, }, // glTextureParameterivEXT + { 0x00000001411A3C90, 0, }, // glTextureRenderbufferEXT + { 0x00000001411A3F70, 0, }, // glTextureStorage2DEXT + { 0x00000001411A3708, 0, }, // glTextureSubImage1DEXT + { 0x00000001411A3710, 0, }, // glTextureSubImage2DEXT + { 0x00000001411A3768, 0, }, // glTextureSubImage3DEXT + { 0x00000001411A5140, 0, }, // glTrackMatrixNV + { 0x00000001411A3560, 0, }, // glTransformFeedbackAttribsNV + { 0x00000001411A45A0, 0, }, // glTransformFeedbackVaryings + { 0x00000001411A3580, 0, }, // glTransformFeedbackVaryingsNV + { 0x00000001411A4358, 0, }, // glUniform1f + { 0x00000001411A4C00, 0, }, // glUniform1fARB + { 0x00000001411A4398, 0, }, // glUniform1fv + { 0x00000001411A4C40, 0, }, // glUniform1fvARB + { 0x00000001411A4378, 0, }, // glUniform1i + { 0x00000001411A4C20, 0, }, // glUniform1iARB + { 0x00000001411A43B8, 0, }, // glUniform1iv + { 0x00000001411A4C60, 0, }, // glUniform1ivARB + { 0x00000001411A4690, 0, }, // glUniform1ui + { 0x00000001411A56D0, 0, }, // glUniform1uiEXT + { 0x00000001411A46B0, 0, }, // glUniform1uiv + { 0x00000001411A56F0, 0, }, // glUniform1uivEXT + { 0x00000001411A4360, 0, }, // glUniform2f + { 0x00000001411A4C08, 0, }, // glUniform2fARB + { 0x00000001411A43A0, 0, }, // glUniform2fv + { 0x00000001411A4C48, 0, }, // glUniform2fvARB + { 0x00000001411A4380, 0, }, // glUniform2i + { 0x00000001411A4C28, 0, }, // glUniform2iARB + { 0x00000001411A43C0, 0, }, // glUniform2iv + { 0x00000001411A4C68, 0, }, // glUniform2ivARB + { 0x00000001411A4698, 0, }, // glUniform2ui + { 0x00000001411A56D8, 0, }, // glUniform2uiEXT + { 0x00000001411A46B8, 0, }, // glUniform2uiv + { 0x00000001411A56F8, 0, }, // glUniform2uivEXT + { 0x00000001411A4368, 0, }, // glUniform3f + { 0x00000001411A4C10, 0, }, // glUniform3fARB + { 0x00000001411A43A8, 0, }, // glUniform3fv + { 0x00000001411A4C50, 0, }, // glUniform3fvARB + { 0x00000001411A4388, 0, }, // glUniform3i + { 0x00000001411A4C30, 0, }, // glUniform3iARB + { 0x00000001411A43C8, 0, }, // glUniform3iv + { 0x00000001411A4C70, 0, }, // glUniform3ivARB + { 0x00000001411A46A0, 0, }, // glUniform3ui + { 0x00000001411A56E0, 0, }, // glUniform3uiEXT + { 0x00000001411A46C0, 0, }, // glUniform3uiv + { 0x00000001411A5700, 0, }, // glUniform3uivEXT + { 0x00000001411A4370, 0, }, // glUniform4f + { 0x00000001411A4C18, 0, }, // glUniform4fARB + { 0x00000001411A43B0, 0, }, // glUniform4fv + { 0x00000001411A4C58, 0, }, // glUniform4fvARB + { 0x00000001411A4390, 0, }, // glUniform4i + { 0x00000001411A4C38, 0, }, // glUniform4iARB + { 0x00000001411A43D0, 0, }, // glUniform4iv + { 0x00000001411A4C78, 0, }, // glUniform4ivARB + { 0x00000001411A46A8, 0, }, // glUniform4ui + { 0x00000001411A56E8, 0, }, // glUniform4uiEXT + { 0x00000001411A46C8, 0, }, // glUniform4uiv + { 0x00000001411A5708, 0, }, // glUniform4uivEXT + { 0x00000001411A35A8, 0, }, // glUniformBufferEXT + { 0x00000001411A43D8, 0, }, // glUniformMatrix2fv + { 0x00000001411A4C80, 0, }, // glUniformMatrix2fvARB + { 0x00000001411A4520, 0, }, // glUniformMatrix2x3fv + { 0x00000001411A4530, 0, }, // glUniformMatrix2x4fv + { 0x00000001411A43E0, 0, }, // glUniformMatrix3fv + { 0x00000001411A4C88, 0, }, // glUniformMatrix3fvARB + { 0x00000001411A4528, 0, }, // glUniformMatrix3x2fv + { 0x00000001411A4540, 0, }, // glUniformMatrix3x4fv + { 0x00000001411A43E8, 0, }, // glUniformMatrix4fv + { 0x00000001411A4C90, 0, }, // glUniformMatrix4fvARB + { 0x00000001411A4538, 0, }, // glUniformMatrix4x2fv + { 0x00000001411A4548, 0, }, // glUniformMatrix4x3fv + { 0x00000001411A4EF0, 0, }, // glUnlockArraysEXT + { 0x00000001411A4220, 0, }, // glUnmapBuffer + { 0x00000001411A4B50, 0, }, // glUnmapBufferARB + { 0x00000001411A4BF0, 0, }, // glUseProgramObjectARB + { 0x00000001411A43F0, 0, }, // glValidateProgram + { 0x00000001411A4BF8, 0, }, // glValidateProgramARB + { 0x00000001411A5310, 0, }, // glVertex2hNV + { 0x00000001411A5318, 0, }, // glVertex2hvNV + { 0x00000001411A5320, 0, }, // glVertex3hNV + { 0x00000001411A5328, 0, }, // glVertex3hvNV + { 0x00000001411A5330, 0, }, // glVertex4hNV + { 0x00000001411A5338, 0, }, // glVertex4hvNV + { 0x00000001411A4FD0, 0, }, // glVertexArrayRangeNV + { 0x00000001411A43F8, 0, }, // glVertexAttrib1d + { 0x00000001411A4920, 0, }, // glVertexAttrib1dARB + { 0x00000001411A5150, 0, }, // glVertexAttrib1dNV + { 0x00000001411A4400, 0, }, // glVertexAttrib1dv + { 0x00000001411A4928, 0, }, // glVertexAttrib1dvARB + { 0x00000001411A5158, 0, }, // glVertexAttrib1dvNV + { 0x00000001411A4408, 0, }, // glVertexAttrib1f + { 0x00000001411A4930, 0, }, // glVertexAttrib1fARB + { 0x00000001411A5160, 0, }, // glVertexAttrib1fNV + { 0x00000001411A4410, 0, }, // glVertexAttrib1fv + { 0x00000001411A4938, 0, }, // glVertexAttrib1fvARB + { 0x00000001411A5168, 0, }, // glVertexAttrib1fvNV + { 0x00000001411A5410, 0, }, // glVertexAttrib1hNV + { 0x00000001411A5418, 0, }, // glVertexAttrib1hvNV + { 0x00000001411A4418, 0, }, // glVertexAttrib1s + { 0x00000001411A4940, 0, }, // glVertexAttrib1sARB + { 0x00000001411A5170, 0, }, // glVertexAttrib1sNV + { 0x00000001411A4420, 0, }, // glVertexAttrib1sv + { 0x00000001411A4948, 0, }, // glVertexAttrib1svARB + { 0x00000001411A5178, 0, }, // glVertexAttrib1svNV + { 0x00000001411A4428, 0, }, // glVertexAttrib2d + { 0x00000001411A4950, 0, }, // glVertexAttrib2dARB + { 0x00000001411A5180, 0, }, // glVertexAttrib2dNV + { 0x00000001411A4430, 0, }, // glVertexAttrib2dv + { 0x00000001411A4958, 0, }, // glVertexAttrib2dvARB + { 0x00000001411A5188, 0, }, // glVertexAttrib2dvNV + { 0x00000001411A4438, 0, }, // glVertexAttrib2f + { 0x00000001411A4960, 0, }, // glVertexAttrib2fARB + { 0x00000001411A5190, 0, }, // glVertexAttrib2fNV + { 0x00000001411A4440, 0, }, // glVertexAttrib2fv + { 0x00000001411A4968, 0, }, // glVertexAttrib2fvARB + { 0x00000001411A5198, 0, }, // glVertexAttrib2fvNV + { 0x00000001411A5420, 0, }, // glVertexAttrib2hNV + { 0x00000001411A5428, 0, }, // glVertexAttrib2hvNV + { 0x00000001411A4448, 0, }, // glVertexAttrib2s + { 0x00000001411A4970, 0, }, // glVertexAttrib2sARB + { 0x00000001411A51A0, 0, }, // glVertexAttrib2sNV + { 0x00000001411A4450, 0, }, // glVertexAttrib2sv + { 0x00000001411A4978, 0, }, // glVertexAttrib2svARB + { 0x00000001411A51A8, 0, }, // glVertexAttrib2svNV + { 0x00000001411A4458, 0, }, // glVertexAttrib3d + { 0x00000001411A4980, 0, }, // glVertexAttrib3dARB + { 0x00000001411A51B0, 0, }, // glVertexAttrib3dNV + { 0x00000001411A4460, 0, }, // glVertexAttrib3dv + { 0x00000001411A4988, 0, }, // glVertexAttrib3dvARB + { 0x00000001411A51B8, 0, }, // glVertexAttrib3dvNV + { 0x00000001411A4468, 0, }, // glVertexAttrib3f + { 0x00000001411A4990, 0, }, // glVertexAttrib3fARB + { 0x00000001411A51C0, 0, }, // glVertexAttrib3fNV + { 0x00000001411A4470, 0, }, // glVertexAttrib3fv + { 0x00000001411A4998, 0, }, // glVertexAttrib3fvARB + { 0x00000001411A51C8, 0, }, // glVertexAttrib3fvNV + { 0x00000001411A5430, 0, }, // glVertexAttrib3hNV + { 0x00000001411A5438, 0, }, // glVertexAttrib3hvNV + { 0x00000001411A4478, 0, }, // glVertexAttrib3s + { 0x00000001411A49A0, 0, }, // glVertexAttrib3sARB + { 0x00000001411A51D0, 0, }, // glVertexAttrib3sNV + { 0x00000001411A4480, 0, }, // glVertexAttrib3sv + { 0x00000001411A49A8, 0, }, // glVertexAttrib3svARB + { 0x00000001411A51D8, 0, }, // glVertexAttrib3svNV + { 0x00000001411A44C0, 0, }, // glVertexAttrib4bv + { 0x00000001411A49E8, 0, }, // glVertexAttrib4bvARB + { 0x00000001411A44C8, 0, }, // glVertexAttrib4d + { 0x00000001411A49F0, 0, }, // glVertexAttrib4dARB + { 0x00000001411A51E0, 0, }, // glVertexAttrib4dNV + { 0x00000001411A44D0, 0, }, // glVertexAttrib4dv + { 0x00000001411A49F8, 0, }, // glVertexAttrib4dvARB + { 0x00000001411A51E8, 0, }, // glVertexAttrib4dvNV + { 0x00000001411A44D8, 0, }, // glVertexAttrib4f + { 0x00000001411A4A00, 0, }, // glVertexAttrib4fARB + { 0x00000001411A51F0, 0, }, // glVertexAttrib4fNV + { 0x00000001411A44E0, 0, }, // glVertexAttrib4fv + { 0x00000001411A4A08, 0, }, // glVertexAttrib4fvARB + { 0x00000001411A51F8, 0, }, // glVertexAttrib4fvNV + { 0x00000001411A5440, 0, }, // glVertexAttrib4hNV + { 0x00000001411A5448, 0, }, // glVertexAttrib4hvNV + { 0x00000001411A44E8, 0, }, // glVertexAttrib4iv + { 0x00000001411A4A10, 0, }, // glVertexAttrib4ivARB + { 0x00000001411A4488, 0, }, // glVertexAttrib4Nbv + { 0x00000001411A49B0, 0, }, // glVertexAttrib4NbvARB + { 0x00000001411A4490, 0, }, // glVertexAttrib4Niv + { 0x00000001411A49B8, 0, }, // glVertexAttrib4NivARB + { 0x00000001411A4498, 0, }, // glVertexAttrib4Nsv + { 0x00000001411A49C0, 0, }, // glVertexAttrib4NsvARB + { 0x00000001411A44A0, 0, }, // glVertexAttrib4Nub + { 0x00000001411A49C8, 0, }, // glVertexAttrib4NubARB + { 0x00000001411A44A8, 0, }, // glVertexAttrib4Nubv + { 0x00000001411A49D0, 0, }, // glVertexAttrib4NubvARB + { 0x00000001411A44B0, 0, }, // glVertexAttrib4Nuiv + { 0x00000001411A49D8, 0, }, // glVertexAttrib4NuivARB + { 0x00000001411A44B8, 0, }, // glVertexAttrib4Nusv + { 0x00000001411A49E0, 0, }, // glVertexAttrib4NusvARB + { 0x00000001411A44F0, 0, }, // glVertexAttrib4s + { 0x00000001411A4A18, 0, }, // glVertexAttrib4sARB + { 0x00000001411A5200, 0, }, // glVertexAttrib4sNV + { 0x00000001411A44F8, 0, }, // glVertexAttrib4sv + { 0x00000001411A4A20, 0, }, // glVertexAttrib4svARB + { 0x00000001411A5208, 0, }, // glVertexAttrib4svNV + { 0x00000001411A5210, 0, }, // glVertexAttrib4ubNV + { 0x00000001411A4500, 0, }, // glVertexAttrib4ubv + { 0x00000001411A4A28, 0, }, // glVertexAttrib4ubvARB + { 0x00000001411A5218, 0, }, // glVertexAttrib4ubvNV + { 0x00000001411A4508, 0, }, // glVertexAttrib4uiv + { 0x00000001411A4A30, 0, }, // glVertexAttrib4uivARB + { 0x00000001411A4510, 0, }, // glVertexAttrib4usv + { 0x00000001411A4A38, 0, }, // glVertexAttrib4usvARB + { 0x00000001411A45C0, 0, }, // glVertexAttribI1i + { 0x00000001411A5600, 0, }, // glVertexAttribI1iEXT + { 0x00000001411A4600, 0, }, // glVertexAttribI1iv + { 0x00000001411A5640, 0, }, // glVertexAttribI1ivEXT + { 0x00000001411A45E0, 0, }, // glVertexAttribI1ui + { 0x00000001411A5620, 0, }, // glVertexAttribI1uiEXT + { 0x00000001411A4620, 0, }, // glVertexAttribI1uiv + { 0x00000001411A5660, 0, }, // glVertexAttribI1uivEXT + { 0x00000001411A45C8, 0, }, // glVertexAttribI2i + { 0x00000001411A5608, 0, }, // glVertexAttribI2iEXT + { 0x00000001411A4608, 0, }, // glVertexAttribI2iv + { 0x00000001411A5648, 0, }, // glVertexAttribI2ivEXT + { 0x00000001411A45E8, 0, }, // glVertexAttribI2ui + { 0x00000001411A5628, 0, }, // glVertexAttribI2uiEXT + { 0x00000001411A4628, 0, }, // glVertexAttribI2uiv + { 0x00000001411A5668, 0, }, // glVertexAttribI2uivEXT + { 0x00000001411A45D0, 0, }, // glVertexAttribI3i + { 0x00000001411A5610, 0, }, // glVertexAttribI3iEXT + { 0x00000001411A4610, 0, }, // glVertexAttribI3iv + { 0x00000001411A5650, 0, }, // glVertexAttribI3ivEXT + { 0x00000001411A45F0, 0, }, // glVertexAttribI3ui + { 0x00000001411A5630, 0, }, // glVertexAttribI3uiEXT + { 0x00000001411A4630, 0, }, // glVertexAttribI3uiv + { 0x00000001411A5670, 0, }, // glVertexAttribI3uivEXT + { 0x00000001411A4640, 0, }, // glVertexAttribI4bv + { 0x00000001411A5680, 0, }, // glVertexAttribI4bvEXT + { 0x00000001411A45D8, 0, }, // glVertexAttribI4i + { 0x00000001411A5618, 0, }, // glVertexAttribI4iEXT + { 0x00000001411A4618, 0, }, // glVertexAttribI4iv + { 0x00000001411A5658, 0, }, // glVertexAttribI4ivEXT + { 0x00000001411A4648, 0, }, // glVertexAttribI4sv + { 0x00000001411A5688, 0, }, // glVertexAttribI4svEXT + { 0x00000001411A4650, 0, }, // glVertexAttribI4ubv + { 0x00000001411A5690, 0, }, // glVertexAttribI4ubvEXT + { 0x00000001411A45F8, 0, }, // glVertexAttribI4ui + { 0x00000001411A5638, 0, }, // glVertexAttribI4uiEXT + { 0x00000001411A4638, 0, }, // glVertexAttribI4uiv + { 0x00000001411A5678, 0, }, // glVertexAttribI4uivEXT + { 0x00000001411A4658, 0, }, // glVertexAttribI4usv + { 0x00000001411A5698, 0, }, // glVertexAttribI4usvEXT + { 0x00000001411A4660, 0, }, // glVertexAttribIPointer + { 0x00000001411A56A0, 0, }, // glVertexAttribIPointerEXT + { 0x00000001411A4518, 0, }, // glVertexAttribPointer + { 0x00000001411A5148, 0, }, // glVertexAttribPointerNV + { 0x00000001411A5220, 0, }, // glVertexAttribs1dvNV + { 0x00000001411A5228, 0, }, // glVertexAttribs1fvNV + { 0x00000001411A5450, 0, }, // glVertexAttribs1hvNV + { 0x00000001411A5230, 0, }, // glVertexAttribs1svNV + { 0x00000001411A5238, 0, }, // glVertexAttribs2dvNV + { 0x00000001411A5240, 0, }, // glVertexAttribs2fvNV + { 0x00000001411A5458, 0, }, // glVertexAttribs2hvNV + { 0x00000001411A5248, 0, }, // glVertexAttribs2svNV + { 0x00000001411A5250, 0, }, // glVertexAttribs3dvNV + { 0x00000001411A5258, 0, }, // glVertexAttribs3fvNV + { 0x00000001411A5460, 0, }, // glVertexAttribs3hvNV + { 0x00000001411A5260, 0, }, // glVertexAttribs3svNV + { 0x00000001411A5268, 0, }, // glVertexAttribs4dvNV + { 0x00000001411A5270, 0, }, // glVertexAttribs4fvNV + { 0x00000001411A5468, 0, }, // glVertexAttribs4hvNV + { 0x00000001411A5278, 0, }, // glVertexAttribs4svNV + { 0x00000001411A5280, 0, }, // glVertexAttribs4ubvNV + { 0x00000001411A4EA0, 0, }, // glVertexPointerEXT + { 0x00000001411A4120, 0, }, // glWindowPos2d + { 0x00000001411A48A0, 0, }, // glWindowPos2dARB + { 0x00000001411A4128, 0, }, // glWindowPos2dv + { 0x00000001411A48A8, 0, }, // glWindowPos2dvARB + { 0x00000001411A4130, 0, }, // glWindowPos2f + { 0x00000001411A48B0, 0, }, // glWindowPos2fARB + { 0x00000001411A4138, 0, }, // glWindowPos2fv + { 0x00000001411A48B8, 0, }, // glWindowPos2fvARB + { 0x00000001411A4140, 0, }, // glWindowPos2i + { 0x00000001411A48C0, 0, }, // glWindowPos2iARB + { 0x00000001411A4148, 0, }, // glWindowPos2iv + { 0x00000001411A48C8, 0, }, // glWindowPos2ivARB + { 0x00000001411A4150, 0, }, // glWindowPos2s + { 0x00000001411A48D0, 0, }, // glWindowPos2sARB + { 0x00000001411A4158, 0, }, // glWindowPos2sv + { 0x00000001411A48D8, 0, }, // glWindowPos2svARB + { 0x00000001411A4160, 0, }, // glWindowPos3d + { 0x00000001411A48E0, 0, }, // glWindowPos3dARB + { 0x00000001411A4168, 0, }, // glWindowPos3dv + { 0x00000001411A48E8, 0, }, // glWindowPos3dvARB + { 0x00000001411A4170, 0, }, // glWindowPos3f + { 0x00000001411A48F0, 0, }, // glWindowPos3fARB + { 0x00000001411A4178, 0, }, // glWindowPos3fv + { 0x00000001411A48F8, 0, }, // glWindowPos3fvARB + { 0x00000001411A4180, 0, }, // glWindowPos3i + { 0x00000001411A4900, 0, }, // glWindowPos3iARB + { 0x00000001411A4188, 0, }, // glWindowPos3iv + { 0x00000001411A4908, 0, }, // glWindowPos3ivARB + { 0x00000001411A4190, 0, }, // glWindowPos3s + { 0x00000001411A4910, 0, }, // glWindowPos3sARB + { 0x00000001411A4198, 0, }, // glWindowPos3sv + { 0x00000001411A4918, 0, }, // glWindowPos3svARB + { 0x00000001411A3E50, 0, }, // wglAllocateMemoryNV + { 0x00000001411A3EE0, 0, }, // wglBindSwapBarrierNV + { 0x00000001411A3DE0, 0, }, // wglBindTexImageARB + { 0x00000001411A3E90, 0, }, // wglBindVideoImageNV + { 0x00000001411A3D60, 0, }, // wglChoosePixelFormatARB + { 0x00000001411A3CF0, 0, }, // wglCreateBufferRegionARB + { 0x00000001411A3E10, 0, }, // wglCreateContextAttribsARB + { 0x00000001411A3D90, 0, }, // wglCreatePbufferARB + { 0x00000001411A3D00, 0, }, // wglDeleteBufferRegionARB + { 0x00000001411A3DC0, 0, }, // wglDestroyPbufferARB + { 0x00000001411A1A48, 0, }, // wglDXCloseDeviceNV + { 0x00000001411A1A68, 0, }, // wglDXLockObjectsNV + { 0x00000001411A1A40, 0, }, // wglDXOpenDeviceNV + { 0x00000001411A1A58, 0, }, // wglDXRegisterObjectNV + { 0x00000001411A1A50, 0, }, // wglDXSetResourceShareHandleNV + { 0x00000001411A1A70, 0, }, // wglDXUnlockObjectsNV + { 0x00000001411A1A60, 0, }, // wglDXUnregisterObjectNV + { 0x00000001411A3E60, 0, }, // wglFreeMemoryNV + { 0x00000001411A1A28, 0, }, // wglGetCurrentContext + { 0x00000001411A3D80, 0, }, // wglGetCurrentReadDCARB + { 0x00000001411A3D30, 0, }, // wglGetExtensionsStringARB + { 0x00000001411A3E20, 0, }, // wglGetExtensionsStringEXT + { 0x00000001411A3DA0, 0, }, // wglGetPbufferDCARB + { 0x00000001411A3D50, 0, }, // wglGetPixelFormatAttribfvARB + { 0x00000001411A3D40, 0, }, // wglGetPixelFormatAttribivARB + { 0x00000001411A1A20, 0, }, // wglGetProcAddress + { 0x00000001411A3E40, 0, }, // wglGetSwapIntervalEXT + { 0x00000001411A3E70, 0, }, // wglGetVideoDeviceNV + { 0x00000001411A3EC0, 0, }, // wglGetVideoInfoNV + { 0x00000001411A3ED0, 0, }, // wglJoinSwapGroupNV + { 0x00000001411A3D70, 0, }, // wglMakeContextCurrentARB + { 0x00000001411A3F10, 0, }, // wglQueryFrameCountNV + { 0x00000001411A3F00, 0, }, // wglQueryMaxSwapGroupsNV + { 0x00000001411A3DD0, 0, }, // wglQueryPbufferARB + { 0x00000001411A3EF0, 0, }, // wglQuerySwapGroupNV + { 0x00000001411A3DB0, 0, }, // wglReleasePbufferDCARB + { 0x00000001411A3DF0, 0, }, // wglReleaseTexImageARB + { 0x00000001411A3E80, 0, }, // wglReleaseVideoDeviceNV + { 0x00000001411A3EA0, 0, }, // wglReleaseVideoImageNV + { 0x00000001411A3F20, 0, }, // wglResetFrameCountNV + { 0x00000001411A3D20, 0, }, // wglRestoreBufferRegionARB + { 0x00000001411A3D10, 0, }, // wglSaveBufferRegionARB + { 0x00000001411A3EB0, 0, }, // wglSendPbufferToVideoNV + { 0x00000001411A3E00, 0, }, // wglSetPbufferAttribARB + { 0x00000001411A3E30, 0, }, // wglSwapIntervalEXT +}; + +gl_func_struct gl_addr_glut[7] = { + { 0x000000000002A358, 0, }, // glFinish + { 0x000000000002A438, 0, }, // glViewport + { 0x000000000002A368, 0, }, // wglDeleteContext + { 0x000000000002A420, 0, }, // wglGetCurrentContext + { 0x000000000002A428, 0, }, // wglGetCurrentDC + { 0x000000000002A448, 0, }, // wglGetProcAddress + { 0x000000000002A430, 0, }, // wglMakeCurrent +}; + +bool GL_VERSION_3_3 = false; +bool GL_VERSION_4_0 = false; +bool GL_VERSION_4_1 = false; +bool GL_VERSION_4_2 = false; +bool GL_VERSION_4_3 = false; +bool GL_VERSION_4_4 = false; +bool GL_VERSION_4_5 = false; +bool GL_VERSION_4_6 = false; + +GLuint current_program; + +extern size_t opengl32_handle; + +#ifdef DEBUG +static void print_debug_error_old(const char* c, const char* e) { + if (e) + printf("DivaGL Deprecated: Debug: %s Error: %s; Time %li\n", c, e, clock()); + else + printf("DivaGL Deprecated: Debug: %s; Time %li\n", c, clock()); +} +#endif + +#ifdef DEBUG +static void print_debug_error(const char* c, const char* e) { + if (e) + printf("DivaGL: Debug: %s Error: %s; Time %li\n", c, e, clock()); +#ifdef PRINT_DEBUG + else + printf("DivaGL: Debug: %s; Time %li\n", c, clock()); +#endif +} +#endif + +void FASTCALL wrap_addresses() { +#ifdef DEBUG + print_debug_error("Patching tables", 0); +#endif + + for (int i = 0; i < 78; i++) + if (wrap_addr_dll[i].func != *(size_t*)wrap_addr_dll[i].address) { + wrap_addr_dll[i].orig_func = *(size_t*)wrap_addr_dll[i].address; + inject_uint64_t((void*)wrap_addr_dll[i].address, wrap_addr_dll[i].func); + } + + for (int i = 0; i < 9; i++) + gl_addr_dll[i].func = *(size_t*)gl_addr_dll[i].address; + +#ifdef DEBUG + print_debug_error("DLL include table patched", 0); +#endif + + for (int i = 0; i < 27; i++) + if (wrap_addr_glut[i].func != *(size_t*)(glut_handle + wrap_addr_glut[i].address)) { + wrap_addr_glut[i].orig_func = *(size_t*)(glut_handle + wrap_addr_glut[i].address); + inject_uint64_t((void*)(glut_handle + wrap_addr_glut[i].address), wrap_addr_glut[i].func); + } + + for (int i = 0; i < 7; i++) + gl_addr_glut[i].func = *(size_t*)(glut_handle + gl_addr_glut[i].address); + +#ifdef DEBUG + print_debug_error("GLUT DLL include table patched", 0); +#endif + + for (int i = 0; i < 50; i++) + if (wrap_addr[i].func != *(size_t*)wrap_addr[i].address) { + wrap_addr[i].orig_func = *(size_t*)wrap_addr[i].address; + inject_uint64_t((void*)wrap_addr[i].address, wrap_addr[i].func); + } + + for (int i = 0; i < 1057; i++) + gl_addr[i].func = *(size_t*)gl_addr[i].address; + +#ifdef DEBUG + print_debug_error("wglGetProcAddresses table patched", 0); +#endif + + const char* version = (const char*)glGetStringGLUT(GL_VERSION); + if (version) { + int32_t major; + int32_t minor; + sscanf_s(version, "%d.%d", &major, &minor); + + GL_VERSION_3_3 = (major == 3 && minor >= 3) || major > 3; + GL_VERSION_4_0 = (major == 4 && minor >= 0) || major > 4; + GL_VERSION_4_1 = (major == 4 && minor >= 1) || major > 4; + GL_VERSION_4_2 = (major == 4 && minor >= 2) || major > 4; + GL_VERSION_4_3 = (major == 4 && minor >= 3) || major > 4; + GL_VERSION_4_4 = (major == 4 && minor >= 4) || major > 4; + GL_VERSION_4_5 = (major == 4 && minor >= 5) || major > 4; + GL_VERSION_4_6 = (major == 4 && minor >= 6) || major > 4; + } +} + +HOOK(void, FASTCALL, wglGetProcAddresses, 0x0000000140461B50) { + originalwglGetProcAddresses(); + wrap_addresses(); +} + +HOOK(GLenum, FASTCALL, gl_check_framebuffer_status, 0x0000000140503240) { + return glCheckFramebufferStatus(GL_FRAMEBUFFER); +} + +void wrap_patch() { + // glShadeModel(GL_SMOOTH); + WRITE_NOP_11(0x00000001401948CA); + + // glClampColorARB(GL_CLAMP_VERTEX_COLOR_ARB, GL_ZERO); + // glClampColorARB(GL_CLAMP_FRAGMENT_COLOR_ARB, GL_FIXED_ONLY_ARB); + // glClampColorARB(GL_CLAMP_READ_COLOR_ARB, GL_FIXED_ONLY_ARB); + WRITE_JUMP(0x0000000140194932, 0x000000014019495B); + + // glCheckFramebufferStatusEXT -> glCheckFramebufferStatus + //WRITE_NULL(0x0000000140A0C3E0, 0x03); + + INSTALL_HOOK(wglGetProcAddresses); + //INSTALL_HOOK(gl_check_framebuffer_status); +} + +void GLAPIENTRY glAlphaFuncDLL(GLenum func, GLfloat ref) { + if (func == GL_GREATER && ref >= 0.5f) + uniform->arr[U_ALPHA_TEST] = 1; + else + uniform->arr[U_ALPHA_TEST] = 0; + ((PFNGLALPHAFUNCDLLPROC)wrap_addr_dll[GLALPHAFUNCDLL].orig_func)(func, ref); +} + +void GLAPIENTRY glBeginDLL(GLenum mode) { + ((PFNGLBEGINDLLPROC)wrap_addr_dll[GLBEGINDLL].orig_func)(mode); +} + +void GLAPIENTRY glBindTextureDLL(GLenum target, GLuint texture) { + ((PFNGLBINDTEXTUREDLLPROC)wrap_addr_dll[GLBINDTEXTUREDLL].orig_func)(target, texture); +} + +void GLAPIENTRY glClearDLL(GLbitfield mask) { + ((PFNGLCLEARDLLPROC)wrap_addr_dll[GLCLEARDLL].orig_func)(mask); +} + +void GLAPIENTRY glClearColorDLL(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) { + ((PFNGLCLEARCOLORDLLPROC)wrap_addr_dll[GLCLEARCOLORDLL].orig_func)(red, green, blue, alpha); +} + +void GLAPIENTRY glClearDepthDLL(GLdouble depth) { + ((PFNGLCLEARDEPTHDLLPROC)wrap_addr_dll[GLCLEARDEPTHDLL].orig_func)(depth); +} + +void GLAPIENTRY glClearStencilDLL(GLint s) { + ((PFNGLCLEARSTENCILDLLPROC)wrap_addr_dll[GLCLEARSTENCILDLL].orig_func)(s); +} + +void GLAPIENTRY glColor3fDLL(GLfloat red, GLfloat green, GLfloat blue) { + ((PFNGLCOLOR3FDLLPROC)wrap_addr_dll[GLCOLOR3FDLL].orig_func)(red, green, blue); +} + +void GLAPIENTRY glColor4fDLL(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) { + ((PFNGLCOLOR4FDLLPROC)wrap_addr_dll[GLCOLOR4FDLL].orig_func)(red, green, blue, alpha); +} + +void GLAPIENTRY glColor4ubDLL(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha) { + ((PFNGLCOLOR4UBDLLPROC)wrap_addr_dll[GLCOLOR4UBDLL].orig_func)(red, green, blue, alpha); +} + +void GLAPIENTRY glColor4ubvDLL(GLubyte const * v) { + ((PFNGLCOLOR4UBVDLLPROC)wrap_addr_dll[GLCOLOR4UBVDLL].orig_func)(v); +} + +void GLAPIENTRY glColorPointerDLL(GLint size, GLenum type, GLsizei stride, const void * pointer) { + ((PFNGLCOLORPOINTERDLLPROC)wrap_addr_dll[GLCOLORPOINTERDLL].orig_func)(size, type, stride, pointer); +} + +void GLAPIENTRY glCopyTexImage2DDLL(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) { + ((PFNGLCOPYTEXIMAGE2DDLLPROC)wrap_addr_dll[GLCOPYTEXIMAGE2DDLL].orig_func)(target, level, internalformat, x, y, width, height, border); +} + +void GLAPIENTRY glCopyTexSubImage2DDLL(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) { + ((PFNGLCOPYTEXSUBIMAGE2DDLLPROC)wrap_addr_dll[GLCOPYTEXSUBIMAGE2DDLL].orig_func)(target, level, xoffset, yoffset, x, y, width, height); +} + +void GLAPIENTRY glCullFaceDLL(GLenum mode) { + ((PFNGLCULLFACEDLLPROC)wrap_addr_dll[GLCULLFACEDLL].orig_func)(mode); +} + +void GLAPIENTRY glDepthFuncDLL(GLenum func) { + ((PFNGLDEPTHFUNCDLLPROC)wrap_addr_dll[GLDEPTHFUNCDLL].orig_func)(func); +} + +void GLAPIENTRY glDisableDLL(GLenum cap) { + ((PFNGLDISABLEDLLPROC)wrap_addr_dll[GLDISABLEDLL].orig_func)(cap); +} + +void GLAPIENTRY glDisableClientStateDLL(GLenum array) { + ((PFNGLDISABLECLIENTSTATEDLLPROC)wrap_addr_dll[GLDISABLECLIENTSTATEDLL].orig_func)(array); +} + +void GLAPIENTRY glDrawArraysDLL(GLenum mode, GLint first, GLsizei count) { + ((PFNGLDRAWARRAYSDLLPROC)wrap_addr_dll[GLDRAWARRAYSDLL].orig_func)(mode, first, count); +} + +void GLAPIENTRY glDrawBufferDLL(GLenum buf) { + ((PFNGLDRAWBUFFERDLLPROC)wrap_addr_dll[GLDRAWBUFFERDLL].orig_func)(buf); +} + +void GLAPIENTRY glDrawElementsDLL(GLenum mode, GLsizei count, GLenum type, const void * indices) { + ((PFNGLDRAWELEMENTSDLLPROC)wrap_addr_dll[GLDRAWELEMENTSDLL].orig_func)(mode, count, type, indices); +} + +void GLAPIENTRY glEnableDLL(GLenum cap) { + ((PFNGLENABLEDLLPROC)wrap_addr_dll[GLENABLEDLL].orig_func)(cap); +} + +void GLAPIENTRY glEnableClientStateDLL(GLenum array) { + ((PFNGLENABLECLIENTSTATEDLLPROC)wrap_addr_dll[GLENABLECLIENTSTATEDLL].orig_func)(array); +} + +void GLAPIENTRY glEndDLL() { + ((PFNGLENDDLLPROC)wrap_addr_dll[GLENDDLL].orig_func)(); +} + +void GLAPIENTRY glFogfDLL(GLenum pname, GLfloat param) { + ((PFNGLFOGFDLLPROC)wrap_addr_dll[GLFOGFDLL].orig_func)(pname, param); +} + +void GLAPIENTRY glFogfvDLL(GLenum pname, GLfloat const * params) { + ((PFNGLFOGFVDLLPROC)wrap_addr_dll[GLFOGFVDLL].orig_func)(pname, params); +} + +void GLAPIENTRY glFogiDLL(GLenum pname, GLint param) { + ((PFNGLFOGIDLLPROC)wrap_addr_dll[GLFOGIDLL].orig_func)(pname, param); +} + +void GLAPIENTRY glFrontFaceDLL(GLenum mode) { + ((PFNGLFRONTFACEDLLPROC)wrap_addr_dll[GLFRONTFACEDLL].orig_func)(mode); +} + +void GLAPIENTRY glFrustumDLL(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar) { + mat4 mat; + mat4_frustrum(left, right, bottom, top, zNear, zFar, &mat); + mat4_transpose(&mat, &mat); + glMultTransposeMatrixf((const GLfloat*)&mat); + //((PFNGLFRUSTUMDLLPROC)wrap_addr_dll[GLFRUSTUMDLL].orig_func)(left, right, bottom, top, zNear, zFar); +} + +void GLAPIENTRY glGetBooleanvDLL(GLenum pname, GLboolean * data) { + switch (pname) { + case GL_VERTEX_PROGRAM_ARB: + case GL_FRAGMENT_PROGRAM_ARB: + if (data) + *data = GL_TRUE; + return; + } + ((PFNGLGETBOOLEANVDLLPROC)wrap_addr_dll[GLGETBOOLEANVDLL].orig_func)(pname, data); +} + +GLenum GLAPIENTRY glGetErrorDLL() { + return ((PFNGLGETERRORDLLPROC)wrap_addr_dll[GLGETERRORDLL].orig_func)(); +} + +void GLAPIENTRY glGetFloatvDLL(GLenum pname, GLfloat * data) { + ((PFNGLGETFLOATVDLLPROC)wrap_addr_dll[GLGETFLOATVDLL].orig_func)(pname, data); +} + +void GLAPIENTRY glGetIntegervDLL(GLenum pname, GLint * data) { + ((PFNGLGETINTEGERVDLLPROC)wrap_addr_dll[GLGETINTEGERVDLL].orig_func)(pname, data); +} + +void GLAPIENTRY glGetMaterialfvDLL(GLenum face, GLenum pname, GLfloat * params) { + ((PFNGLGETMATERIALFVDLLPROC)wrap_addr_dll[GLGETMATERIALFVDLL].orig_func)(face, pname, params); +} + +void GLAPIENTRY glGetTexImageDLL(GLenum target, GLint level, GLenum format, GLenum type, void * pixels) { + ((PFNGLGETTEXIMAGEDLLPROC)wrap_addr_dll[GLGETTEXIMAGEDLL].orig_func)(target, level, format, type, pixels); +} + +void GLAPIENTRY glGetTexLevelParameterivDLL(GLenum target, GLint level, GLenum pname, GLint * params) { + ((PFNGLGETTEXLEVELPARAMETERIVDLLPROC)wrap_addr_dll[GLGETTEXLEVELPARAMETERIVDLL].orig_func)(target, level, pname, params); +} + +void GLAPIENTRY glGetTexParameterivDLL(GLenum target, GLenum pname, GLint * params) { + ((PFNGLGETTEXPARAMETERIVDLLPROC)wrap_addr_dll[GLGETTEXPARAMETERIVDLL].orig_func)(target, pname, params); +} + +GLboolean GLAPIENTRY glIsEnabledDLL(GLenum cap) { + return ((PFNGLISENABLEDDLLPROC)wrap_addr_dll[GLISENABLEDDLL].orig_func)(cap); +} + +void GLAPIENTRY glLightfvDLL(GLenum light, GLenum pname, GLfloat const * params) { + ((PFNGLLIGHTFVDLLPROC)wrap_addr_dll[GLLIGHTFVDLL].orig_func)(light, pname, params); +} + +void GLAPIENTRY glLightModelfvDLL(GLenum pname, GLfloat const * params) { + ((PFNGLLIGHTMODELFVDLLPROC)wrap_addr_dll[GLLIGHTMODELFVDLL].orig_func)(pname, params); +} + +void GLAPIENTRY glLineWidthDLL(GLfloat width) { + ((PFNGLLINEWIDTHDLLPROC)wrap_addr_dll[GLLINEWIDTHDLL].orig_func)(width); +} + +void GLAPIENTRY glLoadIdentityDLL() { + ((PFNGLLOADIDENTITYDLLPROC)wrap_addr_dll[GLLOADIDENTITYDLL].orig_func)(); +} + +void GLAPIENTRY glLoadMatrixfDLL(GLfloat const * m) { + ((PFNGLLOADMATRIXFDLLPROC)wrap_addr_dll[GLLOADMATRIXFDLL].orig_func)(m); +} + +void GLAPIENTRY glMaterialfDLL(GLenum face, GLenum pname, GLfloat param) { + ((PFNGLMATERIALFDLLPROC)wrap_addr_dll[GLMATERIALFDLL].orig_func)(face, pname, param); +} + +void GLAPIENTRY glMaterialfvDLL(GLenum face, GLenum pname, GLfloat const * params) { + ((PFNGLMATERIALFVDLLPROC)wrap_addr_dll[GLMATERIALFVDLL].orig_func)(face, pname, params); +} + +void GLAPIENTRY glMatrixModeDLL(GLenum mode) { + ((PFNGLMATRIXMODEDLLPROC)wrap_addr_dll[GLMATRIXMODEDLL].orig_func)(mode); +} + +void GLAPIENTRY glMultMatrixdDLL(GLdouble const * m) { + ((PFNGLMULTMATRIXDDLLPROC)wrap_addr_dll[GLMULTMATRIXDDLL].orig_func)(m); +} + +void GLAPIENTRY glNormal3fDLL(GLfloat nx, GLfloat ny, GLfloat nz) { + ((PFNGLNORMAL3FDLLPROC)wrap_addr_dll[GLNORMAL3FDLL].orig_func)(nx, ny, nz); +} + +void GLAPIENTRY glNormalPointerDLL(GLenum type, GLsizei stride, const void * pointer) { + ((PFNGLNORMALPOINTERDLLPROC)wrap_addr_dll[GLNORMALPOINTERDLL].orig_func)(type, stride, pointer); +} + +void GLAPIENTRY glOrthoDLL(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar) { + mat4 mat; + mat4_ortho(left, right, bottom, top, zNear, zFar, &mat); + mat4_transpose(&mat, &mat); + glMultTransposeMatrixf((const GLfloat*)&mat); + //((PFNGLORTHODLLPROC)wrap_addr_dll[GLORTHODLL].orig_func)(left, right, bottom, top, zNear, zFar); +} + +void GLAPIENTRY glPixelStoreiDLL(GLenum pname, GLint param) { + ((PFNGLPIXELSTOREIDLLPROC)wrap_addr_dll[GLPIXELSTOREIDLL].orig_func)(pname, param); +} + +void GLAPIENTRY glPointSizeDLL(GLfloat size) { + ((PFNGLPOINTSIZEDLLPROC)wrap_addr_dll[GLPOINTSIZEDLL].orig_func)(size); +} + +void GLAPIENTRY glPolygonModeDLL(GLenum face, GLenum mode) { + ((PFNGLPOLYGONMODEDLLPROC)wrap_addr_dll[GLPOLYGONMODEDLL].orig_func)(face, mode); +} + +void GLAPIENTRY glPopAttribDLL() { + ((PFNGLPOPATTRIBDLLPROC)wrap_addr_dll[GLPOPATTRIBDLL].orig_func)(); +} + +void GLAPIENTRY glPopClientAttribDLL() { + ((PFNGLPOPCLIENTATTRIBDLLPROC)wrap_addr_dll[GLPOPCLIENTATTRIBDLL].orig_func)(); +} + +void GLAPIENTRY glPopMatrixDLL() { + ((PFNGLPOPMATRIXDLLPROC)wrap_addr_dll[GLPOPMATRIXDLL].orig_func)(); +} + +void GLAPIENTRY glPushAttribDLL(GLbitfield mask) { + ((PFNGLPUSHATTRIBDLLPROC)wrap_addr_dll[GLPUSHATTRIBDLL].orig_func)(mask); +} + +void GLAPIENTRY glPushClientAttribDLL(GLbitfield mask) { + ((PFNGLPUSHCLIENTATTRIBDLLPROC)wrap_addr_dll[GLPUSHCLIENTATTRIBDLL].orig_func)(mask); +} + +void GLAPIENTRY glPushMatrixDLL() { + ((PFNGLPUSHMATRIXDLLPROC)wrap_addr_dll[GLPUSHMATRIXDLL].orig_func)(); +} + +void GLAPIENTRY glReadBufferDLL(GLenum src) { + ((PFNGLREADBUFFERDLLPROC)wrap_addr_dll[GLREADBUFFERDLL].orig_func)(src); +} + +void GLAPIENTRY glReadPixelsDLL(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void * pixels) { + ((PFNGLREADPIXELSDLLPROC)wrap_addr_dll[GLREADPIXELSDLL].orig_func)(x, y, width, height, format, type, pixels); +} + +void GLAPIENTRY glRotatefDLL(GLfloat angle, GLfloat x, GLfloat y, GLfloat z) { + float_t c = cosf(angle * DEG_TO_RAD_FLOAT); + float_t s = sinf(angle * DEG_TO_RAD_FLOAT); + float_t t = 1.0f - c; + + mat4 mat; + mat.row0 = { t * x * x + c, t * x * y + z * s, t * x * z - y * s, 0.0f }; + mat.row1 = { t * y * x - z * s, t * y * y + c, t * y * z + x * s, 0.0f }; + mat.row2 = { t * z * x + y * s, t * z * y - x * s, t * z * z + c, 0.0f }; + mat.row3 = { 0.0f, 0.0f, 0.0f, 1.0f }; + mat4_transpose(&mat, &mat); + glMultTransposeMatrixf((const GLfloat*)&mat); + //((PFNGLROTATEFDLLPROC)wrap_addr_dll[GLROTATEFDLL].orig_func)(angle, x, y, z); +} + +void GLAPIENTRY glScalefDLL(GLfloat x, GLfloat y, GLfloat z) { + mat4 mat; + mat4_scale(x, y, z, &mat); + mat4_transpose(&mat, &mat); + glMultTransposeMatrixf((const GLfloat*)&mat); + //((PFNGLSCALEFDLLPROC)wrap_addr_dll[GLSCALEFDLL].orig_func)(x, y, z); +} + +void GLAPIENTRY glShadeModelDLL(GLenum mode) { + ((PFNGLSHADEMODELDLLPROC)wrap_addr_dll[GLSHADEMODELDLL].orig_func)(mode); +} + +void GLAPIENTRY glTexCoord2fDLL(GLfloat s, GLfloat t) { + ((PFNGLTEXCOORD2FDLLPROC)wrap_addr_dll[GLTEXCOORD2FDLL].orig_func)(s, t); +} + +void GLAPIENTRY glTexCoordPointerDLL(GLint size, GLenum type, GLsizei stride, const void * pointer) { + ((PFNGLTEXCOORDPOINTERDLLPROC)wrap_addr_dll[GLTEXCOORDPOINTERDLL].orig_func)(size, type, stride, pointer); +} + +void GLAPIENTRY glTexEnvfDLL(GLenum target, GLenum pname, GLfloat param) { + ((PFNGLTEXENVFDLLPROC)wrap_addr_dll[GLTEXENVFDLL].orig_func)(target, pname, param); +} + +void GLAPIENTRY glTexEnviDLL(GLenum target, GLenum pname, GLint param) { + ((PFNGLTEXENVIDLLPROC)wrap_addr_dll[GLTEXENVIDLL].orig_func)(target, pname, param); +} + +void GLAPIENTRY glTexImage1DDLL(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void * pixels) { + GLint _internalformat; + GLint _format; + switch (internalformat) { + case GL_LUMINANCE_ALPHA16F_ARB: + _internalformat = GL_RG16F; + _format = GL_RG; + break; + default: + _internalformat = internalformat; + _format = format; + break; + } + + ((PFNGLTEXIMAGE1DDLLPROC)wrap_addr_dll[GLTEXIMAGE1DDLL].orig_func)(target, level, _internalformat, width, border, _format, type, pixels); + + switch (internalformat) { + case GL_LUMINANCE_ALPHA16F_ARB: + glTexParameteriDLL(target, GL_TEXTURE_SWIZZLE_R, GL_RED); + glTexParameteriDLL(target, GL_TEXTURE_SWIZZLE_G, GL_RED); + glTexParameteriDLL(target, GL_TEXTURE_SWIZZLE_B, GL_RED); + glTexParameteriDLL(target, GL_TEXTURE_SWIZZLE_A, GL_GREEN); + break; + } +} + +void GLAPIENTRY glTexImage2DDLL(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void * pixels) { + GLint _internalformat; + switch (internalformat) { + case GL_ALPHA8: + _internalformat = GL_R8; + break; + case GL_LUMINANCE8: + _internalformat = GL_R8; + break; + case GL_LUMINANCE8_ALPHA8: + _internalformat = GL_RG8; + break; + default: + _internalformat = internalformat; + break; + } + + ((PFNGLTEXIMAGE2DDLLPROC)wrap_addr_dll[GLTEXIMAGE2DDLL].orig_func)(target, level, _internalformat, width, height, border, format, type, pixels); + + switch (internalformat) { + case GL_ALPHA8: + glTexParameteriDLL(target, GL_TEXTURE_SWIZZLE_R, GL_ZERO); + glTexParameteriDLL(target, GL_TEXTURE_SWIZZLE_G, GL_ZERO); + glTexParameteriDLL(target, GL_TEXTURE_SWIZZLE_B, GL_ZERO); + glTexParameteriDLL(target, GL_TEXTURE_SWIZZLE_A, GL_RED); + break; + case GL_LUMINANCE8: + glTexParameteriDLL(target, GL_TEXTURE_SWIZZLE_R, GL_RED); + glTexParameteriDLL(target, GL_TEXTURE_SWIZZLE_G, GL_RED); + glTexParameteriDLL(target, GL_TEXTURE_SWIZZLE_B, GL_RED); + glTexParameteriDLL(target, GL_TEXTURE_SWIZZLE_A, GL_ONE); + break; + case GL_LUMINANCE8_ALPHA8: + glTexParameteriDLL(target, GL_TEXTURE_SWIZZLE_R, GL_RED); + glTexParameteriDLL(target, GL_TEXTURE_SWIZZLE_G, GL_RED); + glTexParameteriDLL(target, GL_TEXTURE_SWIZZLE_B, GL_RED); + glTexParameteriDLL(target, GL_TEXTURE_SWIZZLE_A, GL_GREEN); + break; + } +} + +void GLAPIENTRY glTexParameterfDLL(GLenum target, GLenum pname, GLfloat param) { + ((PFNGLTEXPARAMETERFDLLPROC)wrap_addr_dll[GLTEXPARAMETERFDLL].orig_func)(target, pname, param); +} + +void GLAPIENTRY glTexParameterfvDLL(GLenum target, GLenum pname, GLfloat const * params) { + ((PFNGLTEXPARAMETERFVDLLPROC)wrap_addr_dll[GLTEXPARAMETERFVDLL].orig_func)(target, pname, params); +} + +void GLAPIENTRY glTexParameteriDLL(GLenum target, GLenum pname, GLint param) { + ((PFNGLTEXPARAMETERIDLLPROC)wrap_addr_dll[GLTEXPARAMETERIDLL].orig_func)(target, pname, param); +} + +void GLAPIENTRY glTexSubImage2DDLL(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void * pixels) { + ((PFNGLTEXSUBIMAGE2DDLLPROC)wrap_addr_dll[GLTEXSUBIMAGE2DDLL].orig_func)(target, level, xoffset, yoffset, width, height, format, type, pixels); +} + +void GLAPIENTRY glTranslatefDLL(GLfloat x, GLfloat y, GLfloat z) { + mat4 mat; + mat4_translate(x, y, z, &mat); + mat4_transpose(&mat, &mat); + glMultTransposeMatrixf((const GLfloat*)&mat); + //((PFNGLTRANSLATEFDLLPROC)wrap_addr_dll[GLTRANSLATEFDLL].orig_func)(x, y, z); +} + +void GLAPIENTRY glVertex3fDLL(GLfloat x, GLfloat y, GLfloat z) { + ((PFNGLVERTEX3FDLLPROC)wrap_addr_dll[GLVERTEX3FDLL].orig_func)(x, y, z); +} + +void GLAPIENTRY glVertex3fvDLL(GLfloat const * v) { + ((PFNGLVERTEX3FVDLLPROC)wrap_addr_dll[GLVERTEX3FVDLL].orig_func)(v); +} + +void GLAPIENTRY glVertexPointerDLL(GLint size, GLenum type, GLsizei stride, const void * pointer) { + ((PFNGLVERTEXPOINTERDLLPROC)wrap_addr_dll[GLVERTEXPOINTERDLL].orig_func)(size, type, stride, pointer); +} + +void GLAPIENTRY glActiveTexture(GLenum texture) { + ((PFNGLACTIVETEXTUREPROC)wrap_addr[GLACTIVETEXTURE].orig_func)(texture); +} + +void GLAPIENTRY glBindBufferARB(GLenum target, GLuint buffer) { + ((PFNGLBINDBUFFERARBPROC)wrap_addr[GLBINDBUFFERARB].orig_func)(target, buffer); +} + +void GLAPIENTRY glBindBufferBaseNV(GLenum target, GLuint index, GLuint buffer) { + ((PFNGLBINDBUFFERBASENVPROC)wrap_addr[GLBINDBUFFERBASENV].orig_func)(target, index, buffer); +} + +void GLAPIENTRY glBindFramebufferEXT(GLenum target, GLuint framebuffer) { + ((PFNGLBINDFRAMEBUFFEREXTPROC)wrap_addr[GLBINDFRAMEBUFFEREXT].orig_func)(target, framebuffer); +} + +void GLAPIENTRY glBindMultiTextureEXT(GLenum texunit, GLenum target, GLuint texture) { + ((PFNGLBINDMULTITEXTUREEXTPROC)wrap_addr[GLBINDMULTITEXTUREEXT].orig_func)(texunit, target, texture); +} + +void GLAPIENTRY glBindRenderbufferEXT(GLenum target, GLuint renderbuffer) { + ((PFNGLBINDRENDERBUFFEREXTPROC)wrap_addr[GLBINDRENDERBUFFEREXT].orig_func)(target, renderbuffer); +} + +void GLAPIENTRY glBufferDataARB(GLenum target, GLsizeiptrARB size, const void * data, GLenum usage) { + ((PFNGLBUFFERDATAARBPROC)wrap_addr[GLBUFFERDATAARB].orig_func)(target, size, data, usage); +} + +void GLAPIENTRY glClampColorARB(GLenum target, GLenum clamp) { + ((PFNGLCLAMPCOLORARBPROC)wrap_addr[GLCLAMPCOLORARB].orig_func)(target, clamp); +} + +void GLAPIENTRY glClientActiveTexture(GLenum texture) { + ((PFNGLCLIENTACTIVETEXTUREPROC)wrap_addr[GLCLIENTACTIVETEXTURE].orig_func)(texture); +} + +void GLAPIENTRY glCopyMultiTexSubImage2DEXT(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) { + ((PFNGLCOPYMULTITEXSUBIMAGE2DEXTPROC)wrap_addr[GLCOPYMULTITEXSUBIMAGE2DEXT].orig_func)(texunit, target, level, xoffset, yoffset, x, y, width, height); +} + +void GLAPIENTRY glDeleteBuffersARB(GLsizei n, GLuint const * buffers) { + ((PFNGLDELETEBUFFERSARBPROC)wrap_addr[GLDELETEBUFFERSARB].orig_func)(n, buffers); +} + +void GLAPIENTRY glDeleteFramebuffersEXT(GLsizei n, GLuint const * framebuffers) { + ((PFNGLDELETEFRAMEBUFFERSEXTPROC)wrap_addr[GLDELETEFRAMEBUFFERSEXT].orig_func)(n, framebuffers); +} + +void GLAPIENTRY glDeleteRenderbuffersEXT(GLsizei n, GLuint const * renderbuffers) { + ((PFNGLDELETERENDERBUFFERSEXTPROC)wrap_addr[GLDELETERENDERBUFFERSEXT].orig_func)(n, renderbuffers); +} + +void GLAPIENTRY glDeleteTextures(GLsizei n, GLuint const * textures) { + glDeleteTexturesDLL(n, textures); + //((PFNGLDELETETEXTURESPROC)wrap_addr[GLDELETETEXTURES].orig_func)(n, textures); +} + +void GLAPIENTRY glDisableVertexAttribArrayARB(GLuint index) { + ((PFNGLDISABLEVERTEXATTRIBARRAYARBPROC)wrap_addr[GLDISABLEVERTEXATTRIBARRAYARB].orig_func)(index); +} + +void GLAPIENTRY glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void * indices) { + ((PFNGLDRAWRANGEELEMENTSPROC)wrap_addr[GLDRAWRANGEELEMENTS].orig_func)(mode, start, end, count, type, indices); +} + +void GLAPIENTRY glEnableVertexAttribArray(GLuint index) { + ((PFNGLENABLEVERTEXATTRIBARRAYPROC)wrap_addr[GLENABLEVERTEXATTRIBARRAY].orig_func)(index); +} + +void GLAPIENTRY glEnableVertexAttribArrayARB(GLuint index) { + ((PFNGLENABLEVERTEXATTRIBARRAYARBPROC)wrap_addr[GLENABLEVERTEXATTRIBARRAYARB].orig_func)(index); +} + +void GLAPIENTRY glFramebufferRenderbufferEXT(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) { + ((PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC)wrap_addr[GLFRAMEBUFFERRENDERBUFFEREXT].orig_func)(target, attachment, renderbuffertarget, renderbuffer); +} + +void GLAPIENTRY glFramebufferTexture2DEXT(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) { + ((PFNGLFRAMEBUFFERTEXTURE2DEXTPROC)wrap_addr[GLFRAMEBUFFERTEXTURE2DEXT].orig_func)(target, attachment, textarget, texture, level); +} + +void GLAPIENTRY glGenFramebuffersEXT(GLsizei n, GLuint * framebuffers) { + ((PFNGLGENFRAMEBUFFERSEXTPROC)wrap_addr[GLGENFRAMEBUFFERSEXT].orig_func)(n, framebuffers); +} + +void GLAPIENTRY glGenRenderbuffersEXT(GLsizei n, GLuint * renderbuffers) { + ((PFNGLGENRENDERBUFFERSEXTPROC)wrap_addr[GLGENRENDERBUFFERSEXT].orig_func)(n, renderbuffers); +} + +void GLAPIENTRY glGenTextures(GLsizei n, GLuint * textures) { + glGenTexturesDLL(n, textures); + //((PFNGLGENTEXTURESPROC)wrap_addr[GLGENTEXTURES].orig_func)(n, textures); +} + +void GLAPIENTRY glGetProgramEnvParameterfvARB(GLenum target, GLuint index, GLfloat * params) { + ((PFNGLGETPROGRAMENVPARAMETERFVARBPROC)wrap_addr[GLGETPROGRAMENVPARAMETERFVARB].orig_func)(target, index, params); +} + +void GLAPIENTRY glGetProgramivARB(GLenum target, GLenum pname, GLint * params) { + switch (pname) { + case GL_VERTEX_PROGRAM_ARB: + case GL_FRAGMENT_PROGRAM_ARB: + if (params) + *params = 0; + return; + } + ((PFNGLGETPROGRAMIVARBPROC)wrap_addr[GLGETPROGRAMIVARB].orig_func)(target, pname, params); +} + +void GLAPIENTRY glGetTextureImageEXT(GLuint texture, GLenum target, GLint level, GLenum format, GLenum type, void * pixels) { + ((PFNGLGETTEXTUREIMAGEEXTPROC)wrap_addr[GLGETTEXTUREIMAGEEXT].orig_func)(texture, target, level, format, type, pixels); +} + +GLboolean GLAPIENTRY glIsBufferARB(GLuint buffer) { + return ((PFNGLISBUFFERARBPROC)wrap_addr[GLISBUFFERARB].orig_func)(buffer); +} + +void GLAPIENTRY glLoadTransposeMatrixf(GLfloat const * m) { + ((PFNGLLOADTRANSPOSEMATRIXFPROC)wrap_addr[GLLOADTRANSPOSEMATRIXF].orig_func)(m); +} + +void * GLAPIENTRY glMapNamedBufferEXT(GLuint buffer, GLenum access) { + return ((PFNGLMAPNAMEDBUFFEREXTPROC)wrap_addr[GLMAPNAMEDBUFFEREXT].orig_func)(buffer, access); +} + +void GLAPIENTRY glMultiTexCoord2f(GLenum target, GLfloat s, GLfloat t) { + ((PFNGLMULTITEXCOORD2FPROC)wrap_addr[GLMULTITEXCOORD2F].orig_func)(target, s, t); +} + +void GLAPIENTRY glMultiTexCoord2fv(GLenum target, GLfloat const * v) { + ((PFNGLMULTITEXCOORD2FVPROC)wrap_addr[GLMULTITEXCOORD2FV].orig_func)(target, v); +} + +void GLAPIENTRY glMultTransposeMatrixf(GLfloat const * m) { + ((PFNGLMULTTRANSPOSEMATRIXFPROC)wrap_addr[GLMULTTRANSPOSEMATRIXF].orig_func)(m); +} + +void GLAPIENTRY glNamedBufferDataEXT(GLuint buffer, GLsizeiptr size, const void * data, GLenum usage) { + ((PFNGLNAMEDBUFFERDATAEXTPROC)wrap_addr[GLNAMEDBUFFERDATAEXT].orig_func)(buffer, size, data, usage); +} + +void GLAPIENTRY glNamedBufferSubDataEXT(GLuint buffer, GLintptr offset, GLsizeiptr size, const void * data) { + ((PFNGLNAMEDBUFFERSUBDATAEXTPROC)wrap_addr[GLNAMEDBUFFERSUBDATAEXT].orig_func)(buffer, offset, size, data); +} + +void GLAPIENTRY glPointParameterf(GLenum pname, GLfloat param) { + ((PFNGLPOINTPARAMETERFPROC)wrap_addr[GLPOINTPARAMETERF].orig_func)(pname, param); +} + +void GLAPIENTRY glPointParameterfv(GLenum pname, GLfloat const * params) { + ((PFNGLPOINTPARAMETERFVPROC)wrap_addr[GLPOINTPARAMETERFV].orig_func)(pname, params); +} + +void GLAPIENTRY glPointParameteri(GLenum pname, GLint param) { + ((PFNGLPOINTPARAMETERIPROC)wrap_addr[GLPOINTPARAMETERI].orig_func)(pname, param); +} + +void GLAPIENTRY glPrimitiveRestartIndexNV(GLuint index) { + glPrimitiveRestartIndex(index); + //((PFNGLPRIMITIVERESTARTINDEXNVPROC)wrap_addr[GLPRIMITIVERESTARTINDEXNV].orig_func)(index); +} + +void GLAPIENTRY glProgramBufferParametersfvNV(GLenum target, GLuint bindingIndex, GLuint wordIndex, GLsizei count, GLfloat const * params) { + ((PFNGLPROGRAMBUFFERPARAMETERSFVNVPROC)wrap_addr[GLPROGRAMBUFFERPARAMETERSFVNV].orig_func)(target, bindingIndex, wordIndex, count, params); +} + +void GLAPIENTRY glProgramEnvParameter4fARB(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w) { + ((PFNGLPROGRAMENVPARAMETER4FARBPROC)wrap_addr[GLPROGRAMENVPARAMETER4FARB].orig_func)(target, index, x, y, z, w); +} + +void GLAPIENTRY glProgramEnvParameter4fvARB(GLenum target, GLuint index, GLfloat const * params) { + ((PFNGLPROGRAMENVPARAMETER4FVARBPROC)wrap_addr[GLPROGRAMENVPARAMETER4FVARB].orig_func)(target, index, params); +} + +void GLAPIENTRY glProgramEnvParameters4fvEXT(GLenum target, GLuint index, GLsizei count, GLfloat const * params) { + ((PFNGLPROGRAMENVPARAMETERS4FVEXTPROC)wrap_addr[GLPROGRAMENVPARAMETERS4FVEXT].orig_func)(target, index, count, params); +} + +void GLAPIENTRY glProgramLocalParameter4fARB(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w) { + ((PFNGLPROGRAMLOCALPARAMETER4FARBPROC)wrap_addr[GLPROGRAMLOCALPARAMETER4FARB].orig_func)(target, index, x, y, z, w); +} + +void GLAPIENTRY glProgramLocalParameter4fvARB(GLenum target, GLuint index, GLfloat const * params) { + ((PFNGLPROGRAMLOCALPARAMETER4FVARBPROC)wrap_addr[GLPROGRAMLOCALPARAMETER4FVARB].orig_func)(target, index, params); +} + +void GLAPIENTRY glProgramLocalParameters4fvEXT(GLenum target, GLuint index, GLsizei count, GLfloat const * params) { + ((PFNGLPROGRAMLOCALPARAMETERS4FVEXTPROC)wrap_addr[GLPROGRAMLOCALPARAMETERS4FVEXT].orig_func)(target, index, count, params); +} + +void GLAPIENTRY glRenderbufferStorageEXT(GLenum target, GLenum internalformat, GLsizei width, GLsizei height) { + ((PFNGLRENDERBUFFERSTORAGEEXTPROC)wrap_addr[GLRENDERBUFFERSTORAGEEXT].orig_func)(target, internalformat, width, height); +} + +void GLAPIENTRY glRenderbufferStorageMultisampleCoverageNV(GLenum target, GLsizei coverageSamples, GLsizei colorSamples, GLenum internalformat, GLsizei width, GLsizei height) { + ((PFNGLRENDERBUFFERSTORAGEMULTISAMPLECOVERAGENVPROC)wrap_addr[GLRENDERBUFFERSTORAGEMULTISAMPLECOVERAGENV].orig_func)(target, coverageSamples, colorSamples, internalformat, width, height); +} + +GLboolean GLAPIENTRY glUnmapNamedBufferEXT(GLuint buffer) { + return ((PFNGLUNMAPNAMEDBUFFEREXTPROC)wrap_addr[GLUNMAPNAMEDBUFFEREXT].orig_func)(buffer); +} + +void GLAPIENTRY glUseProgram(GLuint program) { + current_program = program; + ((PFNGLUSEPROGRAMPROC)wrap_addr[GLUSEPROGRAM].orig_func)(program); +} + +void GLAPIENTRY glVertexAttribPointerARB(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void * pointer) { + ((PFNGLVERTEXATTRIBPOINTERARBPROC)wrap_addr[GLVERTEXATTRIBPOINTERARB].orig_func)(index, size, type, normalized, stride, pointer); +} + +void GLAPIENTRY glBeginGLUT(GLenum mode) { + ((PFNGLBEGINGLUTPROC)wrap_addr_glut[GLBEGINGLUT].orig_func)(mode); +} + +void GLAPIENTRY glBitmapGLUT(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, GLubyte const * bitmap) { + ((PFNGLBITMAPGLUTPROC)wrap_addr_glut[GLBITMAPGLUT].orig_func)(width, height, xorig, yorig, xmove, ymove, bitmap); +} + +void GLAPIENTRY glDrawBufferGLUT(GLenum buf) { + ((PFNGLDRAWBUFFERGLUTPROC)wrap_addr_glut[GLDRAWBUFFERGLUT].orig_func)(buf); +} + +void GLAPIENTRY glEnableGLUT(GLenum cap) { + ((PFNGLENABLEGLUTPROC)wrap_addr_glut[GLENABLEGLUT].orig_func)(cap); +} + +void GLAPIENTRY glEndGLUT() { + ((PFNGLENDGLUTPROC)wrap_addr_glut[GLENDGLUT].orig_func)(); +} + +void GLAPIENTRY glEvalMesh2GLUT(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2) { + ((PFNGLEVALMESH2GLUTPROC)wrap_addr_glut[GLEVALMESH2GLUT].orig_func)(mode, i1, i2, j1, j2); +} + +GLenum GLAPIENTRY glGetErrorGLUT() { + return ((PFNGLGETERRORGLUTPROC)wrap_addr_glut[GLGETERRORGLUT].orig_func)(); +} + +void GLAPIENTRY glGetIntegervGLUT(GLenum pname, GLint * data) { + ((PFNGLGETINTEGERVGLUTPROC)wrap_addr_glut[GLGETINTEGERVGLUT].orig_func)(pname, data); +} + +GLubyte const * GLAPIENTRY glGetStringGLUT(GLenum name) { + return ((PFNGLGETSTRINGGLUTPROC)wrap_addr_glut[GLGETSTRINGGLUT].orig_func)(name); +} + +void GLAPIENTRY glMap2fGLUT(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, GLfloat const * points) { + ((PFNGLMAP2FGLUTPROC)wrap_addr_glut[GLMAP2FGLUT].orig_func)(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points); +} + +void GLAPIENTRY glMapGrid2fGLUT(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2) { + ((PFNGLMAPGRID2FGLUTPROC)wrap_addr_glut[GLMAPGRID2FGLUT].orig_func)(un, u1, u2, vn, v1, v2); +} + +void GLAPIENTRY glNormal3fGLUT(GLfloat nx, GLfloat ny, GLfloat nz) { + ((PFNGLNORMAL3FGLUTPROC)wrap_addr_glut[GLNORMAL3FGLUT].orig_func)(nx, ny, nz); +} + +void GLAPIENTRY glNormal3fvGLUT(GLfloat const * v) { + ((PFNGLNORMAL3FVGLUTPROC)wrap_addr_glut[GLNORMAL3FVGLUT].orig_func)(v); +} + +void GLAPIENTRY glPixelStoreiGLUT(GLenum pname, GLint param) { + ((PFNGLPIXELSTOREIGLUTPROC)wrap_addr_glut[GLPIXELSTOREIGLUT].orig_func)(pname, param); +} + +void GLAPIENTRY glPolygonModeGLUT(GLenum face, GLenum mode) { + ((PFNGLPOLYGONMODEGLUTPROC)wrap_addr_glut[GLPOLYGONMODEGLUT].orig_func)(face, mode); +} + +void GLAPIENTRY glPopAttribGLUT() { + ((PFNGLPOPATTRIBGLUTPROC)wrap_addr_glut[GLPOPATTRIBGLUT].orig_func)(); +} + +void GLAPIENTRY glPopMatrixGLUT() { + ((PFNGLPOPMATRIXGLUTPROC)wrap_addr_glut[GLPOPMATRIXGLUT].orig_func)(); +} + +void GLAPIENTRY glPushAttribGLUT(GLbitfield mask) { + ((PFNGLPUSHATTRIBGLUTPROC)wrap_addr_glut[GLPUSHATTRIBGLUT].orig_func)(mask); +} + +void GLAPIENTRY glPushMatrixGLUT() { + ((PFNGLPUSHMATRIXGLUTPROC)wrap_addr_glut[GLPUSHMATRIXGLUT].orig_func)(); +} + +void GLAPIENTRY glReadBufferGLUT(GLenum src) { + ((PFNGLREADBUFFERGLUTPROC)wrap_addr_glut[GLREADBUFFERGLUT].orig_func)(src); +} + +void GLAPIENTRY glRotatefGLUT(GLfloat angle, GLfloat x, GLfloat y, GLfloat z) { + float_t c = cosf(angle * DEG_TO_RAD_FLOAT); + float_t s = sinf(angle * DEG_TO_RAD_FLOAT); + float_t t = 1.0f - c; + + mat4 mat; + mat.row0 = { t * x * x + c, t * x * y + z * s, t * x * z - y * s, 0.0f }; + mat.row1 = { t * y * x - z * s, t * y * y + c, t * y * z + x * s, 0.0f }; + mat.row2 = { t * z * x + y * s, t * z * y - x * s, t * z * z + c, 0.0f }; + mat.row3 = { 0.0f, 0.0f, 0.0f, 1.0f }; + mat4_transpose(&mat, &mat); + glMultTransposeMatrixf((const GLfloat*)&mat); + //((PFNGLROTATEFGLUTPROC)wrap_addr_glut[GLROTATEFGLUT].orig_func)(angle, x, y, z); +} + +void GLAPIENTRY glScalefGLUT(GLfloat x, GLfloat y, GLfloat z) { + mat4 mat; + mat4_scale(x, y, z, &mat); + mat4_transpose(&mat, &mat); + glMultTransposeMatrixf((const GLfloat*)&mat); + //((PFNGLSCALEFGLUTPROC)wrap_addr_glut[GLSCALEFGLUT].orig_func)(x, y, z); +} + +void GLAPIENTRY glTranslatefGLUT(GLfloat x, GLfloat y, GLfloat z) { + mat4 mat; + mat4_translate(x, y, z, &mat); + mat4_transpose(&mat, &mat); + glMultTransposeMatrixf((const GLfloat*)&mat); + //((PFNGLTRANSLATEFGLUTPROC)wrap_addr_glut[GLTRANSLATEFGLUT].orig_func)(x, y, z); +} + +void GLAPIENTRY glVertex2fGLUT(GLfloat x, GLfloat y) { + ((PFNGLVERTEX2FGLUTPROC)wrap_addr_glut[GLVERTEX2FGLUT].orig_func)(x, y); +} + +void GLAPIENTRY glVertex3fGLUT(GLfloat x, GLfloat y, GLfloat z) { + ((PFNGLVERTEX3FGLUTPROC)wrap_addr_glut[GLVERTEX3FGLUT].orig_func)(x, y, z); +} + +void GLAPIENTRY glVertex3fvGLUT(GLfloat const * v) { + ((PFNGLVERTEX3FVGLUTPROC)wrap_addr_glut[GLVERTEX3FVGLUT].orig_func)(v); +} + +HGLRC GLAPIENTRY wglCreateContextGLUT(HDC hDc) { + return ((PFNWGLCREATECONTEXTGLUTPROC)wrap_addr_glut[WGLCREATECONTEXTGLUT].orig_func)(hDc); +} + +typedef void (GLAPIENTRY* PFNGLTEXPARAMETERIVPROC)(GLenum target, GLenum pname, const GLint* params); +typedef void (GLAPIENTRY* PFNGLSTENCILMASKPROC)(GLuint mask); +typedef void (GLAPIENTRY* PFNGLPRIMITIVERESTARTINDEXPROC)(GLuint index); +typedef void (GLAPIENTRY* PFNGLCLEARDEPTHFPROC)(GLfloat d); +typedef void (GLAPIENTRY* PFNGLGETPROGRAMBINARYPROC)(GLuint program, GLsizei bufSize, GLsizei* length, GLenum* binaryFormat, void* binary); +typedef void (GLAPIENTRY* PFNGLPROGRAMBINARYPROC)(GLuint program, GLenum binaryFormat, const void* binary, GLsizei length); +typedef void (GLAPIENTRY* PFNGLBUFFERSTORAGEPROC)(GLenum target, GLsizeiptr size, const void* data, GLbitfield flags); +typedef void (GLAPIENTRY* PFNGLCREATEBUFFERSPROC)(GLsizei n, GLuint* buffers); +typedef void (GLAPIENTRY* PFNGLNAMEDBUFFERSTORAGEPROC)(GLuint buffer, GLsizeiptr size, const void* data, GLbitfield flags); +typedef void (GLAPIENTRY* PFNGLNAMEDBUFFERSUBDATAPROC)(GLuint buffer, GLintptr offset, GLsizeiptr size, const void* data); +typedef void* (GLAPIENTRY* PFNGLMAPNAMEDBUFFERPROC)(GLuint buffer, GLenum access); +typedef GLboolean (GLAPIENTRY* PFNGLUNMAPNAMEDBUFFERPROC)(GLuint buffer); +typedef void (GLAPIENTRY* PFNGLTEXTURESUBIMAGE2DPROC)(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* pixels); + +#if DEBUG +typedef void(GLAPIENTRY* PFNGLPUSHDEBUGGROUPPROC)(GLenum source, GLuint id, GLsizei length, const GLchar* message); +typedef void(GLAPIENTRY* PFNGLPOPDEBUGGROUPPROC)(); +#endif + +static PFNGLTEXPARAMETERIVPROC _glTexParameteriv = 0; +static PFNGLSTENCILMASKPROC _glStencilMask = 0; +static PFNGLPRIMITIVERESTARTINDEXPROC _glPrimitiveRestartIndex = 0; +static PFNGLCLEARDEPTHFPROC _glClearDepthf = 0; +static PFNGLGETPROGRAMBINARYPROC _glGetProgramBinary = 0; +static PFNGLPROGRAMBINARYPROC _glProgramBinary = 0; +static PFNGLBUFFERSTORAGEPROC _glBufferStorage = 0; +static PFNGLCREATEBUFFERSPROC _glCreateBuffers = 0; +static PFNGLNAMEDBUFFERSTORAGEPROC _glNamedBufferStorage = 0; +static PFNGLNAMEDBUFFERSUBDATAPROC _glNamedBufferSubData = 0; +static PFNGLMAPNAMEDBUFFERPROC _glMapNamedBuffer = 0; +static PFNGLUNMAPNAMEDBUFFERPROC _glUnmapNamedBuffer = 0; +static PFNGLTEXTURESUBIMAGE2DPROC _glTextureSubImage2D = 0; + +#if DEBUG +static PFNGLPUSHDEBUGGROUPPROC _glPushDebugGroup = 0; +static PFNGLPOPDEBUGGROUPPROC _glPopDebugGroup = 0; +#endif + +void GLAPIENTRY glTexParameteriv(GLenum target, GLenum pname, const GLint* params) { + if (!_glTexParameteriv) + _glTexParameteriv = (PFNGLTEXPARAMETERIVPROC)GetProcAddress((HMODULE)opengl32_handle, "glTexParameteriv"); + _glTexParameteriv(target, pname, params); +} + +void GLAPIENTRY glStencilMask(GLuint mask) { + if (!_glStencilMask) + _glStencilMask = (PFNGLSTENCILMASKPROC)wglGetProcAddressDLL("glStencilMask"); + _glStencilMask(mask); +} + +void GLAPIENTRY glPrimitiveRestartIndex(GLuint index) { + if (!_glPrimitiveRestartIndex) + _glPrimitiveRestartIndex = (PFNGLPRIMITIVERESTARTINDEXPROC)wglGetProcAddressDLL("glPrimitiveRestartIndex"); + _glPrimitiveRestartIndex(index); +} + +void GLAPIENTRY glClearDepthf(GLfloat d) { + if (!_glClearDepthf) + _glClearDepthf = (PFNGLCLEARDEPTHFPROC)wglGetProcAddressDLL("glClearDepthf"); + _glClearDepthf(d); +} + +void GLAPIENTRY glGetProgramBinary(GLuint program, GLsizei bufSize, GLsizei* length, GLenum* binaryFormat, void* binary) { + if (!_glGetProgramBinary) + _glGetProgramBinary = (PFNGLGETPROGRAMBINARYPROC)wglGetProcAddressDLL("glGetProgramBinary"); + _glGetProgramBinary(program, bufSize, length, binaryFormat, binary); +} + +void GLAPIENTRY glProgramBinary(GLuint program, GLenum binaryFormat, const void* binary, GLsizei length) { + if (!_glProgramBinary) + _glProgramBinary = (PFNGLPROGRAMBINARYPROC)wglGetProcAddressDLL("glProgramBinary"); + _glProgramBinary(program, binaryFormat, binary, length); +} + +void GLAPIENTRY glBufferStorage(GLenum target, GLsizeiptr size, const void* data, GLbitfield flags) { + if (!_glBufferStorage) + _glBufferStorage = (PFNGLBUFFERSTORAGEPROC)wglGetProcAddressDLL("glBufferStorage"); + _glBufferStorage(target, size, data, flags); +} + +void GLAPIENTRY glCreateBuffers(GLsizei n, GLuint* buffers) { + if (!_glCreateBuffers) + _glCreateBuffers = (PFNGLCREATEBUFFERSPROC)wglGetProcAddressDLL("glCreateBuffers"); + _glCreateBuffers(n, buffers); +} + +void GLAPIENTRY glNamedBufferStorage(GLuint buffer, GLsizeiptr size, const void* data, GLbitfield flags) { + if (!_glNamedBufferStorage) + _glNamedBufferStorage = (PFNGLNAMEDBUFFERSTORAGEPROC)wglGetProcAddressDLL("glNamedBufferStorage"); + _glNamedBufferStorage(buffer, size, data, flags); +} + +void GLAPIENTRY glNamedBufferSubData(GLuint buffer, GLintptr offset, GLsizeiptr size, const void* data) { + if (!_glNamedBufferSubData) + _glNamedBufferSubData = (PFNGLNAMEDBUFFERSUBDATAPROC)wglGetProcAddressDLL("glNamedBufferSubData"); + _glNamedBufferSubData(buffer, offset, size, data); +} + +void* GLAPIENTRY glMapNamedBuffer(GLuint buffer, GLenum access) { + if (!_glMapNamedBuffer) + _glMapNamedBuffer = (PFNGLMAPNAMEDBUFFERPROC)wglGetProcAddressDLL("glMapNamedBuffer"); + return _glMapNamedBuffer(buffer, access); +} + +GLboolean GLAPIENTRY glUnmapNamedBuffer(GLuint buffer) { + if (!_glUnmapNamedBuffer) + _glUnmapNamedBuffer = (PFNGLUNMAPNAMEDBUFFERPROC)wglGetProcAddressDLL("glUnmapNamedBuffer"); + return _glUnmapNamedBuffer(buffer); +} + +void GLAPIENTRY glTextureSubImage2D(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* pixels) { + if (!_glTextureSubImage2D) + _glTextureSubImage2D = (PFNGLTEXTURESUBIMAGE2DPROC)wglGetProcAddressDLL("glTextureSubImage2D"); + _glTextureSubImage2D(texture, level, xoffset, yoffset, width, height, format, type, pixels); +} + +#if DEBUG +void constexpr GLAPIENTRY glPushDebugGroup(GLenum source, GLuint id, GLsizei length, const GLchar* message) { + if (!_glPushDebugGroup) + _glPushDebugGroup = (PFNGLPUSHDEBUGGROUPPROC)wglGetProcAddressDLL("glPushDebugGroup"); + return _glPushDebugGroup(source, id, length, message); +} + +void constexpr GLAPIENTRY glPopDebugGroup() { + if (!_glPopDebugGroup) + _glPopDebugGroup = (PFNGLPOPDEBUGGROUPPROC)wglGetProcAddressDLL("glPopDebugGroup"); + return _glPopDebugGroup(); +} +#endif diff --git a/src/DivaGL/wrap.hpp b/src/DivaGL/wrap.hpp new file mode 100644 index 0000000..f7d00b4 --- /dev/null +++ b/src/DivaGL/wrap.hpp @@ -0,0 +1,3432 @@ +/* + by korenkonder + GitHub/GitLab: korenkonder +*/ + +#pragma once + +#include "gl.hpp" +#include + +struct gl_func_struct { + size_t address; + size_t func; +}; + +typedef void (GLAPIENTRY * PFNGLBLENDFUNCDLLPROC) (GLenum sfactor, GLenum dfactor); +typedef void (GLAPIENTRY * PFNGLCOLORMASKDLLPROC) (GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha); +typedef void (GLAPIENTRY * PFNGLDELETETEXTURESDLLPROC) (GLsizei n, GLuint const * textures); +typedef void (GLAPIENTRY * PFNGLDEPTHMASKDLLPROC) (GLboolean flag); +typedef void (GLAPIENTRY * PFNGLFINISHDLLPROC) (); +typedef void (GLAPIENTRY * PFNGLGENTEXTURESDLLPROC) (GLsizei n, GLuint * textures); +typedef void (GLAPIENTRY * PFNGLSCISSORDLLPROC) (GLint x, GLint y, GLsizei width, GLsizei height); +typedef void (GLAPIENTRY * PFNGLVIEWPORTDLLPROC) (GLint x, GLint y, GLsizei width, GLsizei height); +typedef PROC (GLAPIENTRY * PFNWGLGETPROCADDRESSDLLPROC) (LPCSTR lpszProc); + +typedef void (GLAPIENTRY * PFNGLACTIVESTENCILFACEEXTPROC) (GLenum face); +typedef void (GLAPIENTRY * PFNGLACTIVETEXTUREARBPROC) (GLenum texture); +typedef void (GLAPIENTRY * PFNGLACTIVEVARYINGNVPROC) (GLuint program, GLchar const * name); +typedef GLboolean (GLAPIENTRY * PFNGLAREPROGRAMSRESIDENTNVPROC) (GLsizei n, GLuint const * programs, GLboolean * residences); +typedef GLboolean (GLAPIENTRY * PFNGLARETEXTURESRESIDENTEXTPROC) (GLsizei n, GLuint const * textures, GLboolean * residences); +typedef void (GLAPIENTRY * PFNGLARRAYELEMENTEXTPROC) (GLint i); +typedef void (GLAPIENTRY * PFNGLATTACHOBJECTARBPROC) (GLhandleARB containerObj, GLhandleARB obj); +typedef void (GLAPIENTRY * PFNGLATTACHSHADERPROC) (GLuint program, GLuint shader); +typedef void (GLAPIENTRY * PFNGLBEGINCONDITIONALRENDERPROC) (GLuint id, GLenum mode); +typedef void (GLAPIENTRY * PFNGLBEGINCONDITIONALRENDERNVPROC) (GLuint id, GLenum mode); +typedef void (GLAPIENTRY * PFNGLBEGINOCCLUSIONQUERYNVPROC) (GLuint id); +typedef void (GLAPIENTRY * PFNGLBEGINQUERYPROC) (GLenum target, GLuint id); +typedef void (GLAPIENTRY * PFNGLBEGINQUERYARBPROC) (GLenum target, GLuint id); +typedef void (GLAPIENTRY * PFNGLBEGINTRANSFORMFEEDBACKPROC) (GLenum primitiveMode); +typedef void (GLAPIENTRY * PFNGLBEGINTRANSFORMFEEDBACKNVPROC) (GLenum primitiveMode); +typedef void (GLAPIENTRY * PFNGLBINDATTRIBLOCATIONPROC) (GLuint program, GLuint index, GLchar const * name); +typedef void (GLAPIENTRY * PFNGLBINDATTRIBLOCATIONARBPROC) (GLhandleARB programObj, GLuint index, GLcharARB const * name); +typedef void (GLAPIENTRY * PFNGLBINDBUFFERPROC) (GLenum target, GLuint buffer); +typedef void (GLAPIENTRY * PFNGLBINDBUFFERBASEPROC) (GLenum target, GLuint index, GLuint buffer); +typedef void (GLAPIENTRY * PFNGLBINDBUFFEROFFSETNVPROC) (GLenum target, GLuint index, GLuint buffer, GLintptr offset); +typedef void (GLAPIENTRY * PFNGLBINDBUFFERRANGEPROC) (GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size); +typedef void (GLAPIENTRY * PFNGLBINDBUFFERRANGENVPROC) (GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size); +typedef void (GLAPIENTRY * PFNGLBINDFRAGDATALOCATIONPROC) (GLuint program, GLuint color, GLchar const * name); +typedef void (GLAPIENTRY * PFNGLBINDFRAGDATALOCATIONEXTPROC) (GLuint program, GLuint color, GLchar const * name); +typedef void (GLAPIENTRY * PFNGLBINDFRAMEBUFFERPROC) (GLenum target, GLuint framebuffer); +typedef void (GLAPIENTRY * PFNGLBINDPROGRAMARBPROC) (GLenum target, GLuint program); +typedef void (GLAPIENTRY * PFNGLBINDPROGRAMNVPROC) (GLenum target, GLuint id); +typedef void (GLAPIENTRY * PFNGLBINDRENDERBUFFERPROC) (GLenum target, GLuint renderbuffer); +typedef void (GLAPIENTRY * PFNGLBINDSAMPLERPROC) (GLuint unit, GLuint sampler); +typedef void (GLAPIENTRY * PFNGLBINDTEXTUREEXTPROC) (GLenum target, GLuint texture); +typedef void (GLAPIENTRY * PFNGLBINDVERTEXARRAYPROC) (GLuint array); +typedef void (GLAPIENTRY * PFNGLBLENDCOLORPROC) (GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +typedef void (GLAPIENTRY * PFNGLBLENDCOLOREXTPROC) (GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +typedef void (GLAPIENTRY * PFNGLBLENDEQUATIONPROC) (GLenum mode); +typedef void (GLAPIENTRY * PFNGLBLENDEQUATIONEXTPROC) (GLenum mode); +typedef void (GLAPIENTRY * PFNGLBLENDEQUATIONSEPARATEPROC) (GLenum modeRGB, GLenum modeAlpha); +typedef void (GLAPIENTRY * PFNGLBLENDEQUATIONSEPARATEEXTPROC) (GLenum modeRGB, GLenum modeAlpha); +typedef void (GLAPIENTRY * PFNGLBLENDFUNCSEPARATEPROC) (GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha); +typedef void (GLAPIENTRY * PFNGLBLENDFUNCSEPARATEEXTPROC) (GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha); +typedef void (GLAPIENTRY * PFNGLBLITFRAMEBUFFERPROC) (GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter); +typedef void (GLAPIENTRY * PFNGLBLITFRAMEBUFFEREXTPROC) (GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter); +typedef void (GLAPIENTRY * PFNGLBUFFERDATAPROC) (GLenum target, GLsizeiptr size, const void * data, GLenum usage); +typedef void (GLAPIENTRY * PFNGLBUFFERSUBDATAPROC) (GLenum target, GLintptr offset, GLsizeiptr size, const void * data); +typedef void (GLAPIENTRY * PFNGLBUFFERSUBDATAARBPROC) (GLenum target, GLintptrARB offset, GLsizeiptrARB size, const void * data); +typedef GLenum (GLAPIENTRY * PFNGLCHECKFRAMEBUFFERSTATUSPROC) (GLenum target); +typedef GLenum (GLAPIENTRY * PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC) (GLenum target); +typedef GLenum (GLAPIENTRY * PFNGLCHECKNAMEDFRAMEBUFFERSTATUSEXTPROC) (GLuint framebuffer, GLenum target); +typedef void (GLAPIENTRY * PFNGLCLEARBUFFERFIPROC) (GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil); +typedef void (GLAPIENTRY * PFNGLCLEARBUFFERFVPROC) (GLenum buffer, GLint drawbuffer, GLfloat const * value); +typedef void (GLAPIENTRY * PFNGLCLEARBUFFERIVPROC) (GLenum buffer, GLint drawbuffer, GLint const * value); +typedef void (GLAPIENTRY * PFNGLCLEARBUFFERUIVPROC) (GLenum buffer, GLint drawbuffer, GLuint const * value); +typedef void (GLAPIENTRY * PFNGLCLEARCOLORIIEXTPROC) (GLint red, GLint green, GLint blue, GLint alpha); +typedef void (GLAPIENTRY * PFNGLCLEARCOLORIUIEXTPROC) (GLuint red, GLuint green, GLuint blue, GLuint alpha); +typedef void (GLAPIENTRY * PFNGLCLEARDEPTHDNVPROC) (GLdouble depth); +typedef void (GLAPIENTRY * PFNGLCLIENTACTIVETEXTUREARBPROC) (GLenum texture); +typedef void (GLAPIENTRY * PFNGLCLIENTATTRIBDEFAULTEXTPROC) (GLbitfield mask); +typedef void (GLAPIENTRY * PFNGLCOLOR3HNVPROC) (GLhalfNV red, GLhalfNV green, GLhalfNV blue); +typedef void (GLAPIENTRY * PFNGLCOLOR3HVNVPROC) (GLhalfNV const * v); +typedef void (GLAPIENTRY * PFNGLCOLOR4HNVPROC) (GLhalfNV red, GLhalfNV green, GLhalfNV blue, GLhalfNV alpha); +typedef void (GLAPIENTRY * PFNGLCOLOR4HVNVPROC) (GLhalfNV const * v); +typedef void (GLAPIENTRY * PFNGLCOLORMASKIPROC) (GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a); +typedef void (GLAPIENTRY * PFNGLCOLORMASKINDEXEDEXTPROC) (GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a); +typedef void (GLAPIENTRY * PFNGLCOLORPOINTEREXTPROC) (GLint size, GLenum type, GLsizei stride, GLsizei count, const void * pointer); +typedef void (GLAPIENTRY * PFNGLCOLORSUBTABLEPROC) (GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const void * data); +typedef void (GLAPIENTRY * PFNGLCOLORSUBTABLEEXTPROC) (GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const void * data); +typedef void (GLAPIENTRY * PFNGLCOLORTABLEPROC) (GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const void * table); +typedef void (GLAPIENTRY * PFNGLCOLORTABLEEXTPROC) (GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum type, const void * table); +typedef void (GLAPIENTRY * PFNGLCOLORTABLEPARAMETERFVPROC) (GLenum target, GLenum pname, GLfloat const * params); +typedef void (GLAPIENTRY * PFNGLCOLORTABLEPARAMETERIVPROC) (GLenum target, GLenum pname, GLint const * params); +typedef void (GLAPIENTRY * PFNGLCOMBINERINPUTNVPROC) (GLenum stage, GLenum portion, GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage); +typedef void (GLAPIENTRY * PFNGLCOMBINEROUTPUTNVPROC) (GLenum stage, GLenum portion, GLenum abOutput, GLenum cdOutput, GLenum sumOutput, GLenum scale, GLenum bias, GLboolean abDotProduct, GLboolean cdDotProduct, GLboolean muxSum); +typedef void (GLAPIENTRY * PFNGLCOMBINERPARAMETERFNVPROC) (GLenum pname, GLfloat param); +typedef void (GLAPIENTRY * PFNGLCOMBINERPARAMETERFVNVPROC) (GLenum pname, GLfloat const * params); +typedef void (GLAPIENTRY * PFNGLCOMBINERPARAMETERINVPROC) (GLenum pname, GLint param); +typedef void (GLAPIENTRY * PFNGLCOMBINERPARAMETERIVNVPROC) (GLenum pname, GLint const * params); +typedef void (GLAPIENTRY * PFNGLCOMBINERSTAGEPARAMETERFVNVPROC) (GLenum stage, GLenum pname, GLfloat const * params); +typedef void (GLAPIENTRY * PFNGLCOMPILESHADERPROC) (GLuint shader); +typedef void (GLAPIENTRY * PFNGLCOMPILESHADERARBPROC) (GLhandleARB shaderObj); +typedef void (GLAPIENTRY * PFNGLCOMPRESSEDMULTITEXIMAGE1DEXTPROC) (GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void * bits); +typedef void (GLAPIENTRY * PFNGLCOMPRESSEDMULTITEXIMAGE2DEXTPROC) (GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void * bits); +typedef void (GLAPIENTRY * PFNGLCOMPRESSEDMULTITEXIMAGE3DEXTPROC) (GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void * bits); +typedef void (GLAPIENTRY * PFNGLCOMPRESSEDMULTITEXSUBIMAGE1DEXTPROC) (GLenum texunit, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void * bits); +typedef void (GLAPIENTRY * PFNGLCOMPRESSEDMULTITEXSUBIMAGE2DEXTPROC) (GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void * bits); +typedef void (GLAPIENTRY * PFNGLCOMPRESSEDMULTITEXSUBIMAGE3DEXTPROC) (GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void * bits); +typedef void (GLAPIENTRY * PFNGLCOMPRESSEDTEXIMAGE1DPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void * data); +typedef void (GLAPIENTRY * PFNGLCOMPRESSEDTEXIMAGE1DARBPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void * data); +typedef void (GLAPIENTRY * PFNGLCOMPRESSEDTEXIMAGE2DPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void * data); +typedef void (GLAPIENTRY * PFNGLCOMPRESSEDTEXIMAGE2DARBPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void * data); +typedef void (GLAPIENTRY * PFNGLCOMPRESSEDTEXIMAGE3DPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void * data); +typedef void (GLAPIENTRY * PFNGLCOMPRESSEDTEXIMAGE3DARBPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void * data); +typedef void (GLAPIENTRY * PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC) (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void * data); +typedef void (GLAPIENTRY * PFNGLCOMPRESSEDTEXSUBIMAGE1DARBPROC) (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void * data); +typedef void (GLAPIENTRY * PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void * data); +typedef void (GLAPIENTRY * PFNGLCOMPRESSEDTEXSUBIMAGE2DARBPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void * data); +typedef void (GLAPIENTRY * PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void * data); +typedef void (GLAPIENTRY * PFNGLCOMPRESSEDTEXSUBIMAGE3DARBPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void * data); +typedef void (GLAPIENTRY * PFNGLCOMPRESSEDTEXTUREIMAGE1DEXTPROC) (GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void * bits); +typedef void (GLAPIENTRY * PFNGLCOMPRESSEDTEXTUREIMAGE2DEXTPROC) (GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void * bits); +typedef void (GLAPIENTRY * PFNGLCOMPRESSEDTEXTUREIMAGE3DEXTPROC) (GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void * bits); +typedef void (GLAPIENTRY * PFNGLCOMPRESSEDTEXTURESUBIMAGE1DEXTPROC) (GLuint texture, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void * bits); +typedef void (GLAPIENTRY * PFNGLCOMPRESSEDTEXTURESUBIMAGE2DEXTPROC) (GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void * bits); +typedef void (GLAPIENTRY * PFNGLCOMPRESSEDTEXTURESUBIMAGE3DEXTPROC) (GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void * bits); +typedef void (GLAPIENTRY * PFNGLCONVOLUTIONFILTER1DPROC) (GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const void * image); +typedef void (GLAPIENTRY * PFNGLCONVOLUTIONFILTER2DPROC) (GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void * image); +typedef void (GLAPIENTRY * PFNGLCONVOLUTIONPARAMETERFPROC) (GLenum target, GLenum pname, GLfloat params); +typedef void (GLAPIENTRY * PFNGLCONVOLUTIONPARAMETERFVPROC) (GLenum target, GLenum pname, GLfloat const * params); +typedef void (GLAPIENTRY * PFNGLCONVOLUTIONPARAMETERIPROC) (GLenum target, GLenum pname, GLint params); +typedef void (GLAPIENTRY * PFNGLCONVOLUTIONPARAMETERIVPROC) (GLenum target, GLenum pname, GLint const * params); +typedef void (GLAPIENTRY * PFNGLCOPYCOLORSUBTABLEPROC) (GLenum target, GLsizei start, GLint x, GLint y, GLsizei width); +typedef void (GLAPIENTRY * PFNGLCOPYCOLORTABLEPROC) (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width); +typedef void (GLAPIENTRY * PFNGLCOPYCONVOLUTIONFILTER1DPROC) (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width); +typedef void (GLAPIENTRY * PFNGLCOPYCONVOLUTIONFILTER2DPROC) (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height); +typedef void (GLAPIENTRY * PFNGLCOPYIMAGESUBDATAPROC) (GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei srcWidth, GLsizei srcHeight, GLsizei srcDepth); +typedef void (GLAPIENTRY * PFNGLCOPYMULTITEXIMAGE1DEXTPROC) (GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border); +typedef void (GLAPIENTRY * PFNGLCOPYMULTITEXIMAGE2DEXTPROC) (GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); +typedef void (GLAPIENTRY * PFNGLCOPYMULTITEXSUBIMAGE1DEXTPROC) (GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width); +typedef void (GLAPIENTRY * PFNGLCOPYMULTITEXSUBIMAGE3DEXTPROC) (GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); +typedef void (GLAPIENTRY * PFNGLCOPYTEXSUBIMAGE3DPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); +typedef void (GLAPIENTRY * PFNGLCOPYTEXSUBIMAGE3DEXTPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); +typedef void (GLAPIENTRY * PFNGLCOPYTEXTUREIMAGE1DEXTPROC) (GLuint texture, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border); +typedef void (GLAPIENTRY * PFNGLCOPYTEXTUREIMAGE2DEXTPROC) (GLuint texture, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); +typedef void (GLAPIENTRY * PFNGLCOPYTEXTURESUBIMAGE1DEXTPROC) (GLuint texture, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width); +typedef void (GLAPIENTRY * PFNGLCOPYTEXTURESUBIMAGE2DEXTPROC) (GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); +typedef void (GLAPIENTRY * PFNGLCOPYTEXTURESUBIMAGE3DEXTPROC) (GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); +typedef GLuint (GLAPIENTRY * PFNGLCREATEPROGRAMPROC) (); +typedef GLhandleARB (GLAPIENTRY * PFNGLCREATEPROGRAMOBJECTARBPROC) (); +typedef GLuint (GLAPIENTRY * PFNGLCREATESHADERPROC) (GLenum type); +typedef GLhandleARB (GLAPIENTRY * PFNGLCREATESHADEROBJECTARBPROC) (GLenum shaderType); +typedef void (GLAPIENTRY * PFNGLDELETEBUFFERSPROC) (GLsizei n, GLuint const * buffers); +typedef void (GLAPIENTRY * PFNGLDELETEFENCESNVPROC) (GLsizei n, GLuint const * fences); +typedef void (GLAPIENTRY * PFNGLDELETEFRAMEBUFFERSPROC) (GLsizei n, GLuint const * framebuffers); +typedef void (GLAPIENTRY * PFNGLDELETEOBJECTARBPROC) (GLhandleARB obj); +typedef void (GLAPIENTRY * PFNGLDELETEOCCLUSIONQUERIESNVPROC) (GLsizei n, GLuint const * ids); +typedef void (GLAPIENTRY * PFNGLDELETEPROGRAMPROC) (GLuint program); +typedef void (GLAPIENTRY * PFNGLDELETEPROGRAMSARBPROC) (GLsizei n, GLuint const * programs); +typedef void (GLAPIENTRY * PFNGLDELETEPROGRAMSNVPROC) (GLsizei n, GLuint const * programs); +typedef void (GLAPIENTRY * PFNGLDELETEQUERIESPROC) (GLsizei n, GLuint const * ids); +typedef void (GLAPIENTRY * PFNGLDELETEQUERIESARBPROC) (GLsizei n, GLuint const * ids); +typedef void (GLAPIENTRY * PFNGLDELETERENDERBUFFERSPROC) (GLsizei n, GLuint const * renderbuffers); +typedef void (GLAPIENTRY * PFNGLDELETESAMPLERSPROC) (GLsizei count, GLuint const * samplers); +typedef void (GLAPIENTRY * PFNGLDELETESHADERPROC) (GLuint shader); +typedef void (GLAPIENTRY * PFNGLDELETETEXTURESEXTPROC) (GLsizei n, GLuint const * textures); +typedef void (GLAPIENTRY * PFNGLDELETEVERTEXARRAYSPROC) (GLsizei n, GLuint const * arrays); +typedef void (GLAPIENTRY * PFNGLDEPTHBOUNDSDNVPROC) (GLdouble zmin, GLdouble zmax); +typedef void (GLAPIENTRY * PFNGLDEPTHBOUNDSEXTPROC) (GLclampd zmin, GLclampd zmax); +typedef void (GLAPIENTRY * PFNGLDEPTHRANGEDNVPROC) (GLdouble zNear, GLdouble zFar); +typedef void (GLAPIENTRY * PFNGLDETACHOBJECTARBPROC) (GLhandleARB containerObj, GLhandleARB attachedObj); +typedef void (GLAPIENTRY * PFNGLDETACHSHADERPROC) (GLuint program, GLuint shader); +typedef void (GLAPIENTRY * PFNGLDISABLECLIENTSTATEINDEXEDEXTPROC) (GLenum array, GLuint index); +typedef void (GLAPIENTRY * PFNGLDISABLEIPROC) (GLenum target, GLuint index); +typedef void (GLAPIENTRY * PFNGLDISABLEINDEXEDEXTPROC) (GLenum target, GLuint index); +typedef void (GLAPIENTRY * PFNGLDISABLEVERTEXATTRIBARRAYPROC) (GLuint index); +typedef void (GLAPIENTRY * PFNGLDRAWARRAYSEXTPROC) (GLenum mode, GLint first, GLsizei count); +typedef void (GLAPIENTRY * PFNGLDRAWARRAYSINSTANCEDARBPROC) (GLenum mode, GLint first, GLsizei count, GLsizei primcount); +typedef void (GLAPIENTRY * PFNGLDRAWARRAYSINSTANCEDEXTPROC) (GLenum mode, GLint start, GLsizei count, GLsizei primcount); +typedef void (GLAPIENTRY * PFNGLDRAWBUFFERSPROC) (GLsizei n, GLenum const * bufs); +typedef void (GLAPIENTRY * PFNGLDRAWBUFFERSARBPROC) (GLsizei n, GLenum const * bufs); +typedef void (GLAPIENTRY * PFNGLDRAWBUFFERSATIPROC) (GLsizei n, GLenum const * bufs); +typedef void (GLAPIENTRY * PFNGLDRAWELEMENTSINSTANCEDARBPROC) (GLenum mode, GLsizei count, GLenum type, const void * indices, GLsizei primcount); +typedef void (GLAPIENTRY * PFNGLDRAWELEMENTSINSTANCEDEXTPROC) (GLenum mode, GLsizei count, GLenum type, const void * indices, GLsizei primcount); +typedef void (GLAPIENTRY * PFNGLDRAWRANGEELEMENTSEXTPROC) (GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void * indices); +typedef void (GLAPIENTRY * PFNGLEDGEFLAGPOINTEREXTPROC) (GLsizei stride, GLsizei count, GLboolean const * pointer); +typedef void (GLAPIENTRY * PFNGLENABLECLIENTSTATEINDEXEDEXTPROC) (GLenum array, GLuint index); +typedef void (GLAPIENTRY * PFNGLENABLEIPROC) (GLenum target, GLuint index); +typedef void (GLAPIENTRY * PFNGLENABLEINDEXEDEXTPROC) (GLenum target, GLuint index); +typedef void (GLAPIENTRY * PFNGLENDCONDITIONALRENDERPROC) (); +typedef void (GLAPIENTRY * PFNGLENDCONDITIONALRENDERNVPROC) (); +typedef void (GLAPIENTRY * PFNGLENDOCCLUSIONQUERYNVPROC) (); +typedef void (GLAPIENTRY * PFNGLENDQUERYPROC) (GLenum target); +typedef void (GLAPIENTRY * PFNGLENDQUERYARBPROC) (GLenum target); +typedef void (GLAPIENTRY * PFNGLENDTRANSFORMFEEDBACKPROC) (); +typedef void (GLAPIENTRY * PFNGLENDTRANSFORMFEEDBACKNVPROC) (); +typedef void (GLAPIENTRY * PFNGLEXECUTEPROGRAMNVPROC) (GLenum target, GLuint id, GLfloat const * params); +typedef void (GLAPIENTRY * PFNGLFINALCOMBINERINPUTNVPROC) (GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage); +typedef void (GLAPIENTRY * PFNGLFINISHFENCENVPROC) (GLuint fence); +typedef void (GLAPIENTRY * PFNGLFLUSHMAPPEDBUFFERRANGEPROC) (GLenum target, GLintptr offset, GLsizeiptr length); +typedef void (GLAPIENTRY * PFNGLFLUSHPIXELDATARANGENVPROC) (GLenum target); +typedef void (GLAPIENTRY * PFNGLFLUSHVERTEXARRAYRANGENVPROC) (); +typedef void (GLAPIENTRY * PFNGLFOGCOORDDPROC) (GLdouble coord); +typedef void (GLAPIENTRY * PFNGLFOGCOORDDEXTPROC) (GLdouble coord); +typedef void (GLAPIENTRY * PFNGLFOGCOORDDVPROC) (GLdouble const * coord); +typedef void (GLAPIENTRY * PFNGLFOGCOORDDVEXTPROC) (GLdouble const * coord); +typedef void (GLAPIENTRY * PFNGLFOGCOORDFPROC) (GLfloat coord); +typedef void (GLAPIENTRY * PFNGLFOGCOORDFEXTPROC) (GLfloat coord); +typedef void (GLAPIENTRY * PFNGLFOGCOORDFVPROC) (GLfloat const * coord); +typedef void (GLAPIENTRY * PFNGLFOGCOORDFVEXTPROC) (GLfloat const * coord); +typedef void (GLAPIENTRY * PFNGLFOGCOORDHNVPROC) (GLhalfNV fog); +typedef void (GLAPIENTRY * PFNGLFOGCOORDHVNVPROC) (GLhalfNV const * fog); +typedef void (GLAPIENTRY * PFNGLFOGCOORDPOINTERPROC) (GLenum type, GLsizei stride, const void * pointer); +typedef void (GLAPIENTRY * PFNGLFOGCOORDPOINTEREXTPROC) (GLenum type, GLsizei stride, const void * pointer); +typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERDRAWBUFFEREXTPROC) (GLuint framebuffer, GLenum mode); +typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERDRAWBUFFERSEXTPROC) (GLuint framebuffer, GLsizei n, GLenum const * bufs); +typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERREADBUFFEREXTPROC) (GLuint framebuffer, GLenum mode); +typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERRENDERBUFFERPROC) (GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer); +typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERTEXTUREPROC) (GLenum target, GLenum attachment, GLuint texture, GLint level); +typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERTEXTURE1DPROC) (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERTEXTURE1DEXTPROC) (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERTEXTURE2DPROC) (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERTEXTURE3DPROC) (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset); +typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERTEXTURE3DEXTPROC) (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset); +typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERTEXTUREARBPROC) (GLenum target, GLenum attachment, GLuint texture, GLint level); +typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERTEXTUREEXTPROC) (GLenum target, GLenum attachment, GLuint texture, GLint level); +typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERTEXTUREFACEARBPROC) (GLenum target, GLenum attachment, GLuint texture, GLint level, GLenum face); +typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERTEXTUREFACEEXTPROC) (GLenum target, GLenum attachment, GLuint texture, GLint level, GLenum face); +typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERTEXTURELAYERPROC) (GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer); +typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERTEXTURELAYERARBPROC) (GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer); +typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERTEXTURELAYEREXTPROC) (GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer); +typedef void (GLAPIENTRY * PFNGLGENBUFFERSPROC) (GLsizei n, GLuint * buffers); +typedef void (GLAPIENTRY * PFNGLGENBUFFERSARBPROC) (GLsizei n, GLuint * buffers); +typedef void (GLAPIENTRY * PFNGLGENERATEMIPMAPPROC) (GLenum target); +typedef void (GLAPIENTRY * PFNGLGENERATEMIPMAPEXTPROC) (GLenum target); +typedef void (GLAPIENTRY * PFNGLGENERATEMULTITEXMIPMAPEXTPROC) (GLenum texunit, GLenum target); +typedef void (GLAPIENTRY * PFNGLGENERATETEXTUREMIPMAPEXTPROC) (GLuint texture, GLenum target); +typedef void (GLAPIENTRY * PFNGLGENFENCESNVPROC) (GLsizei n, GLuint * fences); +typedef void (GLAPIENTRY * PFNGLGENFRAMEBUFFERSPROC) (GLsizei n, GLuint * framebuffers); +typedef void (GLAPIENTRY * PFNGLGENOCCLUSIONQUERIESNVPROC) (GLsizei n, GLuint * ids); +typedef void (GLAPIENTRY * PFNGLGENPROGRAMSARBPROC) (GLsizei n, GLuint * programs); +typedef void (GLAPIENTRY * PFNGLGENPROGRAMSNVPROC) (GLsizei n, GLuint * programs); +typedef void (GLAPIENTRY * PFNGLGENQUERIESPROC) (GLsizei n, GLuint * ids); +typedef void (GLAPIENTRY * PFNGLGENQUERIESARBPROC) (GLsizei n, GLuint * ids); +typedef void (GLAPIENTRY * PFNGLGENRENDERBUFFERSPROC) (GLsizei n, GLuint * renderbuffers); +typedef void (GLAPIENTRY * PFNGLGENSAMPLERSPROC) (GLsizei count, GLuint * samplers); +typedef void (GLAPIENTRY * PFNGLGENTEXTURESEXTPROC) (GLsizei n, GLuint * textures); +typedef void (GLAPIENTRY * PFNGLGENVERTEXARRAYSPROC) (GLsizei n, GLuint * arrays); +typedef void (GLAPIENTRY * PFNGLGETACTIVEATTRIBPROC) (GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLint * size, GLenum * type, GLchar * name); +typedef void (GLAPIENTRY * PFNGLGETACTIVEATTRIBARBPROC) (GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei * length, GLint * size, GLenum * type, GLcharARB * name); +typedef void (GLAPIENTRY * PFNGLGETACTIVEUNIFORMPROC) (GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLint * size, GLenum * type, GLchar * name); +typedef void (GLAPIENTRY * PFNGLGETACTIVEUNIFORMARBPROC) (GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei * length, GLint * size, GLenum * type, GLcharARB * name); +typedef void (GLAPIENTRY * PFNGLGETACTIVEVARYINGNVPROC) (GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLsizei * size, GLenum * type, GLchar * name); +typedef void (GLAPIENTRY * PFNGLGETATTACHEDOBJECTSARBPROC) (GLhandleARB containerObj, GLsizei maxCount, GLsizei * count, GLhandleARB * obj); +typedef void (GLAPIENTRY * PFNGLGETATTACHEDSHADERSPROC) (GLuint program, GLsizei maxCount, GLsizei * count, GLuint * shaders); +typedef GLint (GLAPIENTRY * PFNGLGETATTRIBLOCATIONPROC) (GLuint program, GLchar const * name); +typedef GLint (GLAPIENTRY * PFNGLGETATTRIBLOCATIONARBPROC) (GLhandleARB programObj, GLcharARB const * name); +typedef void (GLAPIENTRY * PFNGLGETBOOLEANI_VPROC) (GLenum target, GLuint index, GLboolean * data); +typedef void (GLAPIENTRY * PFNGLGETBOOLEANINDEXEDVEXTPROC) (GLenum target, GLuint index, GLboolean * data); +typedef void (GLAPIENTRY * PFNGLGETBUFFERPARAMETERIVPROC) (GLenum target, GLenum pname, GLint * params); +typedef void (GLAPIENTRY * PFNGLGETBUFFERPARAMETERIVARBPROC) (GLenum target, GLenum pname, GLint * params); +typedef void (GLAPIENTRY * PFNGLGETBUFFERPOINTERVPROC) (GLenum target, GLenum pname, void ** params); +typedef void (GLAPIENTRY * PFNGLGETBUFFERPOINTERVARBPROC) (GLenum target, GLenum pname, void ** params); +typedef void (GLAPIENTRY * PFNGLGETBUFFERSUBDATAPROC) (GLenum target, GLintptr offset, GLsizeiptr size, void * data); +typedef void (GLAPIENTRY * PFNGLGETBUFFERSUBDATAARBPROC) (GLenum target, GLintptrARB offset, GLsizeiptrARB size, void * data); +typedef void (GLAPIENTRY * PFNGLGETCOLORTABLEPROC) (GLenum target, GLenum format, GLenum type, void * table); +typedef void (GLAPIENTRY * PFNGLGETCOLORTABLEEXTPROC) (GLenum target, GLenum format, GLenum type, void * data); +typedef void (GLAPIENTRY * PFNGLGETCOLORTABLEPARAMETERFVPROC) (GLenum target, GLenum pname, GLfloat * params); +typedef void (GLAPIENTRY * PFNGLGETCOLORTABLEPARAMETERFVEXTPROC) (GLenum target, GLenum pname, GLfloat * params); +typedef void (GLAPIENTRY * PFNGLGETCOLORTABLEPARAMETERIVPROC) (GLenum target, GLenum pname, GLint * params); +typedef void (GLAPIENTRY * PFNGLGETCOLORTABLEPARAMETERIVEXTPROC) (GLenum target, GLenum pname, GLint * params); +typedef void (GLAPIENTRY * PFNGLGETCOMBINERINPUTPARAMETERFVNVPROC) (GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLfloat * params); +typedef void (GLAPIENTRY * PFNGLGETCOMBINERINPUTPARAMETERIVNVPROC) (GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLint * params); +typedef void (GLAPIENTRY * PFNGLGETCOMBINEROUTPUTPARAMETERFVNVPROC) (GLenum stage, GLenum portion, GLenum pname, GLfloat * params); +typedef void (GLAPIENTRY * PFNGLGETCOMBINEROUTPUTPARAMETERIVNVPROC) (GLenum stage, GLenum portion, GLenum pname, GLint * params); +typedef void (GLAPIENTRY * PFNGLGETCOMBINERSTAGEPARAMETERFVNVPROC) (GLenum stage, GLenum pname, GLfloat * params); +typedef void (GLAPIENTRY * PFNGLGETCOMPRESSEDMULTITEXIMAGEEXTPROC) (GLenum texunit, GLenum target, GLint lod, void * img); +typedef void (GLAPIENTRY * PFNGLGETCOMPRESSEDTEXIMAGEPROC) (GLenum target, GLint level, void * img); +typedef void (GLAPIENTRY * PFNGLGETCOMPRESSEDTEXIMAGEARBPROC) (GLenum target, GLint level, void * img); +typedef void (GLAPIENTRY * PFNGLGETCOMPRESSEDTEXTUREIMAGEEXTPROC) (GLuint texture, GLenum target, GLint lod, void * img); +typedef void (GLAPIENTRY * PFNGLGETCONVOLUTIONFILTERPROC) (GLenum target, GLenum format, GLenum type, void * image); +typedef void (GLAPIENTRY * PFNGLGETCONVOLUTIONPARAMETERFVPROC) (GLenum target, GLenum pname, GLfloat * params); +typedef void (GLAPIENTRY * PFNGLGETCONVOLUTIONPARAMETERIVPROC) (GLenum target, GLenum pname, GLint * params); +typedef void (GLAPIENTRY * PFNGLGETDOUBLEINDEXEDVEXTPROC) (GLenum target, GLuint index, GLdouble * data); +typedef void (GLAPIENTRY * PFNGLGETFENCEIVNVPROC) (GLuint fence, GLenum pname, GLint * params); +typedef void (GLAPIENTRY * PFNGLGETFINALCOMBINERINPUTPARAMETERFVNVPROC) (GLenum variable, GLenum pname, GLfloat * params); +typedef void (GLAPIENTRY * PFNGLGETFINALCOMBINERINPUTPARAMETERIVNVPROC) (GLenum variable, GLenum pname, GLint * params); +typedef void (GLAPIENTRY * PFNGLGETFLOATINDEXEDVEXTPROC) (GLenum target, GLuint index, GLfloat * data); +typedef GLint (GLAPIENTRY * PFNGLGETFRAGDATALOCATIONPROC) (GLuint program, GLchar const * name); +typedef GLint (GLAPIENTRY * PFNGLGETFRAGDATALOCATIONEXTPROC) (GLuint program, GLchar const * name); +typedef void (GLAPIENTRY * PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC) (GLenum target, GLenum attachment, GLenum pname, GLint * params); +typedef void (GLAPIENTRY * PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC) (GLenum target, GLenum attachment, GLenum pname, GLint * params); +typedef void (GLAPIENTRY * PFNGLGETFRAMEBUFFERPARAMETERIVEXTPROC) (GLuint framebuffer, GLenum pname, GLint * params); +typedef GLhandleARB (GLAPIENTRY * PFNGLGETHANDLEARBPROC) (GLenum pname); +typedef void (GLAPIENTRY * PFNGLGETHISTOGRAMPROC) (GLenum target, GLboolean reset, GLenum format, GLenum type, void * values); +typedef void (GLAPIENTRY * PFNGLGETHISTOGRAMPARAMETERFVPROC) (GLenum target, GLenum pname, GLfloat * params); +typedef void (GLAPIENTRY * PFNGLGETHISTOGRAMPARAMETERIVPROC) (GLenum target, GLenum pname, GLint * params); +typedef void (GLAPIENTRY * PFNGLGETINFOLOGARBPROC) (GLhandleARB obj, GLsizei maxLength, GLsizei * length, GLcharARB * infoLog); +typedef void (GLAPIENTRY * PFNGLGETINTEGERI_VPROC) (GLenum target, GLuint index, GLint * data); +typedef void (GLAPIENTRY * PFNGLGETINTEGERINDEXEDVEXTPROC) (GLenum target, GLuint index, GLint * data); +typedef void (GLAPIENTRY * PFNGLGETMINMAXPROC) (GLenum target, GLboolean reset, GLenum format, GLenum type, void * values); +typedef void (GLAPIENTRY * PFNGLGETMINMAXPARAMETERFVPROC) (GLenum target, GLenum pname, GLfloat * params); +typedef void (GLAPIENTRY * PFNGLGETMINMAXPARAMETERIVPROC) (GLenum target, GLenum pname, GLint * params); +typedef void (GLAPIENTRY * PFNGLGETMULTISAMPLEFVNVPROC) (GLenum pname, GLuint index, GLfloat * val); +typedef void (GLAPIENTRY * PFNGLGETMULTITEXENVFVEXTPROC) (GLenum texunit, GLenum target, GLenum pname, GLfloat * params); +typedef void (GLAPIENTRY * PFNGLGETMULTITEXENVIVEXTPROC) (GLenum texunit, GLenum target, GLenum pname, GLint * params); +typedef void (GLAPIENTRY * PFNGLGETMULTITEXGENDVEXTPROC) (GLenum texunit, GLenum coord, GLenum pname, GLdouble * params); +typedef void (GLAPIENTRY * PFNGLGETMULTITEXGENFVEXTPROC) (GLenum texunit, GLenum coord, GLenum pname, GLfloat * params); +typedef void (GLAPIENTRY * PFNGLGETMULTITEXGENIVEXTPROC) (GLenum texunit, GLenum coord, GLenum pname, GLint * params); +typedef void (GLAPIENTRY * PFNGLGETMULTITEXIMAGEEXTPROC) (GLenum texunit, GLenum target, GLint level, GLenum format, GLenum type, void * pixels); +typedef void (GLAPIENTRY * PFNGLGETMULTITEXLEVELPARAMETERFVEXTPROC) (GLenum texunit, GLenum target, GLint level, GLenum pname, GLfloat * params); +typedef void (GLAPIENTRY * PFNGLGETMULTITEXLEVELPARAMETERIVEXTPROC) (GLenum texunit, GLenum target, GLint level, GLenum pname, GLint * params); +typedef void (GLAPIENTRY * PFNGLGETMULTITEXPARAMETERFVEXTPROC) (GLenum texunit, GLenum target, GLenum pname, GLfloat * params); +typedef void (GLAPIENTRY * PFNGLGETMULTITEXPARAMETERIIVEXTPROC) (GLenum texunit, GLenum target, GLenum pname, GLint * params); +typedef void (GLAPIENTRY * PFNGLGETMULTITEXPARAMETERIUIVEXTPROC) (GLenum texunit, GLenum target, GLenum pname, GLuint * params); +typedef void (GLAPIENTRY * PFNGLGETMULTITEXPARAMETERIVEXTPROC) (GLenum texunit, GLenum target, GLenum pname, GLint * params); +typedef void (GLAPIENTRY * PFNGLGETNAMEDBUFFERPARAMETERIVEXTPROC) (GLuint buffer, GLenum pname, GLint * params); +typedef void (GLAPIENTRY * PFNGLGETNAMEDBUFFERPOINTERVEXTPROC) (GLuint buffer, GLenum pname, void ** params); +typedef void (GLAPIENTRY * PFNGLGETNAMEDBUFFERSUBDATAEXTPROC) (GLuint buffer, GLintptr offset, GLsizeiptr size, void * data); +typedef void (GLAPIENTRY * PFNGLGETNAMEDFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC) (GLuint framebuffer, GLenum attachment, GLenum pname, GLint * params); +typedef void (GLAPIENTRY * PFNGLGETNAMEDPROGRAMIVEXTPROC) (GLuint program, GLenum target, GLenum pname, GLint * params); +typedef void (GLAPIENTRY * PFNGLGETNAMEDPROGRAMLOCALPARAMETERDVEXTPROC) (GLuint program, GLenum target, GLuint index, GLdouble * params); +typedef void (GLAPIENTRY * PFNGLGETNAMEDPROGRAMLOCALPARAMETERFVEXTPROC) (GLuint program, GLenum target, GLuint index, GLfloat * params); +typedef void (GLAPIENTRY * PFNGLGETNAMEDPROGRAMLOCALPARAMETERIIVEXTPROC) (GLuint program, GLenum target, GLuint index, GLint * params); +typedef void (GLAPIENTRY * PFNGLGETNAMEDPROGRAMLOCALPARAMETERIUIVEXTPROC) (GLuint program, GLenum target, GLuint index, GLuint * params); +typedef void (GLAPIENTRY * PFNGLGETNAMEDPROGRAMSTRINGEXTPROC) (GLuint program, GLenum target, GLenum pname, void * string); +typedef void (GLAPIENTRY * PFNGLGETNAMEDRENDERBUFFERPARAMETERIVEXTPROC) (GLuint renderbuffer, GLenum pname, GLint * params); +typedef void (GLAPIENTRY * PFNGLGETOBJECTPARAMETERFVARBPROC) (GLhandleARB obj, GLenum pname, GLfloat * params); +typedef void (GLAPIENTRY * PFNGLGETOBJECTPARAMETERIVARBPROC) (GLhandleARB obj, GLenum pname, GLint * params); +typedef void (GLAPIENTRY * PFNGLGETOCCLUSIONQUERYIVNVPROC) (GLuint id, GLenum pname, GLint * params); +typedef void (GLAPIENTRY * PFNGLGETOCCLUSIONQUERYUIVNVPROC) (GLuint id, GLenum pname, GLuint * params); +typedef void (GLAPIENTRY * PFNGLGETPOINTERINDEXEDVEXTPROC) (GLenum target, GLuint index, void ** data); +typedef void (GLAPIENTRY * PFNGLGETPOINTERVEXTPROC) (GLenum pname, void ** params); +typedef void (GLAPIENTRY * PFNGLGETPROGRAMENVPARAMETERDVARBPROC) (GLenum target, GLuint index, GLdouble * params); +typedef void (GLAPIENTRY * PFNGLGETPROGRAMENVPARAMETERIIVNVPROC) (GLenum target, GLuint index, GLint * params); +typedef void (GLAPIENTRY * PFNGLGETPROGRAMENVPARAMETERIUIVNVPROC) (GLenum target, GLuint index, GLuint * params); +typedef void (GLAPIENTRY * PFNGLGETPROGRAMINFOLOGPROC) (GLuint program, GLsizei bufSize, GLsizei * length, GLchar * infoLog); +typedef void (GLAPIENTRY * PFNGLGETPROGRAMIVPROC) (GLuint program, GLenum pname, GLint * params); +typedef void (GLAPIENTRY * PFNGLGETPROGRAMIVNVPROC) (GLuint id, GLenum pname, GLint * params); +typedef void (GLAPIENTRY * PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC) (GLenum target, GLuint index, GLdouble * params); +typedef void (GLAPIENTRY * PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC) (GLenum target, GLuint index, GLfloat * params); +typedef void (GLAPIENTRY * PFNGLGETPROGRAMLOCALPARAMETERIIVNVPROC) (GLenum target, GLuint index, GLint * params); +typedef void (GLAPIENTRY * PFNGLGETPROGRAMLOCALPARAMETERIUIVNVPROC) (GLenum target, GLuint index, GLuint * params); +typedef void (GLAPIENTRY * PFNGLGETPROGRAMNAMEDPARAMETERDVNVPROC) (GLuint id, GLsizei len, GLubyte const * name, GLdouble * params); +typedef void (GLAPIENTRY * PFNGLGETPROGRAMNAMEDPARAMETERFVNVPROC) (GLuint id, GLsizei len, GLubyte const * name, GLfloat * params); +typedef void (GLAPIENTRY * PFNGLGETPROGRAMPARAMETERDVNVPROC) (GLenum target, GLuint index, GLenum pname, GLdouble * params); +typedef void (GLAPIENTRY * PFNGLGETPROGRAMPARAMETERFVNVPROC) (GLenum target, GLuint index, GLenum pname, GLfloat * params); +typedef void (GLAPIENTRY * PFNGLGETPROGRAMSTRINGARBPROC) (GLenum target, GLenum pname, void * string); +typedef void (GLAPIENTRY * PFNGLGETPROGRAMSTRINGNVPROC) (GLuint id, GLenum pname, GLubyte * program); +typedef void (GLAPIENTRY * PFNGLGETQUERYIVPROC) (GLenum target, GLenum pname, GLint * params); +typedef void (GLAPIENTRY * PFNGLGETQUERYIVARBPROC) (GLenum target, GLenum pname, GLint * params); +typedef void (GLAPIENTRY * PFNGLGETQUERYOBJECTI64VEXTPROC) (GLuint id, GLenum pname, GLint64 * params); +typedef void (GLAPIENTRY * PFNGLGETQUERYOBJECTIVPROC) (GLuint id, GLenum pname, GLint * params); +typedef void (GLAPIENTRY * PFNGLGETQUERYOBJECTIVARBPROC) (GLuint id, GLenum pname, GLint * params); +typedef void (GLAPIENTRY * PFNGLGETQUERYOBJECTUI64VPROC) (GLuint id, GLenum pname, GLuint64 * params); +typedef void (GLAPIENTRY * PFNGLGETQUERYOBJECTUI64VEXTPROC) (GLuint id, GLenum pname, GLuint64 * params); +typedef void (GLAPIENTRY * PFNGLGETQUERYOBJECTUIVPROC) (GLuint id, GLenum pname, GLuint * params); +typedef void (GLAPIENTRY * PFNGLGETQUERYOBJECTUIVARBPROC) (GLuint id, GLenum pname, GLuint * params); +typedef void (GLAPIENTRY * PFNGLGETRENDERBUFFERPARAMETERIVPROC) (GLenum target, GLenum pname, GLint * params); +typedef void (GLAPIENTRY * PFNGLGETRENDERBUFFERPARAMETERIVEXTPROC) (GLenum target, GLenum pname, GLint * params); +typedef void (GLAPIENTRY * PFNGLGETSEPARABLEFILTERPROC) (GLenum target, GLenum format, GLenum type, void * row, void * column, void * span); +typedef void (GLAPIENTRY * PFNGLGETSHADERINFOLOGPROC) (GLuint shader, GLsizei bufSize, GLsizei * length, GLchar * infoLog); +typedef void (GLAPIENTRY * PFNGLGETSHADERIVPROC) (GLuint shader, GLenum pname, GLint * params); +typedef void (GLAPIENTRY * PFNGLGETSHADERSOURCEPROC) (GLuint shader, GLsizei bufSize, GLsizei * length, GLchar * source); +typedef void (GLAPIENTRY * PFNGLGETSHADERSOURCEARBPROC) (GLhandleARB obj, GLsizei maxLength, GLsizei * length, GLcharARB * source); +typedef GLubyte const * (GLAPIENTRY * PFNGLGETSTRINGIPROC) (GLenum name, GLuint index); +typedef void (GLAPIENTRY * PFNGLGETTEXPARAMETERIIVPROC) (GLenum target, GLenum pname, GLint * params); +typedef void (GLAPIENTRY * PFNGLGETTEXPARAMETERIIVEXTPROC) (GLenum target, GLenum pname, GLint * params); +typedef void (GLAPIENTRY * PFNGLGETTEXPARAMETERIUIVPROC) (GLenum target, GLenum pname, GLuint * params); +typedef void (GLAPIENTRY * PFNGLGETTEXPARAMETERIUIVEXTPROC) (GLenum target, GLenum pname, GLuint * params); +typedef void (GLAPIENTRY * PFNGLGETTEXTURELEVELPARAMETERFVEXTPROC) (GLuint texture, GLenum target, GLint level, GLenum pname, GLfloat * params); +typedef void (GLAPIENTRY * PFNGLGETTEXTURELEVELPARAMETERIVEXTPROC) (GLuint texture, GLenum target, GLint level, GLenum pname, GLint * params); +typedef void (GLAPIENTRY * PFNGLGETTEXTUREPARAMETERFVEXTPROC) (GLuint texture, GLenum target, GLenum pname, GLfloat * params); +typedef void (GLAPIENTRY * PFNGLGETTEXTUREPARAMETERIIVEXTPROC) (GLuint texture, GLenum target, GLenum pname, GLint * params); +typedef void (GLAPIENTRY * PFNGLGETTEXTUREPARAMETERIUIVEXTPROC) (GLuint texture, GLenum target, GLenum pname, GLuint * params); +typedef void (GLAPIENTRY * PFNGLGETTEXTUREPARAMETERIVEXTPROC) (GLuint texture, GLenum target, GLenum pname, GLint * params); +typedef void (GLAPIENTRY * PFNGLGETTRACKMATRIXIVNVPROC) (GLenum target, GLuint address, GLenum pname, GLint * params); +typedef void (GLAPIENTRY * PFNGLGETTRANSFORMFEEDBACKVARYINGPROC) (GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLsizei * size, GLenum * type, GLchar * name); +typedef void (GLAPIENTRY * PFNGLGETTRANSFORMFEEDBACKVARYINGNVPROC) (GLuint program, GLuint index, GLint * location); +typedef GLint (GLAPIENTRY * PFNGLGETUNIFORMBUFFERSIZEEXTPROC) (GLuint program, GLint location); +typedef void (GLAPIENTRY * PFNGLGETUNIFORMFVPROC) (GLuint program, GLint location, GLfloat * params); +typedef void (GLAPIENTRY * PFNGLGETUNIFORMFVARBPROC) (GLhandleARB programObj, GLint location, GLfloat * params); +typedef void (GLAPIENTRY * PFNGLGETUNIFORMIVPROC) (GLuint program, GLint location, GLint * params); +typedef void (GLAPIENTRY * PFNGLGETUNIFORMIVARBPROC) (GLhandleARB programObj, GLint location, GLint * params); +typedef GLint (GLAPIENTRY * PFNGLGETUNIFORMLOCATIONPROC) (GLuint program, GLchar const * name); +typedef GLint (GLAPIENTRY * PFNGLGETUNIFORMLOCATIONARBPROC) (GLhandleARB programObj, GLcharARB const * name); +typedef GLintptr (GLAPIENTRY * PFNGLGETUNIFORMOFFSETEXTPROC) (GLuint program, GLint location); +typedef void (GLAPIENTRY * PFNGLGETUNIFORMUIVPROC) (GLuint program, GLint location, GLuint * params); +typedef void (GLAPIENTRY * PFNGLGETUNIFORMUIVEXTPROC) (GLuint program, GLint location, GLuint * params); +typedef GLint (GLAPIENTRY * PFNGLGETVARYINGLOCATIONNVPROC) (GLuint program, GLchar const * name); +typedef void (GLAPIENTRY * PFNGLGETVERTEXATTRIBDVPROC) (GLuint index, GLenum pname, GLdouble * params); +typedef void (GLAPIENTRY * PFNGLGETVERTEXATTRIBDVARBPROC) (GLuint index, GLenum pname, GLdouble * params); +typedef void (GLAPIENTRY * PFNGLGETVERTEXATTRIBDVNVPROC) (GLuint index, GLenum pname, GLdouble * params); +typedef void (GLAPIENTRY * PFNGLGETVERTEXATTRIBFVPROC) (GLuint index, GLenum pname, GLfloat * params); +typedef void (GLAPIENTRY * PFNGLGETVERTEXATTRIBFVARBPROC) (GLuint index, GLenum pname, GLfloat * params); +typedef void (GLAPIENTRY * PFNGLGETVERTEXATTRIBFVNVPROC) (GLuint index, GLenum pname, GLfloat * params); +typedef void (GLAPIENTRY * PFNGLGETVERTEXATTRIBIIVPROC) (GLuint index, GLenum pname, GLint * params); +typedef void (GLAPIENTRY * PFNGLGETVERTEXATTRIBIIVEXTPROC) (GLuint index, GLenum pname, GLint * params); +typedef void (GLAPIENTRY * PFNGLGETVERTEXATTRIBIUIVPROC) (GLuint index, GLenum pname, GLuint * params); +typedef void (GLAPIENTRY * PFNGLGETVERTEXATTRIBIUIVEXTPROC) (GLuint index, GLenum pname, GLuint * params); +typedef void (GLAPIENTRY * PFNGLGETVERTEXATTRIBIVPROC) (GLuint index, GLenum pname, GLint * params); +typedef void (GLAPIENTRY * PFNGLGETVERTEXATTRIBIVARBPROC) (GLuint index, GLenum pname, GLint * params); +typedef void (GLAPIENTRY * PFNGLGETVERTEXATTRIBIVNVPROC) (GLuint index, GLenum pname, GLint * params); +typedef void (GLAPIENTRY * PFNGLGETVERTEXATTRIBPOINTERVPROC) (GLuint index, GLenum pname, void ** pointer); +typedef void (GLAPIENTRY * PFNGLGETVERTEXATTRIBPOINTERVARBPROC) (GLuint index, GLenum pname, void ** pointer); +typedef void (GLAPIENTRY * PFNGLGETVERTEXATTRIBPOINTERVNVPROC) (GLuint index, GLenum pname, void ** pointer); +typedef void (GLAPIENTRY * PFNGLGETVIDEOI64VNVPROC) (GLuint video_slot, GLenum pname, GLint64EXT * params); +typedef void (GLAPIENTRY * PFNGLGETVIDEOIVNVPROC) (GLuint video_slot, GLenum pname, GLint * params); +typedef void (GLAPIENTRY * PFNGLGETVIDEOUI64VNVPROC) (GLuint video_slot, GLenum pname, GLuint64EXT * params); +typedef void (GLAPIENTRY * PFNGLGETVIDEOUIVNVPROC) (GLuint video_slot, GLenum pname, GLuint * params); +typedef void (GLAPIENTRY * PFNGLHISTOGRAMPROC) (GLenum target, GLsizei width, GLenum internalformat, GLboolean sink); +typedef void (GLAPIENTRY * PFNGLINDEXPOINTEREXTPROC) (GLenum type, GLsizei stride, GLsizei count, const void * pointer); +typedef GLboolean (GLAPIENTRY * PFNGLISBUFFERPROC) (GLuint buffer); +typedef GLboolean (GLAPIENTRY * PFNGLISENABLEDIPROC) (GLenum target, GLuint index); +typedef GLboolean (GLAPIENTRY * PFNGLISENABLEDINDEXEDEXTPROC) (GLenum target, GLuint index); +typedef GLboolean (GLAPIENTRY * PFNGLISFENCENVPROC) (GLuint fence); +typedef GLboolean (GLAPIENTRY * PFNGLISFRAMEBUFFERPROC) (GLuint framebuffer); +typedef GLboolean (GLAPIENTRY * PFNGLISFRAMEBUFFEREXTPROC) (GLuint framebuffer); +typedef GLboolean (GLAPIENTRY * PFNGLISOCCLUSIONQUERYNVPROC) (GLuint id); +typedef GLboolean (GLAPIENTRY * PFNGLISPROGRAMPROC) (GLuint program); +typedef GLboolean (GLAPIENTRY * PFNGLISPROGRAMARBPROC) (GLuint program); +typedef GLboolean (GLAPIENTRY * PFNGLISPROGRAMNVPROC) (GLuint id); +typedef GLboolean (GLAPIENTRY * PFNGLISQUERYPROC) (GLuint id); +typedef GLboolean (GLAPIENTRY * PFNGLISQUERYARBPROC) (GLuint id); +typedef GLboolean (GLAPIENTRY * PFNGLISRENDERBUFFERPROC) (GLuint renderbuffer); +typedef GLboolean (GLAPIENTRY * PFNGLISRENDERBUFFEREXTPROC) (GLuint renderbuffer); +typedef GLboolean (GLAPIENTRY * PFNGLISSHADERPROC) (GLuint shader); +typedef GLboolean (GLAPIENTRY * PFNGLISTEXTUREEXTPROC) (GLuint texture); +typedef GLboolean (GLAPIENTRY * PFNGLISVERTEXARRAYPROC) (GLuint array); +typedef void (GLAPIENTRY * PFNGLLINKPROGRAMPROC) (GLuint program); +typedef void (GLAPIENTRY * PFNGLLINKPROGRAMARBPROC) (GLhandleARB programObj); +typedef void (GLAPIENTRY * PFNGLLOADPROGRAMNVPROC) (GLenum target, GLuint id, GLsizei len, GLubyte const * program); +typedef void (GLAPIENTRY * PFNGLLOADTRANSPOSEMATRIXDPROC) (GLdouble const * m); +typedef void (GLAPIENTRY * PFNGLLOADTRANSPOSEMATRIXDARBPROC) (GLdouble const * m); +typedef void (GLAPIENTRY * PFNGLLOADTRANSPOSEMATRIXFARBPROC) (GLfloat const * m); +typedef void (GLAPIENTRY * PFNGLLOCKARRAYSEXTPROC) (GLint first, GLsizei count); +typedef void * (GLAPIENTRY * PFNGLMAPBUFFERPROC) (GLenum target, GLenum access); +typedef void * (GLAPIENTRY * PFNGLMAPBUFFERARBPROC) (GLenum target, GLenum access); +typedef void * (GLAPIENTRY * PFNGLMAPBUFFERRANGEPROC) (GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access); +typedef void (GLAPIENTRY * PFNGLMATRIXFRUSTUMEXTPROC) (GLenum mode, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); +typedef void (GLAPIENTRY * PFNGLMATRIXLOADDEXTPROC) (GLenum mode, GLdouble const * m); +typedef void (GLAPIENTRY * PFNGLMATRIXLOADFEXTPROC) (GLenum mode, GLfloat const * m); +typedef void (GLAPIENTRY * PFNGLMATRIXLOADIDENTITYEXTPROC) (GLenum mode); +typedef void (GLAPIENTRY * PFNGLMATRIXLOADTRANSPOSEDEXTPROC) (GLenum mode, GLdouble const * m); +typedef void (GLAPIENTRY * PFNGLMATRIXLOADTRANSPOSEFEXTPROC) (GLenum mode, GLfloat const * m); +typedef void (GLAPIENTRY * PFNGLMATRIXMULTDEXTPROC) (GLenum mode, GLdouble const * m); +typedef void (GLAPIENTRY * PFNGLMATRIXMULTFEXTPROC) (GLenum mode, GLfloat const * m); +typedef void (GLAPIENTRY * PFNGLMATRIXMULTTRANSPOSEDEXTPROC) (GLenum mode, GLdouble const * m); +typedef void (GLAPIENTRY * PFNGLMATRIXMULTTRANSPOSEFEXTPROC) (GLenum mode, GLfloat const * m); +typedef void (GLAPIENTRY * PFNGLMATRIXORTHOEXTPROC) (GLenum mode, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); +typedef void (GLAPIENTRY * PFNGLMATRIXPOPEXTPROC) (GLenum mode); +typedef void (GLAPIENTRY * PFNGLMATRIXPUSHEXTPROC) (GLenum mode); +typedef void (GLAPIENTRY * PFNGLMATRIXROTATEDEXTPROC) (GLenum mode, GLdouble angle, GLdouble x, GLdouble y, GLdouble z); +typedef void (GLAPIENTRY * PFNGLMATRIXROTATEFEXTPROC) (GLenum mode, GLfloat angle, GLfloat x, GLfloat y, GLfloat z); +typedef void (GLAPIENTRY * PFNGLMATRIXSCALEDEXTPROC) (GLenum mode, GLdouble x, GLdouble y, GLdouble z); +typedef void (GLAPIENTRY * PFNGLMATRIXSCALEFEXTPROC) (GLenum mode, GLfloat x, GLfloat y, GLfloat z); +typedef void (GLAPIENTRY * PFNGLMATRIXTRANSLATEDEXTPROC) (GLenum mode, GLdouble x, GLdouble y, GLdouble z); +typedef void (GLAPIENTRY * PFNGLMATRIXTRANSLATEFEXTPROC) (GLenum mode, GLfloat x, GLfloat y, GLfloat z); +typedef void (GLAPIENTRY * PFNGLMINMAXPROC) (GLenum target, GLenum internalformat, GLboolean sink); +typedef void (GLAPIENTRY * PFNGLMULTIDRAWARRAYSPROC) (GLenum mode, GLint const * first, GLsizei const * count, GLsizei drawcount); +typedef void (GLAPIENTRY * PFNGLMULTIDRAWARRAYSEXTPROC) (GLenum mode, GLint const * first, GLsizei const * count, GLsizei primcount); +typedef void (GLAPIENTRY * PFNGLMULTIDRAWELEMENTSPROC) (GLenum mode, GLsizei const * count, GLenum type, const void *const* indices, GLsizei drawcount); +typedef void (GLAPIENTRY * PFNGLMULTIDRAWELEMENTSEXTPROC) (GLenum mode, GLsizei const * count, GLenum type, const void *const* indices, GLsizei primcount); +typedef void (GLAPIENTRY * PFNGLMULTITEXBUFFEREXTPROC) (GLenum texunit, GLenum target, GLenum internalformat, GLuint buffer); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD1DPROC) (GLenum target, GLdouble s); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD1DARBPROC) (GLenum target, GLdouble s); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD1DVPROC) (GLenum target, GLdouble const * v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD1DVARBPROC) (GLenum target, GLdouble const * v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD1FPROC) (GLenum target, GLfloat s); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD1FARBPROC) (GLenum target, GLfloat s); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD1FVPROC) (GLenum target, GLfloat const * v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD1FVARBPROC) (GLenum target, GLfloat const * v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD1HNVPROC) (GLenum target, GLhalfNV s); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD1HVNVPROC) (GLenum target, GLhalfNV const * v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD1IPROC) (GLenum target, GLint s); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD1IARBPROC) (GLenum target, GLint s); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD1IVPROC) (GLenum target, GLint const * v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD1IVARBPROC) (GLenum target, GLint const * v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD1SPROC) (GLenum target, GLshort s); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD1SARBPROC) (GLenum target, GLshort s); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD1SVPROC) (GLenum target, GLshort const * v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD1SVARBPROC) (GLenum target, GLshort const * v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD2DPROC) (GLenum target, GLdouble s, GLdouble t); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD2DARBPROC) (GLenum target, GLdouble s, GLdouble t); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD2DVPROC) (GLenum target, GLdouble const * v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD2DVARBPROC) (GLenum target, GLdouble const * v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD2FARBPROC) (GLenum target, GLfloat s, GLfloat t); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD2FVARBPROC) (GLenum target, GLfloat const * v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD2HNVPROC) (GLenum target, GLhalfNV s, GLhalfNV t); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD2HVNVPROC) (GLenum target, GLhalfNV const * v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD2IPROC) (GLenum target, GLint s, GLint t); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD2IARBPROC) (GLenum target, GLint s, GLint t); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD2IVPROC) (GLenum target, GLint const * v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD2IVARBPROC) (GLenum target, GLint const * v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD2SPROC) (GLenum target, GLshort s, GLshort t); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD2SARBPROC) (GLenum target, GLshort s, GLshort t); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD2SVPROC) (GLenum target, GLshort const * v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD2SVARBPROC) (GLenum target, GLshort const * v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD3DPROC) (GLenum target, GLdouble s, GLdouble t, GLdouble r); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD3DARBPROC) (GLenum target, GLdouble s, GLdouble t, GLdouble r); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD3DVPROC) (GLenum target, GLdouble const * v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD3DVARBPROC) (GLenum target, GLdouble const * v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD3FPROC) (GLenum target, GLfloat s, GLfloat t, GLfloat r); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD3FARBPROC) (GLenum target, GLfloat s, GLfloat t, GLfloat r); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD3FVPROC) (GLenum target, GLfloat const * v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD3FVARBPROC) (GLenum target, GLfloat const * v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD3HNVPROC) (GLenum target, GLhalfNV s, GLhalfNV t, GLhalfNV r); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD3HVNVPROC) (GLenum target, GLhalfNV const * v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD3IPROC) (GLenum target, GLint s, GLint t, GLint r); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD3IARBPROC) (GLenum target, GLint s, GLint t, GLint r); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD3IVPROC) (GLenum target, GLint const * v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD3IVARBPROC) (GLenum target, GLint const * v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD3SPROC) (GLenum target, GLshort s, GLshort t, GLshort r); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD3SARBPROC) (GLenum target, GLshort s, GLshort t, GLshort r); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD3SVPROC) (GLenum target, GLshort const * v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD3SVARBPROC) (GLenum target, GLshort const * v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD4DPROC) (GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD4DARBPROC) (GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD4DVPROC) (GLenum target, GLdouble const * v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD4DVARBPROC) (GLenum target, GLdouble const * v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD4FPROC) (GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD4FARBPROC) (GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD4FVPROC) (GLenum target, GLfloat const * v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD4FVARBPROC) (GLenum target, GLfloat const * v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD4HNVPROC) (GLenum target, GLhalfNV s, GLhalfNV t, GLhalfNV r, GLhalfNV q); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD4HVNVPROC) (GLenum target, GLhalfNV const * v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD4IPROC) (GLenum target, GLint s, GLint t, GLint r, GLint q); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD4IARBPROC) (GLenum target, GLint s, GLint t, GLint r, GLint q); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD4IVPROC) (GLenum target, GLint const * v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD4IVARBPROC) (GLenum target, GLint const * v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD4SPROC) (GLenum target, GLshort s, GLshort t, GLshort r, GLshort q); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD4SARBPROC) (GLenum target, GLshort s, GLshort t, GLshort r, GLshort q); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD4SVPROC) (GLenum target, GLshort const * v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD4SVARBPROC) (GLenum target, GLshort const * v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORDPOINTEREXTPROC) (GLenum texunit, GLint size, GLenum type, GLsizei stride, const void * pointer); +typedef void (GLAPIENTRY * PFNGLMULTITEXENVFEXTPROC) (GLenum texunit, GLenum target, GLenum pname, GLfloat param); +typedef void (GLAPIENTRY * PFNGLMULTITEXENVFVEXTPROC) (GLenum texunit, GLenum target, GLenum pname, GLfloat const * params); +typedef void (GLAPIENTRY * PFNGLMULTITEXENVIEXTPROC) (GLenum texunit, GLenum target, GLenum pname, GLint param); +typedef void (GLAPIENTRY * PFNGLMULTITEXENVIVEXTPROC) (GLenum texunit, GLenum target, GLenum pname, GLint const * params); +typedef void (GLAPIENTRY * PFNGLMULTITEXGENDEXTPROC) (GLenum texunit, GLenum coord, GLenum pname, GLdouble param); +typedef void (GLAPIENTRY * PFNGLMULTITEXGENDVEXTPROC) (GLenum texunit, GLenum coord, GLenum pname, GLdouble const * params); +typedef void (GLAPIENTRY * PFNGLMULTITEXGENFEXTPROC) (GLenum texunit, GLenum coord, GLenum pname, GLfloat param); +typedef void (GLAPIENTRY * PFNGLMULTITEXGENFVEXTPROC) (GLenum texunit, GLenum coord, GLenum pname, GLfloat const * params); +typedef void (GLAPIENTRY * PFNGLMULTITEXGENIEXTPROC) (GLenum texunit, GLenum coord, GLenum pname, GLint param); +typedef void (GLAPIENTRY * PFNGLMULTITEXGENIVEXTPROC) (GLenum texunit, GLenum coord, GLenum pname, GLint const * params); +typedef void (GLAPIENTRY * PFNGLMULTITEXIMAGE1DEXTPROC) (GLenum texunit, GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void * pixels); +typedef void (GLAPIENTRY * PFNGLMULTITEXIMAGE2DEXTPROC) (GLenum texunit, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void * pixels); +typedef void (GLAPIENTRY * PFNGLMULTITEXIMAGE3DEXTPROC) (GLenum texunit, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void * pixels); +typedef void (GLAPIENTRY * PFNGLMULTITEXPARAMETERFEXTPROC) (GLenum texunit, GLenum target, GLenum pname, GLfloat param); +typedef void (GLAPIENTRY * PFNGLMULTITEXPARAMETERFVEXTPROC) (GLenum texunit, GLenum target, GLenum pname, GLfloat const * params); +typedef void (GLAPIENTRY * PFNGLMULTITEXPARAMETERIEXTPROC) (GLenum texunit, GLenum target, GLenum pname, GLint param); +typedef void (GLAPIENTRY * PFNGLMULTITEXPARAMETERIIVEXTPROC) (GLenum texunit, GLenum target, GLenum pname, GLint const * params); +typedef void (GLAPIENTRY * PFNGLMULTITEXPARAMETERIUIVEXTPROC) (GLenum texunit, GLenum target, GLenum pname, GLuint const * params); +typedef void (GLAPIENTRY * PFNGLMULTITEXPARAMETERIVEXTPROC) (GLenum texunit, GLenum target, GLenum pname, GLint const * params); +typedef void (GLAPIENTRY * PFNGLMULTITEXRENDERBUFFEREXTPROC) (GLenum texunit, GLenum target, GLuint renderbuffer); +typedef void (GLAPIENTRY * PFNGLMULTITEXSUBIMAGE1DEXTPROC) (GLenum texunit, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void * pixels); +typedef void (GLAPIENTRY * PFNGLMULTITEXSUBIMAGE2DEXTPROC) (GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void * pixels); +typedef void (GLAPIENTRY * PFNGLMULTITEXSUBIMAGE3DEXTPROC) (GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void * pixels); +typedef void (GLAPIENTRY * PFNGLMULTTRANSPOSEMATRIXDPROC) (GLdouble const * m); +typedef void (GLAPIENTRY * PFNGLMULTTRANSPOSEMATRIXDARBPROC) (GLdouble const * m); +typedef void (GLAPIENTRY * PFNGLMULTTRANSPOSEMATRIXFARBPROC) (GLfloat const * m); +typedef void (GLAPIENTRY * PFNGLNAMEDFRAMEBUFFERRENDERBUFFEREXTPROC) (GLuint framebuffer, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer); +typedef void (GLAPIENTRY * PFNGLNAMEDFRAMEBUFFERTEXTURE1DEXTPROC) (GLuint framebuffer, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +typedef void (GLAPIENTRY * PFNGLNAMEDFRAMEBUFFERTEXTURE2DEXTPROC) (GLuint framebuffer, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +typedef void (GLAPIENTRY * PFNGLNAMEDFRAMEBUFFERTEXTURE3DEXTPROC) (GLuint framebuffer, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset); +typedef void (GLAPIENTRY * PFNGLNAMEDFRAMEBUFFERTEXTUREEXTPROC) (GLuint framebuffer, GLenum attachment, GLuint texture, GLint level); +typedef void (GLAPIENTRY * PFNGLNAMEDFRAMEBUFFERTEXTUREFACEEXTPROC) (GLuint framebuffer, GLenum attachment, GLuint texture, GLint level, GLenum face); +typedef void (GLAPIENTRY * PFNGLNAMEDFRAMEBUFFERTEXTURELAYEREXTPROC) (GLuint framebuffer, GLenum attachment, GLuint texture, GLint level, GLint layer); +typedef void (GLAPIENTRY * PFNGLNAMEDPROGRAMLOCALPARAMETER4DEXTPROC) (GLuint program, GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +typedef void (GLAPIENTRY * PFNGLNAMEDPROGRAMLOCALPARAMETER4DVEXTPROC) (GLuint program, GLenum target, GLuint index, GLdouble const * params); +typedef void (GLAPIENTRY * PFNGLNAMEDPROGRAMLOCALPARAMETER4FEXTPROC) (GLuint program, GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +typedef void (GLAPIENTRY * PFNGLNAMEDPROGRAMLOCALPARAMETER4FVEXTPROC) (GLuint program, GLenum target, GLuint index, GLfloat const * params); +typedef void (GLAPIENTRY * PFNGLNAMEDPROGRAMLOCALPARAMETERI4IEXTPROC) (GLuint program, GLenum target, GLuint index, GLint x, GLint y, GLint z, GLint w); +typedef void (GLAPIENTRY * PFNGLNAMEDPROGRAMLOCALPARAMETERI4IVEXTPROC) (GLuint program, GLenum target, GLuint index, GLint const * params); +typedef void (GLAPIENTRY * PFNGLNAMEDPROGRAMLOCALPARAMETERI4UIEXTPROC) (GLuint program, GLenum target, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w); +typedef void (GLAPIENTRY * PFNGLNAMEDPROGRAMLOCALPARAMETERI4UIVEXTPROC) (GLuint program, GLenum target, GLuint index, GLuint const * params); +typedef void (GLAPIENTRY * PFNGLNAMEDPROGRAMLOCALPARAMETERS4FVEXTPROC) (GLuint program, GLenum target, GLuint index, GLsizei count, GLfloat const * params); +typedef void (GLAPIENTRY * PFNGLNAMEDPROGRAMLOCALPARAMETERSI4IVEXTPROC) (GLuint program, GLenum target, GLuint index, GLsizei count, GLint const * params); +typedef void (GLAPIENTRY * PFNGLNAMEDPROGRAMLOCALPARAMETERSI4UIVEXTPROC) (GLuint program, GLenum target, GLuint index, GLsizei count, GLuint const * params); +typedef void (GLAPIENTRY * PFNGLNAMEDPROGRAMSTRINGEXTPROC) (GLuint program, GLenum target, GLenum format, GLsizei len, const void * string); +typedef void (GLAPIENTRY * PFNGLNAMEDRENDERBUFFERSTORAGEEXTPROC) (GLuint renderbuffer, GLenum internalformat, GLsizei width, GLsizei height); +typedef void (GLAPIENTRY * PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLECOVERAGEEXTPROC) (GLuint renderbuffer, GLsizei coverageSamples, GLsizei colorSamples, GLenum internalformat, GLsizei width, GLsizei height); +typedef void (GLAPIENTRY * PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC) (GLuint renderbuffer, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height); +typedef void (GLAPIENTRY * PFNGLNORMAL3HNVPROC) (GLhalfNV nx, GLhalfNV ny, GLhalfNV nz); +typedef void (GLAPIENTRY * PFNGLNORMAL3HVNVPROC) (GLhalfNV const * v); +typedef void (GLAPIENTRY * PFNGLNORMALPOINTEREXTPROC) (GLenum type, GLsizei stride, GLsizei count, const void * pointer); +typedef void (GLAPIENTRY * PFNGLPIXELDATARANGENVPROC) (GLenum target, GLsizei length, const void * pointer); +typedef void (GLAPIENTRY * PFNGLPOINTPARAMETERFARBPROC) (GLenum pname, GLfloat param); +typedef void (GLAPIENTRY * PFNGLPOINTPARAMETERFEXTPROC) (GLenum pname, GLfloat param); +typedef void (GLAPIENTRY * PFNGLPOINTPARAMETERFVARBPROC) (GLenum pname, GLfloat const * params); +typedef void (GLAPIENTRY * PFNGLPOINTPARAMETERFVEXTPROC) (GLenum pname, GLfloat const * params); +typedef void (GLAPIENTRY * PFNGLPOINTPARAMETERINVPROC) (GLenum pname, GLint param); +typedef void (GLAPIENTRY * PFNGLPOINTPARAMETERIVPROC) (GLenum pname, GLint const * params); +typedef void (GLAPIENTRY * PFNGLPOINTPARAMETERIVNVPROC) (GLenum pname, GLint const * params); +typedef void (GLAPIENTRY * PFNGLPRESENTFRAMEDUALFILLNVPROC) (GLuint video_slot, GLuint64EXT minPresentTime, GLuint beginPresentTimeId, GLuint presentDurationId, GLenum type, GLenum target0, GLuint fill0, GLenum target1, GLuint fill1, GLenum target2, GLuint fill2, GLenum target3, GLuint fill3); +typedef void (GLAPIENTRY * PFNGLPRESENTFRAMEKEYEDNVPROC) (GLuint video_slot, GLuint64EXT minPresentTime, GLuint beginPresentTimeId, GLuint presentDurationId, GLenum type, GLenum target0, GLuint fill0, GLuint key0, GLenum target1, GLuint fill1, GLuint key1); +typedef void (GLAPIENTRY * PFNGLPRIMITIVERESTARTNVPROC) (); +typedef void (GLAPIENTRY * PFNGLPRIORITIZETEXTURESEXTPROC) (GLsizei n, GLuint const * textures, GLclampf const * priorities); +typedef void (GLAPIENTRY * PFNGLPROGRAMBUFFERPARAMETERSIIVNVPROC) (GLenum target, GLuint bindingIndex, GLuint wordIndex, GLsizei count, GLint const * params); +typedef void (GLAPIENTRY * PFNGLPROGRAMBUFFERPARAMETERSIUIVNVPROC) (GLenum target, GLuint bindingIndex, GLuint wordIndex, GLsizei count, GLuint const * params); +typedef void (GLAPIENTRY * PFNGLPROGRAMENVPARAMETER4DARBPROC) (GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +typedef void (GLAPIENTRY * PFNGLPROGRAMENVPARAMETER4DVARBPROC) (GLenum target, GLuint index, GLdouble const * params); +typedef void (GLAPIENTRY * PFNGLPROGRAMENVPARAMETERI4INVPROC) (GLenum target, GLuint index, GLint x, GLint y, GLint z, GLint w); +typedef void (GLAPIENTRY * PFNGLPROGRAMENVPARAMETERI4IVNVPROC) (GLenum target, GLuint index, GLint const * params); +typedef void (GLAPIENTRY * PFNGLPROGRAMENVPARAMETERI4UINVPROC) (GLenum target, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w); +typedef void (GLAPIENTRY * PFNGLPROGRAMENVPARAMETERI4UIVNVPROC) (GLenum target, GLuint index, GLuint const * params); +typedef void (GLAPIENTRY * PFNGLPROGRAMENVPARAMETERSI4IVNVPROC) (GLenum target, GLuint index, GLsizei count, GLint const * params); +typedef void (GLAPIENTRY * PFNGLPROGRAMENVPARAMETERSI4UIVNVPROC) (GLenum target, GLuint index, GLsizei count, GLuint const * params); +typedef void (GLAPIENTRY * PFNGLPROGRAMLOCALPARAMETER4DARBPROC) (GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +typedef void (GLAPIENTRY * PFNGLPROGRAMLOCALPARAMETER4DVARBPROC) (GLenum target, GLuint index, GLdouble const * params); +typedef void (GLAPIENTRY * PFNGLPROGRAMLOCALPARAMETERI4INVPROC) (GLenum target, GLuint index, GLint x, GLint y, GLint z, GLint w); +typedef void (GLAPIENTRY * PFNGLPROGRAMLOCALPARAMETERI4IVNVPROC) (GLenum target, GLuint index, GLint const * params); +typedef void (GLAPIENTRY * PFNGLPROGRAMLOCALPARAMETERI4UINVPROC) (GLenum target, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w); +typedef void (GLAPIENTRY * PFNGLPROGRAMLOCALPARAMETERI4UIVNVPROC) (GLenum target, GLuint index, GLuint const * params); +typedef void (GLAPIENTRY * PFNGLPROGRAMLOCALPARAMETERSI4IVNVPROC) (GLenum target, GLuint index, GLsizei count, GLint const * params); +typedef void (GLAPIENTRY * PFNGLPROGRAMLOCALPARAMETERSI4UIVNVPROC) (GLenum target, GLuint index, GLsizei count, GLuint const * params); +typedef void (GLAPIENTRY * PFNGLPROGRAMNAMEDPARAMETER4DNVPROC) (GLuint id, GLsizei len, GLubyte const * name, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +typedef void (GLAPIENTRY * PFNGLPROGRAMNAMEDPARAMETER4DVNVPROC) (GLuint id, GLsizei len, GLubyte const * name, GLdouble const * v); +typedef void (GLAPIENTRY * PFNGLPROGRAMNAMEDPARAMETER4FNVPROC) (GLuint id, GLsizei len, GLubyte const * name, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +typedef void (GLAPIENTRY * PFNGLPROGRAMNAMEDPARAMETER4FVNVPROC) (GLuint id, GLsizei len, GLubyte const * name, GLfloat const * v); +typedef void (GLAPIENTRY * PFNGLPROGRAMPARAMETER4DNVPROC) (GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +typedef void (GLAPIENTRY * PFNGLPROGRAMPARAMETER4DVNVPROC) (GLenum target, GLuint index, GLdouble const * v); +typedef void (GLAPIENTRY * PFNGLPROGRAMPARAMETER4FNVPROC) (GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +typedef void (GLAPIENTRY * PFNGLPROGRAMPARAMETER4FVNVPROC) (GLenum target, GLuint index, GLfloat const * v); +typedef void (GLAPIENTRY * PFNGLPROGRAMPARAMETERIARBPROC) (GLuint program, GLenum pname, GLint value); +typedef void (GLAPIENTRY * PFNGLPROGRAMPARAMETERIEXTPROC) (GLuint program, GLenum pname, GLint value); +typedef void (GLAPIENTRY * PFNGLPROGRAMPARAMETERS4DVNVPROC) (GLenum target, GLuint index, GLsizei count, GLdouble const * v); +typedef void (GLAPIENTRY * PFNGLPROGRAMPARAMETERS4FVNVPROC) (GLenum target, GLuint index, GLsizei count, GLfloat const * v); +typedef void (GLAPIENTRY * PFNGLPROGRAMSTRINGARBPROC) (GLenum target, GLenum format, GLsizei len, const void * string); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM1FEXTPROC) (GLuint program, GLint location, GLfloat v0); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM1FVEXTPROC) (GLuint program, GLint location, GLsizei count, GLfloat const * value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM1IEXTPROC) (GLuint program, GLint location, GLint v0); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM1IVEXTPROC) (GLuint program, GLint location, GLsizei count, GLint const * value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM1UIEXTPROC) (GLuint program, GLint location, GLuint v0); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM1UIVEXTPROC) (GLuint program, GLint location, GLsizei count, GLuint const * value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM2FEXTPROC) (GLuint program, GLint location, GLfloat v0, GLfloat v1); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM2FVEXTPROC) (GLuint program, GLint location, GLsizei count, GLfloat const * value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM2IEXTPROC) (GLuint program, GLint location, GLint v0, GLint v1); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM2IVEXTPROC) (GLuint program, GLint location, GLsizei count, GLint const * value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM2UIEXTPROC) (GLuint program, GLint location, GLuint v0, GLuint v1); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM2UIVEXTPROC) (GLuint program, GLint location, GLsizei count, GLuint const * value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM3FEXTPROC) (GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM3FVEXTPROC) (GLuint program, GLint location, GLsizei count, GLfloat const * value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM3IEXTPROC) (GLuint program, GLint location, GLint v0, GLint v1, GLint v2); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM3IVEXTPROC) (GLuint program, GLint location, GLsizei count, GLint const * value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM3UIEXTPROC) (GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM3UIVEXTPROC) (GLuint program, GLint location, GLsizei count, GLuint const * value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM4FEXTPROC) (GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM4FVEXTPROC) (GLuint program, GLint location, GLsizei count, GLfloat const * value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM4IEXTPROC) (GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM4IVEXTPROC) (GLuint program, GLint location, GLsizei count, GLint const * value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM4UIEXTPROC) (GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM4UIVEXTPROC) (GLuint program, GLint location, GLsizei count, GLuint const * value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORMMATRIX2FVEXTPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, GLfloat const * value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORMMATRIX2X3FVEXTPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, GLfloat const * value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORMMATRIX2X4FVEXTPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, GLfloat const * value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORMMATRIX3FVEXTPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, GLfloat const * value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORMMATRIX3X2FVEXTPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, GLfloat const * value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORMMATRIX3X4FVEXTPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, GLfloat const * value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORMMATRIX4FVEXTPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, GLfloat const * value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORMMATRIX4X2FVEXTPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, GLfloat const * value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORMMATRIX4X3FVEXTPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, GLfloat const * value); +typedef void (GLAPIENTRY * PFNGLPROGRAMVERTEXLIMITNVPROC) (GLenum target, GLint limit); +typedef void (GLAPIENTRY * PFNGLPUSHCLIENTATTRIBDEFAULTEXTPROC) (GLbitfield mask); +typedef void (GLAPIENTRY * PFNGLQUERYCOUNTERPROC) (GLuint id, GLenum target); +typedef void (GLAPIENTRY * PFNGLRENDERBUFFERSTORAGEPROC) (GLenum target, GLenum internalformat, GLsizei width, GLsizei height); +typedef void (GLAPIENTRY * PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC) (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height); +typedef void (GLAPIENTRY * PFNGLRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC) (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height); +typedef void (GLAPIENTRY * PFNGLREQUESTRESIDENTPROGRAMSNVPROC) (GLsizei n, GLuint const * programs); +typedef void (GLAPIENTRY * PFNGLRESETHISTOGRAMPROC) (GLenum target); +typedef void (GLAPIENTRY * PFNGLRESETMINMAXPROC) (GLenum target); +typedef void (GLAPIENTRY * PFNGLSAMPLECOVERAGEPROC) (GLfloat value, GLboolean invert); +typedef void (GLAPIENTRY * PFNGLSAMPLECOVERAGEARBPROC) (GLfloat value, GLboolean invert); +typedef void (GLAPIENTRY * PFNGLSAMPLEMASKINDEXEDNVPROC) (GLuint index, GLbitfield mask); +typedef void (GLAPIENTRY * PFNGLSAMPLERPARAMETERFPROC) (GLuint sampler, GLenum pname, GLfloat param); +typedef void (GLAPIENTRY * PFNGLSAMPLERPARAMETERFVPROC) (GLuint sampler, GLenum pname, GLfloat const * param); +typedef void (GLAPIENTRY * PFNGLSAMPLERPARAMETERIPROC) (GLuint sampler, GLenum pname, GLint param); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3BPROC) (GLbyte red, GLbyte green, GLbyte blue); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3BEXTPROC) (GLbyte red, GLbyte green, GLbyte blue); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3BVPROC) (GLbyte const * v); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3BVEXTPROC) (GLbyte const * v); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3DPROC) (GLdouble red, GLdouble green, GLdouble blue); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3DEXTPROC) (GLdouble red, GLdouble green, GLdouble blue); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3DVPROC) (GLdouble const * v); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3DVEXTPROC) (GLdouble const * v); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3FPROC) (GLfloat red, GLfloat green, GLfloat blue); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3FEXTPROC) (GLfloat red, GLfloat green, GLfloat blue); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3FVPROC) (GLfloat const * v); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3FVEXTPROC) (GLfloat const * v); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3HNVPROC) (GLhalfNV red, GLhalfNV green, GLhalfNV blue); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3HVNVPROC) (GLhalfNV const * v); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3IPROC) (GLint red, GLint green, GLint blue); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3IEXTPROC) (GLint red, GLint green, GLint blue); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3IVPROC) (GLint const * v); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3IVEXTPROC) (GLint const * v); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3SPROC) (GLshort red, GLshort green, GLshort blue); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3SEXTPROC) (GLshort red, GLshort green, GLshort blue); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3SVPROC) (GLshort const * v); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3SVEXTPROC) (GLshort const * v); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3UBPROC) (GLubyte red, GLubyte green, GLubyte blue); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3UBEXTPROC) (GLubyte red, GLubyte green, GLubyte blue); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3UBVPROC) (GLubyte const * v); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3UBVEXTPROC) (GLubyte const * v); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3UIPROC) (GLuint red, GLuint green, GLuint blue); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3UIEXTPROC) (GLuint red, GLuint green, GLuint blue); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3UIVPROC) (GLuint const * v); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3UIVEXTPROC) (GLuint const * v); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3USPROC) (GLushort red, GLushort green, GLushort blue); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3USEXTPROC) (GLushort red, GLushort green, GLushort blue); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3USVPROC) (GLushort const * v); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3USVEXTPROC) (GLushort const * v); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLORPOINTERPROC) (GLint size, GLenum type, GLsizei stride, const void * pointer); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLORPOINTEREXTPROC) (GLint size, GLenum type, GLsizei stride, const void * pointer); +typedef void (GLAPIENTRY * PFNGLSEPARABLEFILTER2DPROC) (GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void * row, const void * column); +typedef void (GLAPIENTRY * PFNGLSETFENCENVPROC) (GLuint fence, GLenum condition); +typedef void (GLAPIENTRY * PFNGLSHADERSOURCEPROC) (GLuint shader, GLsizei count, GLchar const *const* string, GLint const * length); +typedef void (GLAPIENTRY * PFNGLSHADERSOURCEARBPROC) (GLhandleARB shaderObj, GLsizei count, GLcharARB const ** string, GLint const * length); +typedef void (GLAPIENTRY * PFNGLSTENCILFUNCSEPARATEPROC) (GLenum face, GLenum func, GLint ref, GLuint mask); +typedef void (GLAPIENTRY * PFNGLSTENCILMASKSEPARATEPROC) (GLenum face, GLuint mask); +typedef void (GLAPIENTRY * PFNGLSTENCILOPSEPARATEPROC) (GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass); +typedef GLboolean (GLAPIENTRY * PFNGLTESTFENCENVPROC) (GLuint fence); +typedef void (GLAPIENTRY * PFNGLTEXBUFFERARBPROC) (GLenum target, GLenum internalformat, GLuint buffer); +typedef void (GLAPIENTRY * PFNGLTEXBUFFEREXTPROC) (GLenum target, GLenum internalformat, GLuint buffer); +typedef void (GLAPIENTRY * PFNGLTEXCOORD1HNVPROC) (GLhalfNV s); +typedef void (GLAPIENTRY * PFNGLTEXCOORD1HVNVPROC) (GLhalfNV const * v); +typedef void (GLAPIENTRY * PFNGLTEXCOORD2HNVPROC) (GLhalfNV s, GLhalfNV t); +typedef void (GLAPIENTRY * PFNGLTEXCOORD2HVNVPROC) (GLhalfNV const * v); +typedef void (GLAPIENTRY * PFNGLTEXCOORD3HNVPROC) (GLhalfNV s, GLhalfNV t, GLhalfNV r); +typedef void (GLAPIENTRY * PFNGLTEXCOORD3HVNVPROC) (GLhalfNV const * v); +typedef void (GLAPIENTRY * PFNGLTEXCOORD4HNVPROC) (GLhalfNV s, GLhalfNV t, GLhalfNV r, GLhalfNV q); +typedef void (GLAPIENTRY * PFNGLTEXCOORD4HVNVPROC) (GLhalfNV const * v); +typedef void (GLAPIENTRY * PFNGLTEXCOORDPOINTEREXTPROC) (GLint size, GLenum type, GLsizei stride, GLsizei count, const void * pointer); +typedef void (GLAPIENTRY * PFNGLTEXIMAGE3DPROC) (GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void * pixels); +typedef void (GLAPIENTRY * PFNGLTEXIMAGE3DEXTPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void * pixels); +typedef void (GLAPIENTRY * PFNGLTEXPARAMETERIIVPROC) (GLenum target, GLenum pname, GLint const * params); +typedef void (GLAPIENTRY * PFNGLTEXPARAMETERIIVEXTPROC) (GLenum target, GLenum pname, GLint const * params); +typedef void (GLAPIENTRY * PFNGLTEXPARAMETERIUIVPROC) (GLenum target, GLenum pname, GLuint const * params); +typedef void (GLAPIENTRY * PFNGLTEXPARAMETERIUIVEXTPROC) (GLenum target, GLenum pname, GLuint const * params); +typedef void (GLAPIENTRY * PFNGLTEXRENDERBUFFERNVPROC) (GLenum target, GLuint renderbuffer); +typedef void (GLAPIENTRY * PFNGLTEXSTORAGE2DPROC) (GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height); +typedef void (GLAPIENTRY * PFNGLTEXSUBIMAGE3DPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void * pixels); +typedef void (GLAPIENTRY * PFNGLTEXSUBIMAGE3DEXTPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void * pixels); +typedef void (GLAPIENTRY * PFNGLTEXTUREBARRIERNVPROC) (); +typedef void (GLAPIENTRY * PFNGLTEXTUREBUFFEREXTPROC) (GLuint texture, GLenum target, GLenum internalformat, GLuint buffer); +typedef void (GLAPIENTRY * PFNGLTEXTUREIMAGE1DEXTPROC) (GLuint texture, GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void * pixels); +typedef void (GLAPIENTRY * PFNGLTEXTUREIMAGE2DEXTPROC) (GLuint texture, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void * pixels); +typedef void (GLAPIENTRY * PFNGLTEXTUREIMAGE3DEXTPROC) (GLuint texture, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void * pixels); +typedef void (GLAPIENTRY * PFNGLTEXTUREPARAMETERFEXTPROC) (GLuint texture, GLenum target, GLenum pname, GLfloat param); +typedef void (GLAPIENTRY * PFNGLTEXTUREPARAMETERFVEXTPROC) (GLuint texture, GLenum target, GLenum pname, GLfloat const * params); +typedef void (GLAPIENTRY * PFNGLTEXTUREPARAMETERIEXTPROC) (GLuint texture, GLenum target, GLenum pname, GLint param); +typedef void (GLAPIENTRY * PFNGLTEXTUREPARAMETERIIVEXTPROC) (GLuint texture, GLenum target, GLenum pname, GLint const * params); +typedef void (GLAPIENTRY * PFNGLTEXTUREPARAMETERIUIVEXTPROC) (GLuint texture, GLenum target, GLenum pname, GLuint const * params); +typedef void (GLAPIENTRY * PFNGLTEXTUREPARAMETERIVEXTPROC) (GLuint texture, GLenum target, GLenum pname, GLint const * params); +typedef void (GLAPIENTRY * PFNGLTEXTURERENDERBUFFEREXTPROC) (GLuint texture, GLenum target, GLuint renderbuffer); +typedef void (GLAPIENTRY * PFNGLTEXTURESTORAGE2DEXTPROC) (GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height); +typedef void (GLAPIENTRY * PFNGLTEXTURESUBIMAGE1DEXTPROC) (GLuint texture, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void * pixels); +typedef void (GLAPIENTRY * PFNGLTEXTURESUBIMAGE2DEXTPROC) (GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void * pixels); +typedef void (GLAPIENTRY * PFNGLTEXTURESUBIMAGE3DEXTPROC) (GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void * pixels); +typedef void (GLAPIENTRY * PFNGLTRACKMATRIXNVPROC) (GLenum target, GLuint address, GLenum matrix, GLenum transform); +typedef void (GLAPIENTRY * PFNGLTRANSFORMFEEDBACKATTRIBSNVPROC) (GLsizei count, GLint const * attribs, GLenum bufferMode); +typedef void (GLAPIENTRY * PFNGLTRANSFORMFEEDBACKVARYINGSPROC) (GLuint program, GLsizei count, GLchar const *const* varyings, GLenum bufferMode); +typedef void (GLAPIENTRY * PFNGLTRANSFORMFEEDBACKVARYINGSNVPROC) (GLuint program, GLsizei count, GLint const * locations, GLenum bufferMode); +typedef void (GLAPIENTRY * PFNGLUNIFORM1FPROC) (GLint location, GLfloat v0); +typedef void (GLAPIENTRY * PFNGLUNIFORM1FARBPROC) (GLint location, GLfloat v0); +typedef void (GLAPIENTRY * PFNGLUNIFORM1FVPROC) (GLint location, GLsizei count, GLfloat const * value); +typedef void (GLAPIENTRY * PFNGLUNIFORM1FVARBPROC) (GLint location, GLsizei count, GLfloat const * value); +typedef void (GLAPIENTRY * PFNGLUNIFORM1IPROC) (GLint location, GLint v0); +typedef void (GLAPIENTRY * PFNGLUNIFORM1IARBPROC) (GLint location, GLint v0); +typedef void (GLAPIENTRY * PFNGLUNIFORM1IVPROC) (GLint location, GLsizei count, GLint const * value); +typedef void (GLAPIENTRY * PFNGLUNIFORM1IVARBPROC) (GLint location, GLsizei count, GLint const * value); +typedef void (GLAPIENTRY * PFNGLUNIFORM1UIPROC) (GLint location, GLuint v0); +typedef void (GLAPIENTRY * PFNGLUNIFORM1UIEXTPROC) (GLint location, GLuint v0); +typedef void (GLAPIENTRY * PFNGLUNIFORM1UIVPROC) (GLint location, GLsizei count, GLuint const * value); +typedef void (GLAPIENTRY * PFNGLUNIFORM1UIVEXTPROC) (GLint location, GLsizei count, GLuint const * value); +typedef void (GLAPIENTRY * PFNGLUNIFORM2FPROC) (GLint location, GLfloat v0, GLfloat v1); +typedef void (GLAPIENTRY * PFNGLUNIFORM2FARBPROC) (GLint location, GLfloat v0, GLfloat v1); +typedef void (GLAPIENTRY * PFNGLUNIFORM2FVPROC) (GLint location, GLsizei count, GLfloat const * value); +typedef void (GLAPIENTRY * PFNGLUNIFORM2FVARBPROC) (GLint location, GLsizei count, GLfloat const * value); +typedef void (GLAPIENTRY * PFNGLUNIFORM2IPROC) (GLint location, GLint v0, GLint v1); +typedef void (GLAPIENTRY * PFNGLUNIFORM2IARBPROC) (GLint location, GLint v0, GLint v1); +typedef void (GLAPIENTRY * PFNGLUNIFORM2IVPROC) (GLint location, GLsizei count, GLint const * value); +typedef void (GLAPIENTRY * PFNGLUNIFORM2IVARBPROC) (GLint location, GLsizei count, GLint const * value); +typedef void (GLAPIENTRY * PFNGLUNIFORM2UIPROC) (GLint location, GLuint v0, GLuint v1); +typedef void (GLAPIENTRY * PFNGLUNIFORM2UIEXTPROC) (GLint location, GLuint v0, GLuint v1); +typedef void (GLAPIENTRY * PFNGLUNIFORM2UIVPROC) (GLint location, GLsizei count, GLuint const * value); +typedef void (GLAPIENTRY * PFNGLUNIFORM2UIVEXTPROC) (GLint location, GLsizei count, GLuint const * value); +typedef void (GLAPIENTRY * PFNGLUNIFORM3FPROC) (GLint location, GLfloat v0, GLfloat v1, GLfloat v2); +typedef void (GLAPIENTRY * PFNGLUNIFORM3FARBPROC) (GLint location, GLfloat v0, GLfloat v1, GLfloat v2); +typedef void (GLAPIENTRY * PFNGLUNIFORM3FVPROC) (GLint location, GLsizei count, GLfloat const * value); +typedef void (GLAPIENTRY * PFNGLUNIFORM3FVARBPROC) (GLint location, GLsizei count, GLfloat const * value); +typedef void (GLAPIENTRY * PFNGLUNIFORM3IPROC) (GLint location, GLint v0, GLint v1, GLint v2); +typedef void (GLAPIENTRY * PFNGLUNIFORM3IARBPROC) (GLint location, GLint v0, GLint v1, GLint v2); +typedef void (GLAPIENTRY * PFNGLUNIFORM3IVPROC) (GLint location, GLsizei count, GLint const * value); +typedef void (GLAPIENTRY * PFNGLUNIFORM3IVARBPROC) (GLint location, GLsizei count, GLint const * value); +typedef void (GLAPIENTRY * PFNGLUNIFORM3UIPROC) (GLint location, GLuint v0, GLuint v1, GLuint v2); +typedef void (GLAPIENTRY * PFNGLUNIFORM3UIEXTPROC) (GLint location, GLuint v0, GLuint v1, GLuint v2); +typedef void (GLAPIENTRY * PFNGLUNIFORM3UIVPROC) (GLint location, GLsizei count, GLuint const * value); +typedef void (GLAPIENTRY * PFNGLUNIFORM3UIVEXTPROC) (GLint location, GLsizei count, GLuint const * value); +typedef void (GLAPIENTRY * PFNGLUNIFORM4FPROC) (GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); +typedef void (GLAPIENTRY * PFNGLUNIFORM4FARBPROC) (GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); +typedef void (GLAPIENTRY * PFNGLUNIFORM4FVPROC) (GLint location, GLsizei count, GLfloat const * value); +typedef void (GLAPIENTRY * PFNGLUNIFORM4FVARBPROC) (GLint location, GLsizei count, GLfloat const * value); +typedef void (GLAPIENTRY * PFNGLUNIFORM4IPROC) (GLint location, GLint v0, GLint v1, GLint v2, GLint v3); +typedef void (GLAPIENTRY * PFNGLUNIFORM4IARBPROC) (GLint location, GLint v0, GLint v1, GLint v2, GLint v3); +typedef void (GLAPIENTRY * PFNGLUNIFORM4IVPROC) (GLint location, GLsizei count, GLint const * value); +typedef void (GLAPIENTRY * PFNGLUNIFORM4IVARBPROC) (GLint location, GLsizei count, GLint const * value); +typedef void (GLAPIENTRY * PFNGLUNIFORM4UIPROC) (GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3); +typedef void (GLAPIENTRY * PFNGLUNIFORM4UIEXTPROC) (GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3); +typedef void (GLAPIENTRY * PFNGLUNIFORM4UIVPROC) (GLint location, GLsizei count, GLuint const * value); +typedef void (GLAPIENTRY * PFNGLUNIFORM4UIVEXTPROC) (GLint location, GLsizei count, GLuint const * value); +typedef void (GLAPIENTRY * PFNGLUNIFORMBUFFEREXTPROC) (GLuint program, GLint location, GLuint buffer); +typedef void (GLAPIENTRY * PFNGLUNIFORMMATRIX2FVPROC) (GLint location, GLsizei count, GLboolean transpose, GLfloat const * value); +typedef void (GLAPIENTRY * PFNGLUNIFORMMATRIX2FVARBPROC) (GLint location, GLsizei count, GLboolean transpose, GLfloat const * value); +typedef void (GLAPIENTRY * PFNGLUNIFORMMATRIX2X3FVPROC) (GLint location, GLsizei count, GLboolean transpose, GLfloat const * value); +typedef void (GLAPIENTRY * PFNGLUNIFORMMATRIX2X4FVPROC) (GLint location, GLsizei count, GLboolean transpose, GLfloat const * value); +typedef void (GLAPIENTRY * PFNGLUNIFORMMATRIX3FVPROC) (GLint location, GLsizei count, GLboolean transpose, GLfloat const * value); +typedef void (GLAPIENTRY * PFNGLUNIFORMMATRIX3FVARBPROC) (GLint location, GLsizei count, GLboolean transpose, GLfloat const * value); +typedef void (GLAPIENTRY * PFNGLUNIFORMMATRIX3X2FVPROC) (GLint location, GLsizei count, GLboolean transpose, GLfloat const * value); +typedef void (GLAPIENTRY * PFNGLUNIFORMMATRIX3X4FVPROC) (GLint location, GLsizei count, GLboolean transpose, GLfloat const * value); +typedef void (GLAPIENTRY * PFNGLUNIFORMMATRIX4FVPROC) (GLint location, GLsizei count, GLboolean transpose, GLfloat const * value); +typedef void (GLAPIENTRY * PFNGLUNIFORMMATRIX4FVARBPROC) (GLint location, GLsizei count, GLboolean transpose, GLfloat const * value); +typedef void (GLAPIENTRY * PFNGLUNIFORMMATRIX4X2FVPROC) (GLint location, GLsizei count, GLboolean transpose, GLfloat const * value); +typedef void (GLAPIENTRY * PFNGLUNIFORMMATRIX4X3FVPROC) (GLint location, GLsizei count, GLboolean transpose, GLfloat const * value); +typedef void (GLAPIENTRY * PFNGLUNLOCKARRAYSEXTPROC) (); +typedef GLboolean (GLAPIENTRY * PFNGLUNMAPBUFFERPROC) (GLenum target); +typedef GLboolean (GLAPIENTRY * PFNGLUNMAPBUFFERARBPROC) (GLenum target); +typedef void (GLAPIENTRY * PFNGLUSEPROGRAMOBJECTARBPROC) (GLhandleARB programObj); +typedef void (GLAPIENTRY * PFNGLVALIDATEPROGRAMPROC) (GLuint program); +typedef void (GLAPIENTRY * PFNGLVALIDATEPROGRAMARBPROC) (GLhandleARB programObj); +typedef void (GLAPIENTRY * PFNGLVERTEX2HNVPROC) (GLhalfNV x, GLhalfNV y); +typedef void (GLAPIENTRY * PFNGLVERTEX2HVNVPROC) (GLhalfNV const * v); +typedef void (GLAPIENTRY * PFNGLVERTEX3HNVPROC) (GLhalfNV x, GLhalfNV y, GLhalfNV z); +typedef void (GLAPIENTRY * PFNGLVERTEX3HVNVPROC) (GLhalfNV const * v); +typedef void (GLAPIENTRY * PFNGLVERTEX4HNVPROC) (GLhalfNV x, GLhalfNV y, GLhalfNV z, GLhalfNV w); +typedef void (GLAPIENTRY * PFNGLVERTEX4HVNVPROC) (GLhalfNV const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXARRAYRANGENVPROC) (GLsizei length, const void * pointer); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB1DPROC) (GLuint index, GLdouble x); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB1DARBPROC) (GLuint index, GLdouble x); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB1DNVPROC) (GLuint index, GLdouble x); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB1DVPROC) (GLuint index, GLdouble const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB1DVARBPROC) (GLuint index, GLdouble const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB1DVNVPROC) (GLuint index, GLdouble const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB1FPROC) (GLuint index, GLfloat x); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB1FARBPROC) (GLuint index, GLfloat x); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB1FNVPROC) (GLuint index, GLfloat x); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB1FVPROC) (GLuint index, GLfloat const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB1FVARBPROC) (GLuint index, GLfloat const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB1FVNVPROC) (GLuint index, GLfloat const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB1HNVPROC) (GLuint index, GLhalfNV x); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB1HVNVPROC) (GLuint index, GLhalfNV const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB1SPROC) (GLuint index, GLshort x); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB1SARBPROC) (GLuint index, GLshort x); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB1SNVPROC) (GLuint index, GLshort x); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB1SVPROC) (GLuint index, GLshort const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB1SVARBPROC) (GLuint index, GLshort const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB1SVNVPROC) (GLuint index, GLshort const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB2DPROC) (GLuint index, GLdouble x, GLdouble y); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB2DARBPROC) (GLuint index, GLdouble x, GLdouble y); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB2DNVPROC) (GLuint index, GLdouble x, GLdouble y); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB2DVPROC) (GLuint index, GLdouble const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB2DVARBPROC) (GLuint index, GLdouble const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB2DVNVPROC) (GLuint index, GLdouble const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB2FPROC) (GLuint index, GLfloat x, GLfloat y); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB2FARBPROC) (GLuint index, GLfloat x, GLfloat y); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB2FNVPROC) (GLuint index, GLfloat x, GLfloat y); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB2FVPROC) (GLuint index, GLfloat const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB2FVARBPROC) (GLuint index, GLfloat const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB2FVNVPROC) (GLuint index, GLfloat const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB2HNVPROC) (GLuint index, GLhalfNV x, GLhalfNV y); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB2HVNVPROC) (GLuint index, GLhalfNV const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB2SPROC) (GLuint index, GLshort x, GLshort y); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB2SARBPROC) (GLuint index, GLshort x, GLshort y); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB2SNVPROC) (GLuint index, GLshort x, GLshort y); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB2SVPROC) (GLuint index, GLshort const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB2SVARBPROC) (GLuint index, GLshort const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB2SVNVPROC) (GLuint index, GLshort const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB3DPROC) (GLuint index, GLdouble x, GLdouble y, GLdouble z); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB3DARBPROC) (GLuint index, GLdouble x, GLdouble y, GLdouble z); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB3DNVPROC) (GLuint index, GLdouble x, GLdouble y, GLdouble z); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB3DVPROC) (GLuint index, GLdouble const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB3DVARBPROC) (GLuint index, GLdouble const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB3DVNVPROC) (GLuint index, GLdouble const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB3FPROC) (GLuint index, GLfloat x, GLfloat y, GLfloat z); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB3FARBPROC) (GLuint index, GLfloat x, GLfloat y, GLfloat z); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB3FNVPROC) (GLuint index, GLfloat x, GLfloat y, GLfloat z); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB3FVPROC) (GLuint index, GLfloat const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB3FVARBPROC) (GLuint index, GLfloat const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB3FVNVPROC) (GLuint index, GLfloat const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB3HNVPROC) (GLuint index, GLhalfNV x, GLhalfNV y, GLhalfNV z); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB3HVNVPROC) (GLuint index, GLhalfNV const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB3SPROC) (GLuint index, GLshort x, GLshort y, GLshort z); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB3SARBPROC) (GLuint index, GLshort x, GLshort y, GLshort z); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB3SNVPROC) (GLuint index, GLshort x, GLshort y, GLshort z); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB3SVPROC) (GLuint index, GLshort const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB3SVARBPROC) (GLuint index, GLshort const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB3SVNVPROC) (GLuint index, GLshort const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4BVPROC) (GLuint index, GLbyte const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4BVARBPROC) (GLuint index, GLbyte const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4DPROC) (GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4DARBPROC) (GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4DNVPROC) (GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4DVPROC) (GLuint index, GLdouble const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4DVARBPROC) (GLuint index, GLdouble const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4DVNVPROC) (GLuint index, GLdouble const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4FPROC) (GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4FARBPROC) (GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4FNVPROC) (GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4FVPROC) (GLuint index, GLfloat const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4FVARBPROC) (GLuint index, GLfloat const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4FVNVPROC) (GLuint index, GLfloat const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4HNVPROC) (GLuint index, GLhalfNV x, GLhalfNV y, GLhalfNV z, GLhalfNV w); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4HVNVPROC) (GLuint index, GLhalfNV const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4IVPROC) (GLuint index, GLint const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4IVARBPROC) (GLuint index, GLint const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4NBVPROC) (GLuint index, GLbyte const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4NBVARBPROC) (GLuint index, GLbyte const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4NIVPROC) (GLuint index, GLint const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4NIVARBPROC) (GLuint index, GLint const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4NSVPROC) (GLuint index, GLshort const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4NSVARBPROC) (GLuint index, GLshort const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4NUBPROC) (GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4NUBARBPROC) (GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4NUBVPROC) (GLuint index, GLubyte const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4NUBVARBPROC) (GLuint index, GLubyte const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4NUIVPROC) (GLuint index, GLuint const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4NUIVARBPROC) (GLuint index, GLuint const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4NUSVPROC) (GLuint index, GLushort const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4NUSVARBPROC) (GLuint index, GLushort const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4SPROC) (GLuint index, GLshort x, GLshort y, GLshort z, GLshort w); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4SARBPROC) (GLuint index, GLshort x, GLshort y, GLshort z, GLshort w); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4SNVPROC) (GLuint index, GLshort x, GLshort y, GLshort z, GLshort w); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4SVPROC) (GLuint index, GLshort const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4SVARBPROC) (GLuint index, GLshort const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4SVNVPROC) (GLuint index, GLshort const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4UBNVPROC) (GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4UBVPROC) (GLuint index, GLubyte const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4UBVARBPROC) (GLuint index, GLubyte const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4UBVNVPROC) (GLuint index, GLubyte const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4UIVPROC) (GLuint index, GLuint const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4UIVARBPROC) (GLuint index, GLuint const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4USVPROC) (GLuint index, GLushort const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4USVARBPROC) (GLuint index, GLushort const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI1IPROC) (GLuint index, GLint x); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI1IEXTPROC) (GLuint index, GLint x); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI1IVPROC) (GLuint index, GLint const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI1IVEXTPROC) (GLuint index, GLint const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI1UIPROC) (GLuint index, GLuint x); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI1UIEXTPROC) (GLuint index, GLuint x); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI1UIVPROC) (GLuint index, GLuint const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI1UIVEXTPROC) (GLuint index, GLuint const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI2IPROC) (GLuint index, GLint x, GLint y); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI2IEXTPROC) (GLuint index, GLint x, GLint y); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI2IVPROC) (GLuint index, GLint const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI2IVEXTPROC) (GLuint index, GLint const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI2UIPROC) (GLuint index, GLuint x, GLuint y); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI2UIEXTPROC) (GLuint index, GLuint x, GLuint y); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI2UIVPROC) (GLuint index, GLuint const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI2UIVEXTPROC) (GLuint index, GLuint const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI3IPROC) (GLuint index, GLint x, GLint y, GLint z); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI3IEXTPROC) (GLuint index, GLint x, GLint y, GLint z); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI3IVPROC) (GLuint index, GLint const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI3IVEXTPROC) (GLuint index, GLint const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI3UIPROC) (GLuint index, GLuint x, GLuint y, GLuint z); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI3UIEXTPROC) (GLuint index, GLuint x, GLuint y, GLuint z); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI3UIVPROC) (GLuint index, GLuint const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI3UIVEXTPROC) (GLuint index, GLuint const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI4BVPROC) (GLuint index, GLbyte const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI4BVEXTPROC) (GLuint index, GLbyte const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI4IPROC) (GLuint index, GLint x, GLint y, GLint z, GLint w); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI4IEXTPROC) (GLuint index, GLint x, GLint y, GLint z, GLint w); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI4IVPROC) (GLuint index, GLint const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI4IVEXTPROC) (GLuint index, GLint const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI4SVPROC) (GLuint index, GLshort const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI4SVEXTPROC) (GLuint index, GLshort const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI4UBVPROC) (GLuint index, GLubyte const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI4UBVEXTPROC) (GLuint index, GLubyte const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI4UIPROC) (GLuint index, GLuint x, GLuint y, GLuint z, GLuint w); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI4UIEXTPROC) (GLuint index, GLuint x, GLuint y, GLuint z, GLuint w); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI4UIVPROC) (GLuint index, GLuint const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI4UIVEXTPROC) (GLuint index, GLuint const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI4USVPROC) (GLuint index, GLushort const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI4USVEXTPROC) (GLuint index, GLushort const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBIPOINTERPROC) (GLuint index, GLint size, GLenum type, GLsizei stride, const void * pointer); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBIPOINTEREXTPROC) (GLuint index, GLint size, GLenum type, GLsizei stride, const void * pointer); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBPOINTERPROC) (GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void * pointer); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBPOINTERNVPROC) (GLuint index, GLint fsize, GLenum type, GLsizei stride, const void * pointer); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBS1DVNVPROC) (GLuint index, GLsizei count, GLdouble const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBS1FVNVPROC) (GLuint index, GLsizei count, GLfloat const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBS1HVNVPROC) (GLuint index, GLsizei n, GLhalfNV const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBS1SVNVPROC) (GLuint index, GLsizei count, GLshort const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBS2DVNVPROC) (GLuint index, GLsizei count, GLdouble const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBS2FVNVPROC) (GLuint index, GLsizei count, GLfloat const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBS2HVNVPROC) (GLuint index, GLsizei n, GLhalfNV const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBS2SVNVPROC) (GLuint index, GLsizei count, GLshort const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBS3DVNVPROC) (GLuint index, GLsizei count, GLdouble const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBS3FVNVPROC) (GLuint index, GLsizei count, GLfloat const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBS3HVNVPROC) (GLuint index, GLsizei n, GLhalfNV const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBS3SVNVPROC) (GLuint index, GLsizei count, GLshort const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBS4DVNVPROC) (GLuint index, GLsizei count, GLdouble const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBS4FVNVPROC) (GLuint index, GLsizei count, GLfloat const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBS4HVNVPROC) (GLuint index, GLsizei n, GLhalfNV const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBS4SVNVPROC) (GLuint index, GLsizei count, GLshort const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBS4UBVNVPROC) (GLuint index, GLsizei count, GLubyte const * v); +typedef void (GLAPIENTRY * PFNGLVERTEXPOINTEREXTPROC) (GLint size, GLenum type, GLsizei stride, GLsizei count, const void * pointer); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS2DPROC) (GLdouble x, GLdouble y); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS2DARBPROC) (GLdouble x, GLdouble y); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS2DVPROC) (GLdouble const * v); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS2DVARBPROC) (GLdouble const * v); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS2FPROC) (GLfloat x, GLfloat y); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS2FARBPROC) (GLfloat x, GLfloat y); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS2FVPROC) (GLfloat const * v); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS2FVARBPROC) (GLfloat const * v); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS2IPROC) (GLint x, GLint y); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS2IARBPROC) (GLint x, GLint y); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS2IVPROC) (GLint const * v); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS2IVARBPROC) (GLint const * v); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS2SPROC) (GLshort x, GLshort y); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS2SARBPROC) (GLshort x, GLshort y); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS2SVPROC) (GLshort const * v); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS2SVARBPROC) (GLshort const * v); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS3DPROC) (GLdouble x, GLdouble y, GLdouble z); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS3DARBPROC) (GLdouble x, GLdouble y, GLdouble z); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS3DVPROC) (GLdouble const * v); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS3DVARBPROC) (GLdouble const * v); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS3FPROC) (GLfloat x, GLfloat y, GLfloat z); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS3FARBPROC) (GLfloat x, GLfloat y, GLfloat z); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS3FVPROC) (GLfloat const * v); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS3FVARBPROC) (GLfloat const * v); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS3IPROC) (GLint x, GLint y, GLint z); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS3IARBPROC) (GLint x, GLint y, GLint z); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS3IVPROC) (GLint const * v); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS3IVARBPROC) (GLint const * v); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS3SPROC) (GLshort x, GLshort y, GLshort z); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS3SARBPROC) (GLshort x, GLshort y, GLshort z); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS3SVPROC) (GLshort const * v); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS3SVARBPROC) (GLshort const * v); +typedef void * (GLAPIENTRY * PFNWGLALLOCATEMEMORYNVPROC) (GLsizei size, GLfloat readfreq, GLfloat writefreq, GLfloat priority); +typedef BOOL (GLAPIENTRY * PFNWGLBINDSWAPBARRIERNVPROC) (GLuint group, GLuint barrier); +typedef BOOL (GLAPIENTRY * PFNWGLBINDTEXIMAGEARBPROC) (HPBUFFERARB hPbuffer, int iBuffer); +typedef BOOL (GLAPIENTRY * PFNWGLBINDVIDEOIMAGENVPROC) (HPVIDEODEV hVideoDevice, HPBUFFERARB hPbuffer, int iVideoBuffer); +typedef BOOL (GLAPIENTRY * PFNWGLCHOOSEPIXELFORMATARBPROC) (HDC hdc, const int * piAttribIList, FLOAT const * pfAttribFList, UINT nMaxFormats, int * piFormats, UINT * nNumFormats); +typedef HANDLE (GLAPIENTRY * PFNWGLCREATEBUFFERREGIONARBPROC) (HDC hDC, int iLayerPlane, UINT uType); +typedef HGLRC (GLAPIENTRY * PFNWGLCREATECONTEXTATTRIBSARBPROC) (HDC hDC, HGLRC hShareContext, const int * attribList); +typedef HPBUFFERARB (GLAPIENTRY * PFNWGLCREATEPBUFFERARBPROC) (HDC hDC, int iPixelFormat, int iWidth, int iHeight, const int * piAttribList); +typedef VOID (GLAPIENTRY * PFNWGLDELETEBUFFERREGIONARBPROC) (HANDLE hRegion); +typedef BOOL (GLAPIENTRY * PFNWGLDESTROYPBUFFERARBPROC) (HPBUFFERARB hPbuffer); +typedef BOOL (GLAPIENTRY * PFNWGLDXCLOSEDEVICENVPROC) (HANDLE hDevice); +typedef BOOL (GLAPIENTRY * PFNWGLDXLOCKOBJECTSNVPROC) (HANDLE hDevice, GLint count, HANDLE * hObjects); +typedef HANDLE (GLAPIENTRY * PFNWGLDXOPENDEVICENVPROC) (void * dxDevice); +typedef HANDLE (GLAPIENTRY * PFNWGLDXREGISTEROBJECTNVPROC) (HANDLE hDevice, void * dxObject, GLuint name, GLenum type, GLenum access); +typedef BOOL (GLAPIENTRY * PFNWGLDXSETRESOURCESHAREHANDLENVPROC) (void * dxObject, HANDLE shareHandle); +typedef BOOL (GLAPIENTRY * PFNWGLDXUNLOCKOBJECTSNVPROC) (HANDLE hDevice, GLint count, HANDLE * hObjects); +typedef BOOL (GLAPIENTRY * PFNWGLDXUNREGISTEROBJECTNVPROC) (HANDLE hDevice, HANDLE hObject); +typedef void (GLAPIENTRY * PFNWGLFREEMEMORYNVPROC) (void * pointer); +typedef HGLRC (GLAPIENTRY * PFNWGLGETCURRENTCONTEXTPROC) (); +typedef HDC (GLAPIENTRY * PFNWGLGETCURRENTREADDCARBPROC) (); +typedef const char * (GLAPIENTRY * PFNWGLGETEXTENSIONSSTRINGARBPROC) (HDC hdc); +typedef const char * (GLAPIENTRY * PFNWGLGETEXTENSIONSSTRINGEXTPROC) (); +typedef HDC (GLAPIENTRY * PFNWGLGETPBUFFERDCARBPROC) (HPBUFFERARB hPbuffer); +typedef BOOL (GLAPIENTRY * PFNWGLGETPIXELFORMATATTRIBFVARBPROC) (HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, const int * piAttributes, FLOAT * pfValues); +typedef BOOL (GLAPIENTRY * PFNWGLGETPIXELFORMATATTRIBIVARBPROC) (HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, const int * piAttributes, int * piValues); +typedef PROC (GLAPIENTRY * PFNWGLGETPROCADDRESSPROC) (LPCSTR lpszProc); +typedef int (GLAPIENTRY * PFNWGLGETSWAPINTERVALEXTPROC) (); +typedef BOOL (GLAPIENTRY * PFNWGLGETVIDEODEVICENVPROC) (HDC hDC, int numDevices, HPVIDEODEV * hVideoDevice); +typedef BOOL (GLAPIENTRY * PFNWGLGETVIDEOINFONVPROC) (HPVIDEODEV hpVideoDevice, unsigned long * pulCounterOutputPbuffer, unsigned long * pulCounterOutputVideo); +typedef BOOL (GLAPIENTRY * PFNWGLJOINSWAPGROUPNVPROC) (HDC hDC, GLuint group); +typedef BOOL (GLAPIENTRY * PFNWGLMAKECONTEXTCURRENTARBPROC) (HDC hDrawDC, HDC hReadDC, HGLRC hglrc); +typedef BOOL (GLAPIENTRY * PFNWGLQUERYFRAMECOUNTNVPROC) (HDC hDC, GLuint * count); +typedef BOOL (GLAPIENTRY * PFNWGLQUERYMAXSWAPGROUPSNVPROC) (HDC hDC, GLuint * maxGroups, GLuint * maxBarriers); +typedef BOOL (GLAPIENTRY * PFNWGLQUERYPBUFFERARBPROC) (HPBUFFERARB hPbuffer, int iAttribute, int * piValue); +typedef BOOL (GLAPIENTRY * PFNWGLQUERYSWAPGROUPNVPROC) (HDC hDC, GLuint * group, GLuint * barrier); +typedef int (GLAPIENTRY * PFNWGLRELEASEPBUFFERDCARBPROC) (HPBUFFERARB hPbuffer, HDC hDC); +typedef BOOL (GLAPIENTRY * PFNWGLRELEASETEXIMAGEARBPROC) (HPBUFFERARB hPbuffer, int iBuffer); +typedef BOOL (GLAPIENTRY * PFNWGLRELEASEVIDEODEVICENVPROC) (HPVIDEODEV hVideoDevice); +typedef BOOL (GLAPIENTRY * PFNWGLRELEASEVIDEOIMAGENVPROC) (HPBUFFERARB hPbuffer, int iVideoBuffer); +typedef BOOL (GLAPIENTRY * PFNWGLRESETFRAMECOUNTNVPROC) (HDC hDC); +typedef BOOL (GLAPIENTRY * PFNWGLRESTOREBUFFERREGIONARBPROC) (HANDLE hRegion, int x, int y, int width, int height, int xSrc, int ySrc); +typedef BOOL (GLAPIENTRY * PFNWGLSAVEBUFFERREGIONARBPROC) (HANDLE hRegion, int x, int y, int width, int height); +typedef BOOL (GLAPIENTRY * PFNWGLSENDPBUFFERTOVIDEONVPROC) (HPBUFFERARB hPbuffer, int iBufferType, unsigned long * pulCounterPbuffer, BOOL bBlock); +typedef BOOL (GLAPIENTRY * PFNWGLSETPBUFFERATTRIBARBPROC) (HPBUFFERARB hPbuffer, const int * piAttribList); +typedef BOOL (GLAPIENTRY * PFNWGLSWAPINTERVALEXTPROC) (int interval); + +typedef void (GLAPIENTRY * PFNGLFINISHGLUTPROC) (); +typedef void (GLAPIENTRY * PFNGLVIEWPORTGLUTPROC) (GLint x, GLint y, GLsizei width, GLsizei height); +typedef BOOL (GLAPIENTRY * PFNWGLDELETECONTEXTGLUTPROC) (HGLRC oldContext); +typedef HGLRC (GLAPIENTRY * PFNWGLGETCURRENTCONTEXTGLUTPROC) (); +typedef HDC (GLAPIENTRY * PFNWGLGETCURRENTDCGLUTPROC) (); +typedef PROC (GLAPIENTRY * PFNWGLGETPROCADDRESSGLUTPROC) (LPCSTR lpszProc); +typedef BOOL (GLAPIENTRY * PFNWGLMAKECURRENTGLUTPROC) (HDC hDc, HGLRC newContext); + +#define GLBLENDFUNCDLL 0 +#define GLCOLORMASKDLL 1 +#define GLDELETETEXTURESDLL 2 +#define GLDEPTHMASKDLL 3 +#define GLFINISHDLL 4 +#define GLGENTEXTURESDLL 5 +#define GLSCISSORDLL 6 +#define GLVIEWPORTDLL 7 +#define WGLGETPROCADDRESSDLL 8 + +#define GLACTIVESTENCILFACEEXT 0 +#define GLACTIVETEXTUREARB 1 +#define GLACTIVEVARYINGNV 2 +#define GLAREPROGRAMSRESIDENTNV 3 +#define GLARETEXTURESRESIDENTEXT 4 +#define GLARRAYELEMENTEXT 5 +#define GLATTACHOBJECTARB 6 +#define GLATTACHSHADER 7 +#define GLBEGINCONDITIONALRENDER 8 +#define GLBEGINCONDITIONALRENDERNV 9 +#define GLBEGINOCCLUSIONQUERYNV 10 +#define GLBEGINQUERY 11 +#define GLBEGINQUERYARB 12 +#define GLBEGINTRANSFORMFEEDBACK 13 +#define GLBEGINTRANSFORMFEEDBACKNV 14 +#define GLBINDATTRIBLOCATION 15 +#define GLBINDATTRIBLOCATIONARB 16 +#define GLBINDBUFFER 17 +#define GLBINDBUFFERBASE 18 +#define GLBINDBUFFEROFFSETNV 19 +#define GLBINDBUFFERRANGE 20 +#define GLBINDBUFFERRANGENV 21 +#define GLBINDFRAGDATALOCATION 22 +#define GLBINDFRAGDATALOCATIONEXT 23 +#define GLBINDFRAMEBUFFER 24 +#define GLBINDPROGRAMARB 25 +#define GLBINDPROGRAMNV 26 +#define GLBINDRENDERBUFFER 27 +#define GLBINDSAMPLER 28 +#define GLBINDTEXTUREEXT 29 +#define GLBINDVERTEXARRAY 30 +#define GLBLENDCOLOR 31 +#define GLBLENDCOLOREXT 32 +#define GLBLENDEQUATION 33 +#define GLBLENDEQUATIONEXT 34 +#define GLBLENDEQUATIONSEPARATE 35 +#define GLBLENDEQUATIONSEPARATEEXT 36 +#define GLBLENDFUNCSEPARATE 37 +#define GLBLENDFUNCSEPARATEEXT 38 +#define GLBLITFRAMEBUFFER 39 +#define GLBLITFRAMEBUFFEREXT 40 +#define GLBUFFERDATA 41 +#define GLBUFFERSUBDATA 42 +#define GLBUFFERSUBDATAARB 43 +#define GLCHECKFRAMEBUFFERSTATUS 44 +#define GLCHECKFRAMEBUFFERSTATUSEXT 45 +#define GLCHECKNAMEDFRAMEBUFFERSTATUSEXT 46 +#define GLCLEARBUFFERFI 47 +#define GLCLEARBUFFERFV 48 +#define GLCLEARBUFFERIV 49 +#define GLCLEARBUFFERUIV 50 +#define GLCLEARCOLORIIEXT 51 +#define GLCLEARCOLORIUIEXT 52 +#define GLCLEARDEPTHDNV 53 +#define GLCLIENTACTIVETEXTUREARB 54 +#define GLCLIENTATTRIBDEFAULTEXT 55 +#define GLCOLOR3HNV 56 +#define GLCOLOR3HVNV 57 +#define GLCOLOR4HNV 58 +#define GLCOLOR4HVNV 59 +#define GLCOLORMASKI 60 +#define GLCOLORMASKINDEXEDEXT 61 +#define GLCOLORPOINTEREXT 62 +#define GLCOLORSUBTABLE 63 +#define GLCOLORSUBTABLEEXT 64 +#define GLCOLORTABLE 65 +#define GLCOLORTABLEEXT 66 +#define GLCOLORTABLEPARAMETERFV 67 +#define GLCOLORTABLEPARAMETERIV 68 +#define GLCOMBINERINPUTNV 69 +#define GLCOMBINEROUTPUTNV 70 +#define GLCOMBINERPARAMETERFNV 71 +#define GLCOMBINERPARAMETERFVNV 72 +#define GLCOMBINERPARAMETERINV 73 +#define GLCOMBINERPARAMETERIVNV 74 +#define GLCOMBINERSTAGEPARAMETERFVNV 75 +#define GLCOMPILESHADER 76 +#define GLCOMPILESHADERARB 77 +#define GLCOMPRESSEDMULTITEXIMAGE1DEXT 78 +#define GLCOMPRESSEDMULTITEXIMAGE2DEXT 79 +#define GLCOMPRESSEDMULTITEXIMAGE3DEXT 80 +#define GLCOMPRESSEDMULTITEXSUBIMAGE1DEXT 81 +#define GLCOMPRESSEDMULTITEXSUBIMAGE2DEXT 82 +#define GLCOMPRESSEDMULTITEXSUBIMAGE3DEXT 83 +#define GLCOMPRESSEDTEXIMAGE1D 84 +#define GLCOMPRESSEDTEXIMAGE1DARB 85 +#define GLCOMPRESSEDTEXIMAGE2D 86 +#define GLCOMPRESSEDTEXIMAGE2DARB 87 +#define GLCOMPRESSEDTEXIMAGE3D 88 +#define GLCOMPRESSEDTEXIMAGE3DARB 89 +#define GLCOMPRESSEDTEXSUBIMAGE1D 90 +#define GLCOMPRESSEDTEXSUBIMAGE1DARB 91 +#define GLCOMPRESSEDTEXSUBIMAGE2D 92 +#define GLCOMPRESSEDTEXSUBIMAGE2DARB 93 +#define GLCOMPRESSEDTEXSUBIMAGE3D 94 +#define GLCOMPRESSEDTEXSUBIMAGE3DARB 95 +#define GLCOMPRESSEDTEXTUREIMAGE1DEXT 96 +#define GLCOMPRESSEDTEXTUREIMAGE2DEXT 97 +#define GLCOMPRESSEDTEXTUREIMAGE3DEXT 98 +#define GLCOMPRESSEDTEXTURESUBIMAGE1DEXT 99 +#define GLCOMPRESSEDTEXTURESUBIMAGE2DEXT 100 +#define GLCOMPRESSEDTEXTURESUBIMAGE3DEXT 101 +#define GLCONVOLUTIONFILTER1D 102 +#define GLCONVOLUTIONFILTER2D 103 +#define GLCONVOLUTIONPARAMETERF 104 +#define GLCONVOLUTIONPARAMETERFV 105 +#define GLCONVOLUTIONPARAMETERI 106 +#define GLCONVOLUTIONPARAMETERIV 107 +#define GLCOPYCOLORSUBTABLE 108 +#define GLCOPYCOLORTABLE 109 +#define GLCOPYCONVOLUTIONFILTER1D 110 +#define GLCOPYCONVOLUTIONFILTER2D 111 +#define GLCOPYIMAGESUBDATA 112 +#define GLCOPYMULTITEXIMAGE1DEXT 113 +#define GLCOPYMULTITEXIMAGE2DEXT 114 +#define GLCOPYMULTITEXSUBIMAGE1DEXT 115 +#define GLCOPYMULTITEXSUBIMAGE3DEXT 116 +#define GLCOPYTEXSUBIMAGE3D 117 +#define GLCOPYTEXSUBIMAGE3DEXT 118 +#define GLCOPYTEXTUREIMAGE1DEXT 119 +#define GLCOPYTEXTUREIMAGE2DEXT 120 +#define GLCOPYTEXTURESUBIMAGE1DEXT 121 +#define GLCOPYTEXTURESUBIMAGE2DEXT 122 +#define GLCOPYTEXTURESUBIMAGE3DEXT 123 +#define GLCREATEPROGRAM 124 +#define GLCREATEPROGRAMOBJECTARB 125 +#define GLCREATESHADER 126 +#define GLCREATESHADEROBJECTARB 127 +#define GLDELETEBUFFERS 128 +#define GLDELETEFENCESNV 129 +#define GLDELETEFRAMEBUFFERS 130 +#define GLDELETEOBJECTARB 131 +#define GLDELETEOCCLUSIONQUERIESNV 132 +#define GLDELETEPROGRAM 133 +#define GLDELETEPROGRAMSARB 134 +#define GLDELETEPROGRAMSNV 135 +#define GLDELETEQUERIES 136 +#define GLDELETEQUERIESARB 137 +#define GLDELETERENDERBUFFERS 138 +#define GLDELETESAMPLERS 139 +#define GLDELETESHADER 140 +#define GLDELETETEXTURESEXT 141 +#define GLDELETEVERTEXARRAYS 142 +#define GLDEPTHBOUNDSDNV 143 +#define GLDEPTHBOUNDSEXT 144 +#define GLDEPTHRANGEDNV 145 +#define GLDETACHOBJECTARB 146 +#define GLDETACHSHADER 147 +#define GLDISABLECLIENTSTATEINDEXEDEXT 148 +#define GLDISABLEI 149 +#define GLDISABLEINDEXEDEXT 150 +#define GLDISABLEVERTEXATTRIBARRAY 151 +#define GLDRAWARRAYSEXT 152 +#define GLDRAWARRAYSINSTANCEDARB 153 +#define GLDRAWARRAYSINSTANCEDEXT 154 +#define GLDRAWBUFFERS 155 +#define GLDRAWBUFFERSARB 156 +#define GLDRAWBUFFERSATI 157 +#define GLDRAWELEMENTSINSTANCEDARB 158 +#define GLDRAWELEMENTSINSTANCEDEXT 159 +#define GLDRAWRANGEELEMENTSEXT 160 +#define GLEDGEFLAGPOINTEREXT 161 +#define GLENABLECLIENTSTATEINDEXEDEXT 162 +#define GLENABLEI 163 +#define GLENABLEINDEXEDEXT 164 +#define GLENDCONDITIONALRENDER 165 +#define GLENDCONDITIONALRENDERNV 166 +#define GLENDOCCLUSIONQUERYNV 167 +#define GLENDQUERY 168 +#define GLENDQUERYARB 169 +#define GLENDTRANSFORMFEEDBACK 170 +#define GLENDTRANSFORMFEEDBACKNV 171 +#define GLEXECUTEPROGRAMNV 172 +#define GLFINALCOMBINERINPUTNV 173 +#define GLFINISHFENCENV 174 +#define GLFLUSHMAPPEDBUFFERRANGE 175 +#define GLFLUSHPIXELDATARANGENV 176 +#define GLFLUSHVERTEXARRAYRANGENV 177 +#define GLFOGCOORDD 178 +#define GLFOGCOORDDEXT 179 +#define GLFOGCOORDDV 180 +#define GLFOGCOORDDVEXT 181 +#define GLFOGCOORDF 182 +#define GLFOGCOORDFEXT 183 +#define GLFOGCOORDFV 184 +#define GLFOGCOORDFVEXT 185 +#define GLFOGCOORDHNV 186 +#define GLFOGCOORDHVNV 187 +#define GLFOGCOORDPOINTER 188 +#define GLFOGCOORDPOINTEREXT 189 +#define GLFRAMEBUFFERDRAWBUFFEREXT 190 +#define GLFRAMEBUFFERDRAWBUFFERSEXT 191 +#define GLFRAMEBUFFERREADBUFFEREXT 192 +#define GLFRAMEBUFFERRENDERBUFFER 193 +#define GLFRAMEBUFFERTEXTURE 194 +#define GLFRAMEBUFFERTEXTURE1D 195 +#define GLFRAMEBUFFERTEXTURE1DEXT 196 +#define GLFRAMEBUFFERTEXTURE2D 197 +#define GLFRAMEBUFFERTEXTURE3D 198 +#define GLFRAMEBUFFERTEXTURE3DEXT 199 +#define GLFRAMEBUFFERTEXTUREARB 200 +#define GLFRAMEBUFFERTEXTUREEXT 201 +#define GLFRAMEBUFFERTEXTUREFACEARB 202 +#define GLFRAMEBUFFERTEXTUREFACEEXT 203 +#define GLFRAMEBUFFERTEXTURELAYER 204 +#define GLFRAMEBUFFERTEXTURELAYERARB 205 +#define GLFRAMEBUFFERTEXTURELAYEREXT 206 +#define GLGENBUFFERS 207 +#define GLGENBUFFERSARB 208 +#define GLGENERATEMIPMAP 209 +#define GLGENERATEMIPMAPEXT 210 +#define GLGENERATEMULTITEXMIPMAPEXT 211 +#define GLGENERATETEXTUREMIPMAPEXT 212 +#define GLGENFENCESNV 213 +#define GLGENFRAMEBUFFERS 214 +#define GLGENOCCLUSIONQUERIESNV 215 +#define GLGENPROGRAMSARB 216 +#define GLGENPROGRAMSNV 217 +#define GLGENQUERIES 218 +#define GLGENQUERIESARB 219 +#define GLGENRENDERBUFFERS 220 +#define GLGENSAMPLERS 221 +#define GLGENTEXTURESEXT 222 +#define GLGENVERTEXARRAYS 223 +#define GLGETACTIVEATTRIB 224 +#define GLGETACTIVEATTRIBARB 225 +#define GLGETACTIVEUNIFORM 226 +#define GLGETACTIVEUNIFORMARB 227 +#define GLGETACTIVEVARYINGNV 228 +#define GLGETATTACHEDOBJECTSARB 229 +#define GLGETATTACHEDSHADERS 230 +#define GLGETATTRIBLOCATION 231 +#define GLGETATTRIBLOCATIONARB 232 +#define GLGETBOOLEANI_V 233 +#define GLGETBOOLEANINDEXEDVEXT 234 +#define GLGETBUFFERPARAMETERIV 235 +#define GLGETBUFFERPARAMETERIVARB 236 +#define GLGETBUFFERPOINTERV 237 +#define GLGETBUFFERPOINTERVARB 238 +#define GLGETBUFFERSUBDATA 239 +#define GLGETBUFFERSUBDATAARB 240 +#define GLGETCOLORTABLE 241 +#define GLGETCOLORTABLEEXT 242 +#define GLGETCOLORTABLEPARAMETERFV 243 +#define GLGETCOLORTABLEPARAMETERFVEXT 244 +#define GLGETCOLORTABLEPARAMETERIV 245 +#define GLGETCOLORTABLEPARAMETERIVEXT 246 +#define GLGETCOMBINERINPUTPARAMETERFVNV 247 +#define GLGETCOMBINERINPUTPARAMETERIVNV 248 +#define GLGETCOMBINEROUTPUTPARAMETERFVNV 249 +#define GLGETCOMBINEROUTPUTPARAMETERIVNV 250 +#define GLGETCOMBINERSTAGEPARAMETERFVNV 251 +#define GLGETCOMPRESSEDMULTITEXIMAGEEXT 252 +#define GLGETCOMPRESSEDTEXIMAGE 253 +#define GLGETCOMPRESSEDTEXIMAGEARB 254 +#define GLGETCOMPRESSEDTEXTUREIMAGEEXT 255 +#define GLGETCONVOLUTIONFILTER 256 +#define GLGETCONVOLUTIONPARAMETERFV 257 +#define GLGETCONVOLUTIONPARAMETERIV 258 +#define GLGETDOUBLEINDEXEDVEXT 259 +#define GLGETFENCEIVNV 260 +#define GLGETFINALCOMBINERINPUTPARAMETERFVNV 261 +#define GLGETFINALCOMBINERINPUTPARAMETERIVNV 262 +#define GLGETFLOATINDEXEDVEXT 263 +#define GLGETFRAGDATALOCATION 264 +#define GLGETFRAGDATALOCATIONEXT 265 +#define GLGETFRAMEBUFFERATTACHMENTPARAMETERIV 266 +#define GLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXT 267 +#define GLGETFRAMEBUFFERPARAMETERIVEXT 268 +#define GLGETHANDLEARB 269 +#define GLGETHISTOGRAM 270 +#define GLGETHISTOGRAMPARAMETERFV 271 +#define GLGETHISTOGRAMPARAMETERIV 272 +#define GLGETINFOLOGARB 273 +#define GLGETINTEGERI_V 274 +#define GLGETINTEGERINDEXEDVEXT 275 +#define GLGETMINMAX 276 +#define GLGETMINMAXPARAMETERFV 277 +#define GLGETMINMAXPARAMETERIV 278 +#define GLGETMULTISAMPLEFVNV 279 +#define GLGETMULTITEXENVFVEXT 280 +#define GLGETMULTITEXENVIVEXT 281 +#define GLGETMULTITEXGENDVEXT 282 +#define GLGETMULTITEXGENFVEXT 283 +#define GLGETMULTITEXGENIVEXT 284 +#define GLGETMULTITEXIMAGEEXT 285 +#define GLGETMULTITEXLEVELPARAMETERFVEXT 286 +#define GLGETMULTITEXLEVELPARAMETERIVEXT 287 +#define GLGETMULTITEXPARAMETERFVEXT 288 +#define GLGETMULTITEXPARAMETERIIVEXT 289 +#define GLGETMULTITEXPARAMETERIUIVEXT 290 +#define GLGETMULTITEXPARAMETERIVEXT 291 +#define GLGETNAMEDBUFFERPARAMETERIVEXT 292 +#define GLGETNAMEDBUFFERPOINTERVEXT 293 +#define GLGETNAMEDBUFFERSUBDATAEXT 294 +#define GLGETNAMEDFRAMEBUFFERATTACHMENTPARAMETERIVEXT 295 +#define GLGETNAMEDPROGRAMIVEXT 296 +#define GLGETNAMEDPROGRAMLOCALPARAMETERDVEXT 297 +#define GLGETNAMEDPROGRAMLOCALPARAMETERFVEXT 298 +#define GLGETNAMEDPROGRAMLOCALPARAMETERIIVEXT 299 +#define GLGETNAMEDPROGRAMLOCALPARAMETERIUIVEXT 300 +#define GLGETNAMEDPROGRAMSTRINGEXT 301 +#define GLGETNAMEDRENDERBUFFERPARAMETERIVEXT 302 +#define GLGETOBJECTPARAMETERFVARB 303 +#define GLGETOBJECTPARAMETERIVARB 304 +#define GLGETOCCLUSIONQUERYIVNV 305 +#define GLGETOCCLUSIONQUERYUIVNV 306 +#define GLGETPOINTERINDEXEDVEXT 307 +#define GLGETPOINTERVEXT 308 +#define GLGETPROGRAMENVPARAMETERDVARB 309 +#define GLGETPROGRAMENVPARAMETERIIVNV 310 +#define GLGETPROGRAMENVPARAMETERIUIVNV 311 +#define GLGETPROGRAMINFOLOG 312 +#define GLGETPROGRAMIV 313 +#define GLGETPROGRAMIVNV 314 +#define GLGETPROGRAMLOCALPARAMETERDVARB 315 +#define GLGETPROGRAMLOCALPARAMETERFVARB 316 +#define GLGETPROGRAMLOCALPARAMETERIIVNV 317 +#define GLGETPROGRAMLOCALPARAMETERIUIVNV 318 +#define GLGETPROGRAMNAMEDPARAMETERDVNV 319 +#define GLGETPROGRAMNAMEDPARAMETERFVNV 320 +#define GLGETPROGRAMPARAMETERDVNV 321 +#define GLGETPROGRAMPARAMETERFVNV 322 +#define GLGETPROGRAMSTRINGARB 323 +#define GLGETPROGRAMSTRINGNV 324 +#define GLGETQUERYIV 325 +#define GLGETQUERYIVARB 326 +#define GLGETQUERYOBJECTI64VEXT 327 +#define GLGETQUERYOBJECTIV 328 +#define GLGETQUERYOBJECTIVARB 329 +#define GLGETQUERYOBJECTUI64V 330 +#define GLGETQUERYOBJECTUI64VEXT 331 +#define GLGETQUERYOBJECTUIV 332 +#define GLGETQUERYOBJECTUIVARB 333 +#define GLGETRENDERBUFFERPARAMETERIV 334 +#define GLGETRENDERBUFFERPARAMETERIVEXT 335 +#define GLGETSEPARABLEFILTER 336 +#define GLGETSHADERINFOLOG 337 +#define GLGETSHADERIV 338 +#define GLGETSHADERSOURCE 339 +#define GLGETSHADERSOURCEARB 340 +#define GLGETSTRINGI 341 +#define GLGETTEXPARAMETERIIV 342 +#define GLGETTEXPARAMETERIIVEXT 343 +#define GLGETTEXPARAMETERIUIV 344 +#define GLGETTEXPARAMETERIUIVEXT 345 +#define GLGETTEXTURELEVELPARAMETERFVEXT 346 +#define GLGETTEXTURELEVELPARAMETERIVEXT 347 +#define GLGETTEXTUREPARAMETERFVEXT 348 +#define GLGETTEXTUREPARAMETERIIVEXT 349 +#define GLGETTEXTUREPARAMETERIUIVEXT 350 +#define GLGETTEXTUREPARAMETERIVEXT 351 +#define GLGETTRACKMATRIXIVNV 352 +#define GLGETTRANSFORMFEEDBACKVARYING 353 +#define GLGETTRANSFORMFEEDBACKVARYINGNV 354 +#define GLGETUNIFORMBUFFERSIZEEXT 355 +#define GLGETUNIFORMFV 356 +#define GLGETUNIFORMFVARB 357 +#define GLGETUNIFORMIV 358 +#define GLGETUNIFORMIVARB 359 +#define GLGETUNIFORMLOCATION 360 +#define GLGETUNIFORMLOCATIONARB 361 +#define GLGETUNIFORMOFFSETEXT 362 +#define GLGETUNIFORMUIV 363 +#define GLGETUNIFORMUIVEXT 364 +#define GLGETVARYINGLOCATIONNV 365 +#define GLGETVERTEXATTRIBDV 366 +#define GLGETVERTEXATTRIBDVARB 367 +#define GLGETVERTEXATTRIBDVNV 368 +#define GLGETVERTEXATTRIBFV 369 +#define GLGETVERTEXATTRIBFVARB 370 +#define GLGETVERTEXATTRIBFVNV 371 +#define GLGETVERTEXATTRIBIIV 372 +#define GLGETVERTEXATTRIBIIVEXT 373 +#define GLGETVERTEXATTRIBIUIV 374 +#define GLGETVERTEXATTRIBIUIVEXT 375 +#define GLGETVERTEXATTRIBIV 376 +#define GLGETVERTEXATTRIBIVARB 377 +#define GLGETVERTEXATTRIBIVNV 378 +#define GLGETVERTEXATTRIBPOINTERV 379 +#define GLGETVERTEXATTRIBPOINTERVARB 380 +#define GLGETVERTEXATTRIBPOINTERVNV 381 +#define GLGETVIDEOI64VNV 382 +#define GLGETVIDEOIVNV 383 +#define GLGETVIDEOUI64VNV 384 +#define GLGETVIDEOUIVNV 385 +#define GLHISTOGRAM 386 +#define GLINDEXPOINTEREXT 387 +#define GLISBUFFER 388 +#define GLISENABLEDI 389 +#define GLISENABLEDINDEXEDEXT 390 +#define GLISFENCENV 391 +#define GLISFRAMEBUFFER 392 +#define GLISFRAMEBUFFEREXT 393 +#define GLISOCCLUSIONQUERYNV 394 +#define GLISPROGRAM 395 +#define GLISPROGRAMARB 396 +#define GLISPROGRAMNV 397 +#define GLISQUERY 398 +#define GLISQUERYARB 399 +#define GLISRENDERBUFFER 400 +#define GLISRENDERBUFFEREXT 401 +#define GLISSHADER 402 +#define GLISTEXTUREEXT 403 +#define GLISVERTEXARRAY 404 +#define GLLINKPROGRAM 405 +#define GLLINKPROGRAMARB 406 +#define GLLOADPROGRAMNV 407 +#define GLLOADTRANSPOSEMATRIXD 408 +#define GLLOADTRANSPOSEMATRIXDARB 409 +#define GLLOADTRANSPOSEMATRIXFARB 410 +#define GLLOCKARRAYSEXT 411 +#define GLMAPBUFFER 412 +#define GLMAPBUFFERARB 413 +#define GLMAPBUFFERRANGE 414 +#define GLMATRIXFRUSTUMEXT 415 +#define GLMATRIXLOADDEXT 416 +#define GLMATRIXLOADFEXT 417 +#define GLMATRIXLOADIDENTITYEXT 418 +#define GLMATRIXLOADTRANSPOSEDEXT 419 +#define GLMATRIXLOADTRANSPOSEFEXT 420 +#define GLMATRIXMULTDEXT 421 +#define GLMATRIXMULTFEXT 422 +#define GLMATRIXMULTTRANSPOSEDEXT 423 +#define GLMATRIXMULTTRANSPOSEFEXT 424 +#define GLMATRIXORTHOEXT 425 +#define GLMATRIXPOPEXT 426 +#define GLMATRIXPUSHEXT 427 +#define GLMATRIXROTATEDEXT 428 +#define GLMATRIXROTATEFEXT 429 +#define GLMATRIXSCALEDEXT 430 +#define GLMATRIXSCALEFEXT 431 +#define GLMATRIXTRANSLATEDEXT 432 +#define GLMATRIXTRANSLATEFEXT 433 +#define GLMINMAX 434 +#define GLMULTIDRAWARRAYS 435 +#define GLMULTIDRAWARRAYSEXT 436 +#define GLMULTIDRAWELEMENTS 437 +#define GLMULTIDRAWELEMENTSEXT 438 +#define GLMULTITEXBUFFEREXT 439 +#define GLMULTITEXCOORD1D 440 +#define GLMULTITEXCOORD1DARB 441 +#define GLMULTITEXCOORD1DV 442 +#define GLMULTITEXCOORD1DVARB 443 +#define GLMULTITEXCOORD1F 444 +#define GLMULTITEXCOORD1FARB 445 +#define GLMULTITEXCOORD1FV 446 +#define GLMULTITEXCOORD1FVARB 447 +#define GLMULTITEXCOORD1HNV 448 +#define GLMULTITEXCOORD1HVNV 449 +#define GLMULTITEXCOORD1I 450 +#define GLMULTITEXCOORD1IARB 451 +#define GLMULTITEXCOORD1IV 452 +#define GLMULTITEXCOORD1IVARB 453 +#define GLMULTITEXCOORD1S 454 +#define GLMULTITEXCOORD1SARB 455 +#define GLMULTITEXCOORD1SV 456 +#define GLMULTITEXCOORD1SVARB 457 +#define GLMULTITEXCOORD2D 458 +#define GLMULTITEXCOORD2DARB 459 +#define GLMULTITEXCOORD2DV 460 +#define GLMULTITEXCOORD2DVARB 461 +#define GLMULTITEXCOORD2FARB 462 +#define GLMULTITEXCOORD2FVARB 463 +#define GLMULTITEXCOORD2HNV 464 +#define GLMULTITEXCOORD2HVNV 465 +#define GLMULTITEXCOORD2I 466 +#define GLMULTITEXCOORD2IARB 467 +#define GLMULTITEXCOORD2IV 468 +#define GLMULTITEXCOORD2IVARB 469 +#define GLMULTITEXCOORD2S 470 +#define GLMULTITEXCOORD2SARB 471 +#define GLMULTITEXCOORD2SV 472 +#define GLMULTITEXCOORD2SVARB 473 +#define GLMULTITEXCOORD3D 474 +#define GLMULTITEXCOORD3DARB 475 +#define GLMULTITEXCOORD3DV 476 +#define GLMULTITEXCOORD3DVARB 477 +#define GLMULTITEXCOORD3F 478 +#define GLMULTITEXCOORD3FARB 479 +#define GLMULTITEXCOORD3FV 480 +#define GLMULTITEXCOORD3FVARB 481 +#define GLMULTITEXCOORD3HNV 482 +#define GLMULTITEXCOORD3HVNV 483 +#define GLMULTITEXCOORD3I 484 +#define GLMULTITEXCOORD3IARB 485 +#define GLMULTITEXCOORD3IV 486 +#define GLMULTITEXCOORD3IVARB 487 +#define GLMULTITEXCOORD3S 488 +#define GLMULTITEXCOORD3SARB 489 +#define GLMULTITEXCOORD3SV 490 +#define GLMULTITEXCOORD3SVARB 491 +#define GLMULTITEXCOORD4D 492 +#define GLMULTITEXCOORD4DARB 493 +#define GLMULTITEXCOORD4DV 494 +#define GLMULTITEXCOORD4DVARB 495 +#define GLMULTITEXCOORD4F 496 +#define GLMULTITEXCOORD4FARB 497 +#define GLMULTITEXCOORD4FV 498 +#define GLMULTITEXCOORD4FVARB 499 +#define GLMULTITEXCOORD4HNV 500 +#define GLMULTITEXCOORD4HVNV 501 +#define GLMULTITEXCOORD4I 502 +#define GLMULTITEXCOORD4IARB 503 +#define GLMULTITEXCOORD4IV 504 +#define GLMULTITEXCOORD4IVARB 505 +#define GLMULTITEXCOORD4S 506 +#define GLMULTITEXCOORD4SARB 507 +#define GLMULTITEXCOORD4SV 508 +#define GLMULTITEXCOORD4SVARB 509 +#define GLMULTITEXCOORDPOINTEREXT 510 +#define GLMULTITEXENVFEXT 511 +#define GLMULTITEXENVFVEXT 512 +#define GLMULTITEXENVIEXT 513 +#define GLMULTITEXENVIVEXT 514 +#define GLMULTITEXGENDEXT 515 +#define GLMULTITEXGENDVEXT 516 +#define GLMULTITEXGENFEXT 517 +#define GLMULTITEXGENFVEXT 518 +#define GLMULTITEXGENIEXT 519 +#define GLMULTITEXGENIVEXT 520 +#define GLMULTITEXIMAGE1DEXT 521 +#define GLMULTITEXIMAGE2DEXT 522 +#define GLMULTITEXIMAGE3DEXT 523 +#define GLMULTITEXPARAMETERFEXT 524 +#define GLMULTITEXPARAMETERFVEXT 525 +#define GLMULTITEXPARAMETERIEXT 526 +#define GLMULTITEXPARAMETERIIVEXT 527 +#define GLMULTITEXPARAMETERIUIVEXT 528 +#define GLMULTITEXPARAMETERIVEXT 529 +#define GLMULTITEXRENDERBUFFEREXT 530 +#define GLMULTITEXSUBIMAGE1DEXT 531 +#define GLMULTITEXSUBIMAGE2DEXT 532 +#define GLMULTITEXSUBIMAGE3DEXT 533 +#define GLMULTTRANSPOSEMATRIXD 534 +#define GLMULTTRANSPOSEMATRIXDARB 535 +#define GLMULTTRANSPOSEMATRIXFARB 536 +#define GLNAMEDFRAMEBUFFERRENDERBUFFEREXT 537 +#define GLNAMEDFRAMEBUFFERTEXTURE1DEXT 538 +#define GLNAMEDFRAMEBUFFERTEXTURE2DEXT 539 +#define GLNAMEDFRAMEBUFFERTEXTURE3DEXT 540 +#define GLNAMEDFRAMEBUFFERTEXTUREEXT 541 +#define GLNAMEDFRAMEBUFFERTEXTUREFACEEXT 542 +#define GLNAMEDFRAMEBUFFERTEXTURELAYEREXT 543 +#define GLNAMEDPROGRAMLOCALPARAMETER4DEXT 544 +#define GLNAMEDPROGRAMLOCALPARAMETER4DVEXT 545 +#define GLNAMEDPROGRAMLOCALPARAMETER4FEXT 546 +#define GLNAMEDPROGRAMLOCALPARAMETER4FVEXT 547 +#define GLNAMEDPROGRAMLOCALPARAMETERI4IEXT 548 +#define GLNAMEDPROGRAMLOCALPARAMETERI4IVEXT 549 +#define GLNAMEDPROGRAMLOCALPARAMETERI4UIEXT 550 +#define GLNAMEDPROGRAMLOCALPARAMETERI4UIVEXT 551 +#define GLNAMEDPROGRAMLOCALPARAMETERS4FVEXT 552 +#define GLNAMEDPROGRAMLOCALPARAMETERSI4IVEXT 553 +#define GLNAMEDPROGRAMLOCALPARAMETERSI4UIVEXT 554 +#define GLNAMEDPROGRAMSTRINGEXT 555 +#define GLNAMEDRENDERBUFFERSTORAGEEXT 556 +#define GLNAMEDRENDERBUFFERSTORAGEMULTISAMPLECOVERAGEEXT 557 +#define GLNAMEDRENDERBUFFERSTORAGEMULTISAMPLEEXT 558 +#define GLNORMAL3HNV 559 +#define GLNORMAL3HVNV 560 +#define GLNORMALPOINTEREXT 561 +#define GLPIXELDATARANGENV 562 +#define GLPOINTPARAMETERFARB 563 +#define GLPOINTPARAMETERFEXT 564 +#define GLPOINTPARAMETERFVARB 565 +#define GLPOINTPARAMETERFVEXT 566 +#define GLPOINTPARAMETERINV 567 +#define GLPOINTPARAMETERIV 568 +#define GLPOINTPARAMETERIVNV 569 +#define GLPRESENTFRAMEDUALFILLNV 570 +#define GLPRESENTFRAMEKEYEDNV 571 +#define GLPRIMITIVERESTARTNV 572 +#define GLPRIORITIZETEXTURESEXT 573 +#define GLPROGRAMBUFFERPARAMETERSIIVNV 574 +#define GLPROGRAMBUFFERPARAMETERSIUIVNV 575 +#define GLPROGRAMENVPARAMETER4DARB 576 +#define GLPROGRAMENVPARAMETER4DVARB 577 +#define GLPROGRAMENVPARAMETERI4INV 578 +#define GLPROGRAMENVPARAMETERI4IVNV 579 +#define GLPROGRAMENVPARAMETERI4UINV 580 +#define GLPROGRAMENVPARAMETERI4UIVNV 581 +#define GLPROGRAMENVPARAMETERSI4IVNV 582 +#define GLPROGRAMENVPARAMETERSI4UIVNV 583 +#define GLPROGRAMLOCALPARAMETER4DARB 584 +#define GLPROGRAMLOCALPARAMETER4DVARB 585 +#define GLPROGRAMLOCALPARAMETERI4INV 586 +#define GLPROGRAMLOCALPARAMETERI4IVNV 587 +#define GLPROGRAMLOCALPARAMETERI4UINV 588 +#define GLPROGRAMLOCALPARAMETERI4UIVNV 589 +#define GLPROGRAMLOCALPARAMETERSI4IVNV 590 +#define GLPROGRAMLOCALPARAMETERSI4UIVNV 591 +#define GLPROGRAMNAMEDPARAMETER4DNV 592 +#define GLPROGRAMNAMEDPARAMETER4DVNV 593 +#define GLPROGRAMNAMEDPARAMETER4FNV 594 +#define GLPROGRAMNAMEDPARAMETER4FVNV 595 +#define GLPROGRAMPARAMETER4DNV 596 +#define GLPROGRAMPARAMETER4DVNV 597 +#define GLPROGRAMPARAMETER4FNV 598 +#define GLPROGRAMPARAMETER4FVNV 599 +#define GLPROGRAMPARAMETERIARB 600 +#define GLPROGRAMPARAMETERIEXT 601 +#define GLPROGRAMPARAMETERS4DVNV 602 +#define GLPROGRAMPARAMETERS4FVNV 603 +#define GLPROGRAMSTRINGARB 604 +#define GLPROGRAMUNIFORM1FEXT 605 +#define GLPROGRAMUNIFORM1FVEXT 606 +#define GLPROGRAMUNIFORM1IEXT 607 +#define GLPROGRAMUNIFORM1IVEXT 608 +#define GLPROGRAMUNIFORM1UIEXT 609 +#define GLPROGRAMUNIFORM1UIVEXT 610 +#define GLPROGRAMUNIFORM2FEXT 611 +#define GLPROGRAMUNIFORM2FVEXT 612 +#define GLPROGRAMUNIFORM2IEXT 613 +#define GLPROGRAMUNIFORM2IVEXT 614 +#define GLPROGRAMUNIFORM2UIEXT 615 +#define GLPROGRAMUNIFORM2UIVEXT 616 +#define GLPROGRAMUNIFORM3FEXT 617 +#define GLPROGRAMUNIFORM3FVEXT 618 +#define GLPROGRAMUNIFORM3IEXT 619 +#define GLPROGRAMUNIFORM3IVEXT 620 +#define GLPROGRAMUNIFORM3UIEXT 621 +#define GLPROGRAMUNIFORM3UIVEXT 622 +#define GLPROGRAMUNIFORM4FEXT 623 +#define GLPROGRAMUNIFORM4FVEXT 624 +#define GLPROGRAMUNIFORM4IEXT 625 +#define GLPROGRAMUNIFORM4IVEXT 626 +#define GLPROGRAMUNIFORM4UIEXT 627 +#define GLPROGRAMUNIFORM4UIVEXT 628 +#define GLPROGRAMUNIFORMMATRIX2FVEXT 629 +#define GLPROGRAMUNIFORMMATRIX2X3FVEXT 630 +#define GLPROGRAMUNIFORMMATRIX2X4FVEXT 631 +#define GLPROGRAMUNIFORMMATRIX3FVEXT 632 +#define GLPROGRAMUNIFORMMATRIX3X2FVEXT 633 +#define GLPROGRAMUNIFORMMATRIX3X4FVEXT 634 +#define GLPROGRAMUNIFORMMATRIX4FVEXT 635 +#define GLPROGRAMUNIFORMMATRIX4X2FVEXT 636 +#define GLPROGRAMUNIFORMMATRIX4X3FVEXT 637 +#define GLPROGRAMVERTEXLIMITNV 638 +#define GLPUSHCLIENTATTRIBDEFAULTEXT 639 +#define GLQUERYCOUNTER 640 +#define GLRENDERBUFFERSTORAGE 641 +#define GLRENDERBUFFERSTORAGEMULTISAMPLE 642 +#define GLRENDERBUFFERSTORAGEMULTISAMPLEEXT 643 +#define GLREQUESTRESIDENTPROGRAMSNV 644 +#define GLRESETHISTOGRAM 645 +#define GLRESETMINMAX 646 +#define GLSAMPLECOVERAGE 647 +#define GLSAMPLECOVERAGEARB 648 +#define GLSAMPLEMASKINDEXEDNV 649 +#define GLSAMPLERPARAMETERF 650 +#define GLSAMPLERPARAMETERFV 651 +#define GLSAMPLERPARAMETERI 652 +#define GLSECONDARYCOLOR3B 653 +#define GLSECONDARYCOLOR3BEXT 654 +#define GLSECONDARYCOLOR3BV 655 +#define GLSECONDARYCOLOR3BVEXT 656 +#define GLSECONDARYCOLOR3D 657 +#define GLSECONDARYCOLOR3DEXT 658 +#define GLSECONDARYCOLOR3DV 659 +#define GLSECONDARYCOLOR3DVEXT 660 +#define GLSECONDARYCOLOR3F 661 +#define GLSECONDARYCOLOR3FEXT 662 +#define GLSECONDARYCOLOR3FV 663 +#define GLSECONDARYCOLOR3FVEXT 664 +#define GLSECONDARYCOLOR3HNV 665 +#define GLSECONDARYCOLOR3HVNV 666 +#define GLSECONDARYCOLOR3I 667 +#define GLSECONDARYCOLOR3IEXT 668 +#define GLSECONDARYCOLOR3IV 669 +#define GLSECONDARYCOLOR3IVEXT 670 +#define GLSECONDARYCOLOR3S 671 +#define GLSECONDARYCOLOR3SEXT 672 +#define GLSECONDARYCOLOR3SV 673 +#define GLSECONDARYCOLOR3SVEXT 674 +#define GLSECONDARYCOLOR3UB 675 +#define GLSECONDARYCOLOR3UBEXT 676 +#define GLSECONDARYCOLOR3UBV 677 +#define GLSECONDARYCOLOR3UBVEXT 678 +#define GLSECONDARYCOLOR3UI 679 +#define GLSECONDARYCOLOR3UIEXT 680 +#define GLSECONDARYCOLOR3UIV 681 +#define GLSECONDARYCOLOR3UIVEXT 682 +#define GLSECONDARYCOLOR3US 683 +#define GLSECONDARYCOLOR3USEXT 684 +#define GLSECONDARYCOLOR3USV 685 +#define GLSECONDARYCOLOR3USVEXT 686 +#define GLSECONDARYCOLORPOINTER 687 +#define GLSECONDARYCOLORPOINTEREXT 688 +#define GLSEPARABLEFILTER2D 689 +#define GLSETFENCENV 690 +#define GLSHADERSOURCE 691 +#define GLSHADERSOURCEARB 692 +#define GLSTENCILFUNCSEPARATE 693 +#define GLSTENCILMASKSEPARATE 694 +#define GLSTENCILOPSEPARATE 695 +#define GLTESTFENCENV 696 +#define GLTEXBUFFERARB 697 +#define GLTEXBUFFEREXT 698 +#define GLTEXCOORD1HNV 699 +#define GLTEXCOORD1HVNV 700 +#define GLTEXCOORD2HNV 701 +#define GLTEXCOORD2HVNV 702 +#define GLTEXCOORD3HNV 703 +#define GLTEXCOORD3HVNV 704 +#define GLTEXCOORD4HNV 705 +#define GLTEXCOORD4HVNV 706 +#define GLTEXCOORDPOINTEREXT 707 +#define GLTEXIMAGE3D 708 +#define GLTEXIMAGE3DEXT 709 +#define GLTEXPARAMETERIIV 710 +#define GLTEXPARAMETERIIVEXT 711 +#define GLTEXPARAMETERIUIV 712 +#define GLTEXPARAMETERIUIVEXT 713 +#define GLTEXRENDERBUFFERNV 714 +#define GLTEXSTORAGE2D 715 +#define GLTEXSUBIMAGE3D 716 +#define GLTEXSUBIMAGE3DEXT 717 +#define GLTEXTUREBARRIERNV 718 +#define GLTEXTUREBUFFEREXT 719 +#define GLTEXTUREIMAGE1DEXT 720 +#define GLTEXTUREIMAGE2DEXT 721 +#define GLTEXTUREIMAGE3DEXT 722 +#define GLTEXTUREPARAMETERFEXT 723 +#define GLTEXTUREPARAMETERFVEXT 724 +#define GLTEXTUREPARAMETERIEXT 725 +#define GLTEXTUREPARAMETERIIVEXT 726 +#define GLTEXTUREPARAMETERIUIVEXT 727 +#define GLTEXTUREPARAMETERIVEXT 728 +#define GLTEXTURERENDERBUFFEREXT 729 +#define GLTEXTURESTORAGE2DEXT 730 +#define GLTEXTURESUBIMAGE1DEXT 731 +#define GLTEXTURESUBIMAGE2DEXT 732 +#define GLTEXTURESUBIMAGE3DEXT 733 +#define GLTRACKMATRIXNV 734 +#define GLTRANSFORMFEEDBACKATTRIBSNV 735 +#define GLTRANSFORMFEEDBACKVARYINGS 736 +#define GLTRANSFORMFEEDBACKVARYINGSNV 737 +#define GLUNIFORM1F 738 +#define GLUNIFORM1FARB 739 +#define GLUNIFORM1FV 740 +#define GLUNIFORM1FVARB 741 +#define GLUNIFORM1I 742 +#define GLUNIFORM1IARB 743 +#define GLUNIFORM1IV 744 +#define GLUNIFORM1IVARB 745 +#define GLUNIFORM1UI 746 +#define GLUNIFORM1UIEXT 747 +#define GLUNIFORM1UIV 748 +#define GLUNIFORM1UIVEXT 749 +#define GLUNIFORM2F 750 +#define GLUNIFORM2FARB 751 +#define GLUNIFORM2FV 752 +#define GLUNIFORM2FVARB 753 +#define GLUNIFORM2I 754 +#define GLUNIFORM2IARB 755 +#define GLUNIFORM2IV 756 +#define GLUNIFORM2IVARB 757 +#define GLUNIFORM2UI 758 +#define GLUNIFORM2UIEXT 759 +#define GLUNIFORM2UIV 760 +#define GLUNIFORM2UIVEXT 761 +#define GLUNIFORM3F 762 +#define GLUNIFORM3FARB 763 +#define GLUNIFORM3FV 764 +#define GLUNIFORM3FVARB 765 +#define GLUNIFORM3I 766 +#define GLUNIFORM3IARB 767 +#define GLUNIFORM3IV 768 +#define GLUNIFORM3IVARB 769 +#define GLUNIFORM3UI 770 +#define GLUNIFORM3UIEXT 771 +#define GLUNIFORM3UIV 772 +#define GLUNIFORM3UIVEXT 773 +#define GLUNIFORM4F 774 +#define GLUNIFORM4FARB 775 +#define GLUNIFORM4FV 776 +#define GLUNIFORM4FVARB 777 +#define GLUNIFORM4I 778 +#define GLUNIFORM4IARB 779 +#define GLUNIFORM4IV 780 +#define GLUNIFORM4IVARB 781 +#define GLUNIFORM4UI 782 +#define GLUNIFORM4UIEXT 783 +#define GLUNIFORM4UIV 784 +#define GLUNIFORM4UIVEXT 785 +#define GLUNIFORMBUFFEREXT 786 +#define GLUNIFORMMATRIX2FV 787 +#define GLUNIFORMMATRIX2FVARB 788 +#define GLUNIFORMMATRIX2X3FV 789 +#define GLUNIFORMMATRIX2X4FV 790 +#define GLUNIFORMMATRIX3FV 791 +#define GLUNIFORMMATRIX3FVARB 792 +#define GLUNIFORMMATRIX3X2FV 793 +#define GLUNIFORMMATRIX3X4FV 794 +#define GLUNIFORMMATRIX4FV 795 +#define GLUNIFORMMATRIX4FVARB 796 +#define GLUNIFORMMATRIX4X2FV 797 +#define GLUNIFORMMATRIX4X3FV 798 +#define GLUNLOCKARRAYSEXT 799 +#define GLUNMAPBUFFER 800 +#define GLUNMAPBUFFERARB 801 +#define GLUSEPROGRAMOBJECTARB 802 +#define GLVALIDATEPROGRAM 803 +#define GLVALIDATEPROGRAMARB 804 +#define GLVERTEX2HNV 805 +#define GLVERTEX2HVNV 806 +#define GLVERTEX3HNV 807 +#define GLVERTEX3HVNV 808 +#define GLVERTEX4HNV 809 +#define GLVERTEX4HVNV 810 +#define GLVERTEXARRAYRANGENV 811 +#define GLVERTEXATTRIB1D 812 +#define GLVERTEXATTRIB1DARB 813 +#define GLVERTEXATTRIB1DNV 814 +#define GLVERTEXATTRIB1DV 815 +#define GLVERTEXATTRIB1DVARB 816 +#define GLVERTEXATTRIB1DVNV 817 +#define GLVERTEXATTRIB1F 818 +#define GLVERTEXATTRIB1FARB 819 +#define GLVERTEXATTRIB1FNV 820 +#define GLVERTEXATTRIB1FV 821 +#define GLVERTEXATTRIB1FVARB 822 +#define GLVERTEXATTRIB1FVNV 823 +#define GLVERTEXATTRIB1HNV 824 +#define GLVERTEXATTRIB1HVNV 825 +#define GLVERTEXATTRIB1S 826 +#define GLVERTEXATTRIB1SARB 827 +#define GLVERTEXATTRIB1SNV 828 +#define GLVERTEXATTRIB1SV 829 +#define GLVERTEXATTRIB1SVARB 830 +#define GLVERTEXATTRIB1SVNV 831 +#define GLVERTEXATTRIB2D 832 +#define GLVERTEXATTRIB2DARB 833 +#define GLVERTEXATTRIB2DNV 834 +#define GLVERTEXATTRIB2DV 835 +#define GLVERTEXATTRIB2DVARB 836 +#define GLVERTEXATTRIB2DVNV 837 +#define GLVERTEXATTRIB2F 838 +#define GLVERTEXATTRIB2FARB 839 +#define GLVERTEXATTRIB2FNV 840 +#define GLVERTEXATTRIB2FV 841 +#define GLVERTEXATTRIB2FVARB 842 +#define GLVERTEXATTRIB2FVNV 843 +#define GLVERTEXATTRIB2HNV 844 +#define GLVERTEXATTRIB2HVNV 845 +#define GLVERTEXATTRIB2S 846 +#define GLVERTEXATTRIB2SARB 847 +#define GLVERTEXATTRIB2SNV 848 +#define GLVERTEXATTRIB2SV 849 +#define GLVERTEXATTRIB2SVARB 850 +#define GLVERTEXATTRIB2SVNV 851 +#define GLVERTEXATTRIB3D 852 +#define GLVERTEXATTRIB3DARB 853 +#define GLVERTEXATTRIB3DNV 854 +#define GLVERTEXATTRIB3DV 855 +#define GLVERTEXATTRIB3DVARB 856 +#define GLVERTEXATTRIB3DVNV 857 +#define GLVERTEXATTRIB3F 858 +#define GLVERTEXATTRIB3FARB 859 +#define GLVERTEXATTRIB3FNV 860 +#define GLVERTEXATTRIB3FV 861 +#define GLVERTEXATTRIB3FVARB 862 +#define GLVERTEXATTRIB3FVNV 863 +#define GLVERTEXATTRIB3HNV 864 +#define GLVERTEXATTRIB3HVNV 865 +#define GLVERTEXATTRIB3S 866 +#define GLVERTEXATTRIB3SARB 867 +#define GLVERTEXATTRIB3SNV 868 +#define GLVERTEXATTRIB3SV 869 +#define GLVERTEXATTRIB3SVARB 870 +#define GLVERTEXATTRIB3SVNV 871 +#define GLVERTEXATTRIB4BV 872 +#define GLVERTEXATTRIB4BVARB 873 +#define GLVERTEXATTRIB4D 874 +#define GLVERTEXATTRIB4DARB 875 +#define GLVERTEXATTRIB4DNV 876 +#define GLVERTEXATTRIB4DV 877 +#define GLVERTEXATTRIB4DVARB 878 +#define GLVERTEXATTRIB4DVNV 879 +#define GLVERTEXATTRIB4F 880 +#define GLVERTEXATTRIB4FARB 881 +#define GLVERTEXATTRIB4FNV 882 +#define GLVERTEXATTRIB4FV 883 +#define GLVERTEXATTRIB4FVARB 884 +#define GLVERTEXATTRIB4FVNV 885 +#define GLVERTEXATTRIB4HNV 886 +#define GLVERTEXATTRIB4HVNV 887 +#define GLVERTEXATTRIB4IV 888 +#define GLVERTEXATTRIB4IVARB 889 +#define GLVERTEXATTRIB4NBV 890 +#define GLVERTEXATTRIB4NBVARB 891 +#define GLVERTEXATTRIB4NIV 892 +#define GLVERTEXATTRIB4NIVARB 893 +#define GLVERTEXATTRIB4NSV 894 +#define GLVERTEXATTRIB4NSVARB 895 +#define GLVERTEXATTRIB4NUB 896 +#define GLVERTEXATTRIB4NUBARB 897 +#define GLVERTEXATTRIB4NUBV 898 +#define GLVERTEXATTRIB4NUBVARB 899 +#define GLVERTEXATTRIB4NUIV 900 +#define GLVERTEXATTRIB4NUIVARB 901 +#define GLVERTEXATTRIB4NUSV 902 +#define GLVERTEXATTRIB4NUSVARB 903 +#define GLVERTEXATTRIB4S 904 +#define GLVERTEXATTRIB4SARB 905 +#define GLVERTEXATTRIB4SNV 906 +#define GLVERTEXATTRIB4SV 907 +#define GLVERTEXATTRIB4SVARB 908 +#define GLVERTEXATTRIB4SVNV 909 +#define GLVERTEXATTRIB4UBNV 910 +#define GLVERTEXATTRIB4UBV 911 +#define GLVERTEXATTRIB4UBVARB 912 +#define GLVERTEXATTRIB4UBVNV 913 +#define GLVERTEXATTRIB4UIV 914 +#define GLVERTEXATTRIB4UIVARB 915 +#define GLVERTEXATTRIB4USV 916 +#define GLVERTEXATTRIB4USVARB 917 +#define GLVERTEXATTRIBI1I 918 +#define GLVERTEXATTRIBI1IEXT 919 +#define GLVERTEXATTRIBI1IV 920 +#define GLVERTEXATTRIBI1IVEXT 921 +#define GLVERTEXATTRIBI1UI 922 +#define GLVERTEXATTRIBI1UIEXT 923 +#define GLVERTEXATTRIBI1UIV 924 +#define GLVERTEXATTRIBI1UIVEXT 925 +#define GLVERTEXATTRIBI2I 926 +#define GLVERTEXATTRIBI2IEXT 927 +#define GLVERTEXATTRIBI2IV 928 +#define GLVERTEXATTRIBI2IVEXT 929 +#define GLVERTEXATTRIBI2UI 930 +#define GLVERTEXATTRIBI2UIEXT 931 +#define GLVERTEXATTRIBI2UIV 932 +#define GLVERTEXATTRIBI2UIVEXT 933 +#define GLVERTEXATTRIBI3I 934 +#define GLVERTEXATTRIBI3IEXT 935 +#define GLVERTEXATTRIBI3IV 936 +#define GLVERTEXATTRIBI3IVEXT 937 +#define GLVERTEXATTRIBI3UI 938 +#define GLVERTEXATTRIBI3UIEXT 939 +#define GLVERTEXATTRIBI3UIV 940 +#define GLVERTEXATTRIBI3UIVEXT 941 +#define GLVERTEXATTRIBI4BV 942 +#define GLVERTEXATTRIBI4BVEXT 943 +#define GLVERTEXATTRIBI4I 944 +#define GLVERTEXATTRIBI4IEXT 945 +#define GLVERTEXATTRIBI4IV 946 +#define GLVERTEXATTRIBI4IVEXT 947 +#define GLVERTEXATTRIBI4SV 948 +#define GLVERTEXATTRIBI4SVEXT 949 +#define GLVERTEXATTRIBI4UBV 950 +#define GLVERTEXATTRIBI4UBVEXT 951 +#define GLVERTEXATTRIBI4UI 952 +#define GLVERTEXATTRIBI4UIEXT 953 +#define GLVERTEXATTRIBI4UIV 954 +#define GLVERTEXATTRIBI4UIVEXT 955 +#define GLVERTEXATTRIBI4USV 956 +#define GLVERTEXATTRIBI4USVEXT 957 +#define GLVERTEXATTRIBIPOINTER 958 +#define GLVERTEXATTRIBIPOINTEREXT 959 +#define GLVERTEXATTRIBPOINTER 960 +#define GLVERTEXATTRIBPOINTERNV 961 +#define GLVERTEXATTRIBS1DVNV 962 +#define GLVERTEXATTRIBS1FVNV 963 +#define GLVERTEXATTRIBS1HVNV 964 +#define GLVERTEXATTRIBS1SVNV 965 +#define GLVERTEXATTRIBS2DVNV 966 +#define GLVERTEXATTRIBS2FVNV 967 +#define GLVERTEXATTRIBS2HVNV 968 +#define GLVERTEXATTRIBS2SVNV 969 +#define GLVERTEXATTRIBS3DVNV 970 +#define GLVERTEXATTRIBS3FVNV 971 +#define GLVERTEXATTRIBS3HVNV 972 +#define GLVERTEXATTRIBS3SVNV 973 +#define GLVERTEXATTRIBS4DVNV 974 +#define GLVERTEXATTRIBS4FVNV 975 +#define GLVERTEXATTRIBS4HVNV 976 +#define GLVERTEXATTRIBS4SVNV 977 +#define GLVERTEXATTRIBS4UBVNV 978 +#define GLVERTEXPOINTEREXT 979 +#define GLWINDOWPOS2D 980 +#define GLWINDOWPOS2DARB 981 +#define GLWINDOWPOS2DV 982 +#define GLWINDOWPOS2DVARB 983 +#define GLWINDOWPOS2F 984 +#define GLWINDOWPOS2FARB 985 +#define GLWINDOWPOS2FV 986 +#define GLWINDOWPOS2FVARB 987 +#define GLWINDOWPOS2I 988 +#define GLWINDOWPOS2IARB 989 +#define GLWINDOWPOS2IV 990 +#define GLWINDOWPOS2IVARB 991 +#define GLWINDOWPOS2S 992 +#define GLWINDOWPOS2SARB 993 +#define GLWINDOWPOS2SV 994 +#define GLWINDOWPOS2SVARB 995 +#define GLWINDOWPOS3D 996 +#define GLWINDOWPOS3DARB 997 +#define GLWINDOWPOS3DV 998 +#define GLWINDOWPOS3DVARB 999 +#define GLWINDOWPOS3F 1000 +#define GLWINDOWPOS3FARB 1001 +#define GLWINDOWPOS3FV 1002 +#define GLWINDOWPOS3FVARB 1003 +#define GLWINDOWPOS3I 1004 +#define GLWINDOWPOS3IARB 1005 +#define GLWINDOWPOS3IV 1006 +#define GLWINDOWPOS3IVARB 1007 +#define GLWINDOWPOS3S 1008 +#define GLWINDOWPOS3SARB 1009 +#define GLWINDOWPOS3SV 1010 +#define GLWINDOWPOS3SVARB 1011 +#define WGLALLOCATEMEMORYNV 1012 +#define WGLBINDSWAPBARRIERNV 1013 +#define WGLBINDTEXIMAGEARB 1014 +#define WGLBINDVIDEOIMAGENV 1015 +#define WGLCHOOSEPIXELFORMATARB 1016 +#define WGLCREATEBUFFERREGIONARB 1017 +#define WGLCREATECONTEXTATTRIBSARB 1018 +#define WGLCREATEPBUFFERARB 1019 +#define WGLDELETEBUFFERREGIONARB 1020 +#define WGLDESTROYPBUFFERARB 1021 +#define WGLDXCLOSEDEVICENV 1022 +#define WGLDXLOCKOBJECTSNV 1023 +#define WGLDXOPENDEVICENV 1024 +#define WGLDXREGISTEROBJECTNV 1025 +#define WGLDXSETRESOURCESHAREHANDLENV 1026 +#define WGLDXUNLOCKOBJECTSNV 1027 +#define WGLDXUNREGISTEROBJECTNV 1028 +#define WGLFREEMEMORYNV 1029 +#define WGLGETCURRENTCONTEXT 1030 +#define WGLGETCURRENTREADDCARB 1031 +#define WGLGETEXTENSIONSSTRINGARB 1032 +#define WGLGETEXTENSIONSSTRINGEXT 1033 +#define WGLGETPBUFFERDCARB 1034 +#define WGLGETPIXELFORMATATTRIBFVARB 1035 +#define WGLGETPIXELFORMATATTRIBIVARB 1036 +#define WGLGETPROCADDRESS 1037 +#define WGLGETSWAPINTERVALEXT 1038 +#define WGLGETVIDEODEVICENV 1039 +#define WGLGETVIDEOINFONV 1040 +#define WGLJOINSWAPGROUPNV 1041 +#define WGLMAKECONTEXTCURRENTARB 1042 +#define WGLQUERYFRAMECOUNTNV 1043 +#define WGLQUERYMAXSWAPGROUPSNV 1044 +#define WGLQUERYPBUFFERARB 1045 +#define WGLQUERYSWAPGROUPNV 1046 +#define WGLRELEASEPBUFFERDCARB 1047 +#define WGLRELEASETEXIMAGEARB 1048 +#define WGLRELEASEVIDEODEVICENV 1049 +#define WGLRELEASEVIDEOIMAGENV 1050 +#define WGLRESETFRAMECOUNTNV 1051 +#define WGLRESTOREBUFFERREGIONARB 1052 +#define WGLSAVEBUFFERREGIONARB 1053 +#define WGLSENDPBUFFERTOVIDEONV 1054 +#define WGLSETPBUFFERATTRIBARB 1055 +#define WGLSWAPINTERVALEXT 1056 + +#define GLFINISHGLUT 0 +#define GLVIEWPORTGLUT 1 +#define WGLDELETECONTEXTGLUT 2 +#define WGLGETCURRENTCONTEXTGLUT 3 +#define WGLGETCURRENTDCGLUT 4 +#define WGLGETPROCADDRESSGLUT 5 +#define WGLMAKECURRENTGLUT 6 + +extern gl_func_struct gl_addr_dll[9]; +extern gl_func_struct gl_addr[1057]; +extern gl_func_struct gl_addr_glut[7]; + +#define glBlendFuncDLL ((PFNGLBLENDFUNCDLLPROC)gl_addr_dll[GLBLENDFUNCDLL].func) +#define glColorMaskDLL ((PFNGLCOLORMASKDLLPROC)gl_addr_dll[GLCOLORMASKDLL].func) +#define glDeleteTexturesDLL ((PFNGLDELETETEXTURESDLLPROC)gl_addr_dll[GLDELETETEXTURESDLL].func) +#define glDepthMaskDLL ((PFNGLDEPTHMASKDLLPROC)gl_addr_dll[GLDEPTHMASKDLL].func) +#define glFinishDLL ((PFNGLFINISHDLLPROC)gl_addr_dll[GLFINISHDLL].func) +#define glGenTexturesDLL ((PFNGLGENTEXTURESDLLPROC)gl_addr_dll[GLGENTEXTURESDLL].func) +#define glScissorDLL ((PFNGLSCISSORDLLPROC)gl_addr_dll[GLSCISSORDLL].func) +#define glViewportDLL ((PFNGLVIEWPORTDLLPROC)gl_addr_dll[GLVIEWPORTDLL].func) +#define wglGetProcAddressDLL ((PFNWGLGETPROCADDRESSDLLPROC)gl_addr_dll[WGLGETPROCADDRESSDLL].func) + +#define glActiveStencilFaceEXT ((PFNGLACTIVESTENCILFACEEXTPROC)gl_addr[GLACTIVESTENCILFACEEXT].func) +#define glActiveTextureARB ((PFNGLACTIVETEXTUREARBPROC)gl_addr[GLACTIVETEXTUREARB].func) +#define glActiveVaryingNV ((PFNGLACTIVEVARYINGNVPROC)gl_addr[GLACTIVEVARYINGNV].func) +#define glAreProgramsResidentNV ((PFNGLAREPROGRAMSRESIDENTNVPROC)gl_addr[GLAREPROGRAMSRESIDENTNV].func) +#define glAreTexturesResidentEXT ((PFNGLARETEXTURESRESIDENTEXTPROC)gl_addr[GLARETEXTURESRESIDENTEXT].func) +#define glArrayElementEXT ((PFNGLARRAYELEMENTEXTPROC)gl_addr[GLARRAYELEMENTEXT].func) +#define glAttachObjectARB ((PFNGLATTACHOBJECTARBPROC)gl_addr[GLATTACHOBJECTARB].func) +#define glAttachShader ((PFNGLATTACHSHADERPROC)gl_addr[GLATTACHSHADER].func) +#define glBeginConditionalRender ((PFNGLBEGINCONDITIONALRENDERPROC)gl_addr[GLBEGINCONDITIONALRENDER].func) +#define glBeginConditionalRenderNV ((PFNGLBEGINCONDITIONALRENDERNVPROC)gl_addr[GLBEGINCONDITIONALRENDERNV].func) +#define glBeginOcclusionQueryNV ((PFNGLBEGINOCCLUSIONQUERYNVPROC)gl_addr[GLBEGINOCCLUSIONQUERYNV].func) +#define glBeginQuery ((PFNGLBEGINQUERYPROC)gl_addr[GLBEGINQUERY].func) +#define glBeginQueryARB ((PFNGLBEGINQUERYARBPROC)gl_addr[GLBEGINQUERYARB].func) +#define glBeginTransformFeedback ((PFNGLBEGINTRANSFORMFEEDBACKPROC)gl_addr[GLBEGINTRANSFORMFEEDBACK].func) +#define glBeginTransformFeedbackNV ((PFNGLBEGINTRANSFORMFEEDBACKNVPROC)gl_addr[GLBEGINTRANSFORMFEEDBACKNV].func) +#define glBindAttribLocation ((PFNGLBINDATTRIBLOCATIONPROC)gl_addr[GLBINDATTRIBLOCATION].func) +#define glBindAttribLocationARB ((PFNGLBINDATTRIBLOCATIONARBPROC)gl_addr[GLBINDATTRIBLOCATIONARB].func) +#define glBindBuffer ((PFNGLBINDBUFFERPROC)gl_addr[GLBINDBUFFER].func) +#define glBindBufferBase ((PFNGLBINDBUFFERBASEPROC)gl_addr[GLBINDBUFFERBASE].func) +#define glBindBufferOffsetNV ((PFNGLBINDBUFFEROFFSETNVPROC)gl_addr[GLBINDBUFFEROFFSETNV].func) +#define glBindBufferRange ((PFNGLBINDBUFFERRANGEPROC)gl_addr[GLBINDBUFFERRANGE].func) +#define glBindBufferRangeNV ((PFNGLBINDBUFFERRANGENVPROC)gl_addr[GLBINDBUFFERRANGENV].func) +#define glBindFragDataLocation ((PFNGLBINDFRAGDATALOCATIONPROC)gl_addr[GLBINDFRAGDATALOCATION].func) +#define glBindFragDataLocationEXT ((PFNGLBINDFRAGDATALOCATIONEXTPROC)gl_addr[GLBINDFRAGDATALOCATIONEXT].func) +#define glBindFramebuffer ((PFNGLBINDFRAMEBUFFERPROC)gl_addr[GLBINDFRAMEBUFFER].func) +#define glBindProgramARB ((PFNGLBINDPROGRAMARBPROC)gl_addr[GLBINDPROGRAMARB].func) +#define glBindProgramNV ((PFNGLBINDPROGRAMNVPROC)gl_addr[GLBINDPROGRAMNV].func) +#define glBindRenderbuffer ((PFNGLBINDRENDERBUFFERPROC)gl_addr[GLBINDRENDERBUFFER].func) +#define glBindSampler ((PFNGLBINDSAMPLERPROC)gl_addr[GLBINDSAMPLER].func) +#define glBindTextureEXT ((PFNGLBINDTEXTUREEXTPROC)gl_addr[GLBINDTEXTUREEXT].func) +#define glBindVertexArray ((PFNGLBINDVERTEXARRAYPROC)gl_addr[GLBINDVERTEXARRAY].func) +#define glBlendColor ((PFNGLBLENDCOLORPROC)gl_addr[GLBLENDCOLOR].func) +#define glBlendColorEXT ((PFNGLBLENDCOLOREXTPROC)gl_addr[GLBLENDCOLOREXT].func) +#define glBlendEquation ((PFNGLBLENDEQUATIONPROC)gl_addr[GLBLENDEQUATION].func) +#define glBlendEquationEXT ((PFNGLBLENDEQUATIONEXTPROC)gl_addr[GLBLENDEQUATIONEXT].func) +#define glBlendEquationSeparate ((PFNGLBLENDEQUATIONSEPARATEPROC)gl_addr[GLBLENDEQUATIONSEPARATE].func) +#define glBlendEquationSeparateEXT ((PFNGLBLENDEQUATIONSEPARATEEXTPROC)gl_addr[GLBLENDEQUATIONSEPARATEEXT].func) +#define glBlendFuncSeparate ((PFNGLBLENDFUNCSEPARATEPROC)gl_addr[GLBLENDFUNCSEPARATE].func) +#define glBlendFuncSeparateEXT ((PFNGLBLENDFUNCSEPARATEEXTPROC)gl_addr[GLBLENDFUNCSEPARATEEXT].func) +#define glBlitFramebuffer ((PFNGLBLITFRAMEBUFFERPROC)gl_addr[GLBLITFRAMEBUFFER].func) +#define glBlitFramebufferEXT ((PFNGLBLITFRAMEBUFFEREXTPROC)gl_addr[GLBLITFRAMEBUFFEREXT].func) +#define glBufferData ((PFNGLBUFFERDATAPROC)gl_addr[GLBUFFERDATA].func) +#define glBufferSubData ((PFNGLBUFFERSUBDATAPROC)gl_addr[GLBUFFERSUBDATA].func) +#define glBufferSubDataARB ((PFNGLBUFFERSUBDATAARBPROC)gl_addr[GLBUFFERSUBDATAARB].func) +#define glCheckFramebufferStatus ((PFNGLCHECKFRAMEBUFFERSTATUSPROC)gl_addr[GLCHECKFRAMEBUFFERSTATUS].func) +#define glCheckFramebufferStatusEXT ((PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC)gl_addr[GLCHECKFRAMEBUFFERSTATUSEXT].func) +#define glCheckNamedFramebufferStatusEXT ((PFNGLCHECKNAMEDFRAMEBUFFERSTATUSEXTPROC)gl_addr[GLCHECKNAMEDFRAMEBUFFERSTATUSEXT].func) +#define glClearBufferfi ((PFNGLCLEARBUFFERFIPROC)gl_addr[GLCLEARBUFFERFI].func) +#define glClearBufferfv ((PFNGLCLEARBUFFERFVPROC)gl_addr[GLCLEARBUFFERFV].func) +#define glClearBufferiv ((PFNGLCLEARBUFFERIVPROC)gl_addr[GLCLEARBUFFERIV].func) +#define glClearBufferuiv ((PFNGLCLEARBUFFERUIVPROC)gl_addr[GLCLEARBUFFERUIV].func) +#define glClearColorIiEXT ((PFNGLCLEARCOLORIIEXTPROC)gl_addr[GLCLEARCOLORIIEXT].func) +#define glClearColorIuiEXT ((PFNGLCLEARCOLORIUIEXTPROC)gl_addr[GLCLEARCOLORIUIEXT].func) +#define glClearDepthdNV ((PFNGLCLEARDEPTHDNVPROC)gl_addr[GLCLEARDEPTHDNV].func) +#define glClientActiveTextureARB ((PFNGLCLIENTACTIVETEXTUREARBPROC)gl_addr[GLCLIENTACTIVETEXTUREARB].func) +#define glClientAttribDefaultEXT ((PFNGLCLIENTATTRIBDEFAULTEXTPROC)gl_addr[GLCLIENTATTRIBDEFAULTEXT].func) +#define glColor3hNV ((PFNGLCOLOR3HNVPROC)gl_addr[GLCOLOR3HNV].func) +#define glColor3hvNV ((PFNGLCOLOR3HVNVPROC)gl_addr[GLCOLOR3HVNV].func) +#define glColor4hNV ((PFNGLCOLOR4HNVPROC)gl_addr[GLCOLOR4HNV].func) +#define glColor4hvNV ((PFNGLCOLOR4HVNVPROC)gl_addr[GLCOLOR4HVNV].func) +#define glColorMaski ((PFNGLCOLORMASKIPROC)gl_addr[GLCOLORMASKI].func) +#define glColorMaskIndexedEXT ((PFNGLCOLORMASKINDEXEDEXTPROC)gl_addr[GLCOLORMASKINDEXEDEXT].func) +#define glColorPointerEXT ((PFNGLCOLORPOINTEREXTPROC)gl_addr[GLCOLORPOINTEREXT].func) +#define glColorSubTable ((PFNGLCOLORSUBTABLEPROC)gl_addr[GLCOLORSUBTABLE].func) +#define glColorSubTableEXT ((PFNGLCOLORSUBTABLEEXTPROC)gl_addr[GLCOLORSUBTABLEEXT].func) +#define glColorTable ((PFNGLCOLORTABLEPROC)gl_addr[GLCOLORTABLE].func) +#define glColorTableEXT ((PFNGLCOLORTABLEEXTPROC)gl_addr[GLCOLORTABLEEXT].func) +#define glColorTableParameterfv ((PFNGLCOLORTABLEPARAMETERFVPROC)gl_addr[GLCOLORTABLEPARAMETERFV].func) +#define glColorTableParameteriv ((PFNGLCOLORTABLEPARAMETERIVPROC)gl_addr[GLCOLORTABLEPARAMETERIV].func) +#define glCombinerInputNV ((PFNGLCOMBINERINPUTNVPROC)gl_addr[GLCOMBINERINPUTNV].func) +#define glCombinerOutputNV ((PFNGLCOMBINEROUTPUTNVPROC)gl_addr[GLCOMBINEROUTPUTNV].func) +#define glCombinerParameterfNV ((PFNGLCOMBINERPARAMETERFNVPROC)gl_addr[GLCOMBINERPARAMETERFNV].func) +#define glCombinerParameterfvNV ((PFNGLCOMBINERPARAMETERFVNVPROC)gl_addr[GLCOMBINERPARAMETERFVNV].func) +#define glCombinerParameteriNV ((PFNGLCOMBINERPARAMETERINVPROC)gl_addr[GLCOMBINERPARAMETERINV].func) +#define glCombinerParameterivNV ((PFNGLCOMBINERPARAMETERIVNVPROC)gl_addr[GLCOMBINERPARAMETERIVNV].func) +#define glCombinerStageParameterfvNV ((PFNGLCOMBINERSTAGEPARAMETERFVNVPROC)gl_addr[GLCOMBINERSTAGEPARAMETERFVNV].func) +#define glCompileShader ((PFNGLCOMPILESHADERPROC)gl_addr[GLCOMPILESHADER].func) +#define glCompileShaderARB ((PFNGLCOMPILESHADERARBPROC)gl_addr[GLCOMPILESHADERARB].func) +#define glCompressedMultiTexImage1DEXT ((PFNGLCOMPRESSEDMULTITEXIMAGE1DEXTPROC)gl_addr[GLCOMPRESSEDMULTITEXIMAGE1DEXT].func) +#define glCompressedMultiTexImage2DEXT ((PFNGLCOMPRESSEDMULTITEXIMAGE2DEXTPROC)gl_addr[GLCOMPRESSEDMULTITEXIMAGE2DEXT].func) +#define glCompressedMultiTexImage3DEXT ((PFNGLCOMPRESSEDMULTITEXIMAGE3DEXTPROC)gl_addr[GLCOMPRESSEDMULTITEXIMAGE3DEXT].func) +#define glCompressedMultiTexSubImage1DEXT ((PFNGLCOMPRESSEDMULTITEXSUBIMAGE1DEXTPROC)gl_addr[GLCOMPRESSEDMULTITEXSUBIMAGE1DEXT].func) +#define glCompressedMultiTexSubImage2DEXT ((PFNGLCOMPRESSEDMULTITEXSUBIMAGE2DEXTPROC)gl_addr[GLCOMPRESSEDMULTITEXSUBIMAGE2DEXT].func) +#define glCompressedMultiTexSubImage3DEXT ((PFNGLCOMPRESSEDMULTITEXSUBIMAGE3DEXTPROC)gl_addr[GLCOMPRESSEDMULTITEXSUBIMAGE3DEXT].func) +#define glCompressedTexImage1D ((PFNGLCOMPRESSEDTEXIMAGE1DPROC)gl_addr[GLCOMPRESSEDTEXIMAGE1D].func) +#define glCompressedTexImage1DARB ((PFNGLCOMPRESSEDTEXIMAGE1DARBPROC)gl_addr[GLCOMPRESSEDTEXIMAGE1DARB].func) +#define glCompressedTexImage2D ((PFNGLCOMPRESSEDTEXIMAGE2DPROC)gl_addr[GLCOMPRESSEDTEXIMAGE2D].func) +#define glCompressedTexImage2DARB ((PFNGLCOMPRESSEDTEXIMAGE2DARBPROC)gl_addr[GLCOMPRESSEDTEXIMAGE2DARB].func) +#define glCompressedTexImage3D ((PFNGLCOMPRESSEDTEXIMAGE3DPROC)gl_addr[GLCOMPRESSEDTEXIMAGE3D].func) +#define glCompressedTexImage3DARB ((PFNGLCOMPRESSEDTEXIMAGE3DARBPROC)gl_addr[GLCOMPRESSEDTEXIMAGE3DARB].func) +#define glCompressedTexSubImage1D ((PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC)gl_addr[GLCOMPRESSEDTEXSUBIMAGE1D].func) +#define glCompressedTexSubImage1DARB ((PFNGLCOMPRESSEDTEXSUBIMAGE1DARBPROC)gl_addr[GLCOMPRESSEDTEXSUBIMAGE1DARB].func) +#define glCompressedTexSubImage2D ((PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC)gl_addr[GLCOMPRESSEDTEXSUBIMAGE2D].func) +#define glCompressedTexSubImage2DARB ((PFNGLCOMPRESSEDTEXSUBIMAGE2DARBPROC)gl_addr[GLCOMPRESSEDTEXSUBIMAGE2DARB].func) +#define glCompressedTexSubImage3D ((PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC)gl_addr[GLCOMPRESSEDTEXSUBIMAGE3D].func) +#define glCompressedTexSubImage3DARB ((PFNGLCOMPRESSEDTEXSUBIMAGE3DARBPROC)gl_addr[GLCOMPRESSEDTEXSUBIMAGE3DARB].func) +#define glCompressedTextureImage1DEXT ((PFNGLCOMPRESSEDTEXTUREIMAGE1DEXTPROC)gl_addr[GLCOMPRESSEDTEXTUREIMAGE1DEXT].func) +#define glCompressedTextureImage2DEXT ((PFNGLCOMPRESSEDTEXTUREIMAGE2DEXTPROC)gl_addr[GLCOMPRESSEDTEXTUREIMAGE2DEXT].func) +#define glCompressedTextureImage3DEXT ((PFNGLCOMPRESSEDTEXTUREIMAGE3DEXTPROC)gl_addr[GLCOMPRESSEDTEXTUREIMAGE3DEXT].func) +#define glCompressedTextureSubImage1DEXT ((PFNGLCOMPRESSEDTEXTURESUBIMAGE1DEXTPROC)gl_addr[GLCOMPRESSEDTEXTURESUBIMAGE1DEXT].func) +#define glCompressedTextureSubImage2DEXT ((PFNGLCOMPRESSEDTEXTURESUBIMAGE2DEXTPROC)gl_addr[GLCOMPRESSEDTEXTURESUBIMAGE2DEXT].func) +#define glCompressedTextureSubImage3DEXT ((PFNGLCOMPRESSEDTEXTURESUBIMAGE3DEXTPROC)gl_addr[GLCOMPRESSEDTEXTURESUBIMAGE3DEXT].func) +#define glConvolutionFilter1D ((PFNGLCONVOLUTIONFILTER1DPROC)gl_addr[GLCONVOLUTIONFILTER1D].func) +#define glConvolutionFilter2D ((PFNGLCONVOLUTIONFILTER2DPROC)gl_addr[GLCONVOLUTIONFILTER2D].func) +#define glConvolutionParameterf ((PFNGLCONVOLUTIONPARAMETERFPROC)gl_addr[GLCONVOLUTIONPARAMETERF].func) +#define glConvolutionParameterfv ((PFNGLCONVOLUTIONPARAMETERFVPROC)gl_addr[GLCONVOLUTIONPARAMETERFV].func) +#define glConvolutionParameteri ((PFNGLCONVOLUTIONPARAMETERIPROC)gl_addr[GLCONVOLUTIONPARAMETERI].func) +#define glConvolutionParameteriv ((PFNGLCONVOLUTIONPARAMETERIVPROC)gl_addr[GLCONVOLUTIONPARAMETERIV].func) +#define glCopyColorSubTable ((PFNGLCOPYCOLORSUBTABLEPROC)gl_addr[GLCOPYCOLORSUBTABLE].func) +#define glCopyColorTable ((PFNGLCOPYCOLORTABLEPROC)gl_addr[GLCOPYCOLORTABLE].func) +#define glCopyConvolutionFilter1D ((PFNGLCOPYCONVOLUTIONFILTER1DPROC)gl_addr[GLCOPYCONVOLUTIONFILTER1D].func) +#define glCopyConvolutionFilter2D ((PFNGLCOPYCONVOLUTIONFILTER2DPROC)gl_addr[GLCOPYCONVOLUTIONFILTER2D].func) +#define glCopyImageSubData ((PFNGLCOPYIMAGESUBDATAPROC)gl_addr[GLCOPYIMAGESUBDATA].func) +#define glCopyMultiTexImage1DEXT ((PFNGLCOPYMULTITEXIMAGE1DEXTPROC)gl_addr[GLCOPYMULTITEXIMAGE1DEXT].func) +#define glCopyMultiTexImage2DEXT ((PFNGLCOPYMULTITEXIMAGE2DEXTPROC)gl_addr[GLCOPYMULTITEXIMAGE2DEXT].func) +#define glCopyMultiTexSubImage1DEXT ((PFNGLCOPYMULTITEXSUBIMAGE1DEXTPROC)gl_addr[GLCOPYMULTITEXSUBIMAGE1DEXT].func) +#define glCopyMultiTexSubImage3DEXT ((PFNGLCOPYMULTITEXSUBIMAGE3DEXTPROC)gl_addr[GLCOPYMULTITEXSUBIMAGE3DEXT].func) +#define glCopyTexSubImage3D ((PFNGLCOPYTEXSUBIMAGE3DPROC)gl_addr[GLCOPYTEXSUBIMAGE3D].func) +#define glCopyTexSubImage3DEXT ((PFNGLCOPYTEXSUBIMAGE3DEXTPROC)gl_addr[GLCOPYTEXSUBIMAGE3DEXT].func) +#define glCopyTextureImage1DEXT ((PFNGLCOPYTEXTUREIMAGE1DEXTPROC)gl_addr[GLCOPYTEXTUREIMAGE1DEXT].func) +#define glCopyTextureImage2DEXT ((PFNGLCOPYTEXTUREIMAGE2DEXTPROC)gl_addr[GLCOPYTEXTUREIMAGE2DEXT].func) +#define glCopyTextureSubImage1DEXT ((PFNGLCOPYTEXTURESUBIMAGE1DEXTPROC)gl_addr[GLCOPYTEXTURESUBIMAGE1DEXT].func) +#define glCopyTextureSubImage2DEXT ((PFNGLCOPYTEXTURESUBIMAGE2DEXTPROC)gl_addr[GLCOPYTEXTURESUBIMAGE2DEXT].func) +#define glCopyTextureSubImage3DEXT ((PFNGLCOPYTEXTURESUBIMAGE3DEXTPROC)gl_addr[GLCOPYTEXTURESUBIMAGE3DEXT].func) +#define glCreateProgram ((PFNGLCREATEPROGRAMPROC)gl_addr[GLCREATEPROGRAM].func) +#define glCreateProgramObjectARB ((PFNGLCREATEPROGRAMOBJECTARBPROC)gl_addr[GLCREATEPROGRAMOBJECTARB].func) +#define glCreateShader ((PFNGLCREATESHADERPROC)gl_addr[GLCREATESHADER].func) +#define glCreateShaderObjectARB ((PFNGLCREATESHADEROBJECTARBPROC)gl_addr[GLCREATESHADEROBJECTARB].func) +#define glDeleteBuffers ((PFNGLDELETEBUFFERSPROC)gl_addr[GLDELETEBUFFERS].func) +#define glDeleteFencesNV ((PFNGLDELETEFENCESNVPROC)gl_addr[GLDELETEFENCESNV].func) +#define glDeleteFramebuffers ((PFNGLDELETEFRAMEBUFFERSPROC)gl_addr[GLDELETEFRAMEBUFFERS].func) +#define glDeleteObjectARB ((PFNGLDELETEOBJECTARBPROC)gl_addr[GLDELETEOBJECTARB].func) +#define glDeleteOcclusionQueriesNV ((PFNGLDELETEOCCLUSIONQUERIESNVPROC)gl_addr[GLDELETEOCCLUSIONQUERIESNV].func) +#define glDeleteProgram ((PFNGLDELETEPROGRAMPROC)gl_addr[GLDELETEPROGRAM].func) +#define glDeleteProgramsARB ((PFNGLDELETEPROGRAMSARBPROC)gl_addr[GLDELETEPROGRAMSARB].func) +#define glDeleteProgramsNV ((PFNGLDELETEPROGRAMSNVPROC)gl_addr[GLDELETEPROGRAMSNV].func) +#define glDeleteQueries ((PFNGLDELETEQUERIESPROC)gl_addr[GLDELETEQUERIES].func) +#define glDeleteQueriesARB ((PFNGLDELETEQUERIESARBPROC)gl_addr[GLDELETEQUERIESARB].func) +#define glDeleteRenderbuffers ((PFNGLDELETERENDERBUFFERSPROC)gl_addr[GLDELETERENDERBUFFERS].func) +#define glDeleteSamplers ((PFNGLDELETESAMPLERSPROC)gl_addr[GLDELETESAMPLERS].func) +#define glDeleteShader ((PFNGLDELETESHADERPROC)gl_addr[GLDELETESHADER].func) +#define glDeleteTexturesEXT ((PFNGLDELETETEXTURESEXTPROC)gl_addr[GLDELETETEXTURESEXT].func) +#define glDeleteVertexArrays ((PFNGLDELETEVERTEXARRAYSPROC)gl_addr[GLDELETEVERTEXARRAYS].func) +#define glDepthBoundsdNV ((PFNGLDEPTHBOUNDSDNVPROC)gl_addr[GLDEPTHBOUNDSDNV].func) +#define glDepthBoundsEXT ((PFNGLDEPTHBOUNDSEXTPROC)gl_addr[GLDEPTHBOUNDSEXT].func) +#define glDepthRangedNV ((PFNGLDEPTHRANGEDNVPROC)gl_addr[GLDEPTHRANGEDNV].func) +#define glDetachObjectARB ((PFNGLDETACHOBJECTARBPROC)gl_addr[GLDETACHOBJECTARB].func) +#define glDetachShader ((PFNGLDETACHSHADERPROC)gl_addr[GLDETACHSHADER].func) +#define glDisableClientStateIndexedEXT ((PFNGLDISABLECLIENTSTATEINDEXEDEXTPROC)gl_addr[GLDISABLECLIENTSTATEINDEXEDEXT].func) +#define glDisablei ((PFNGLDISABLEIPROC)gl_addr[GLDISABLEI].func) +#define glDisableIndexedEXT ((PFNGLDISABLEINDEXEDEXTPROC)gl_addr[GLDISABLEINDEXEDEXT].func) +#define glDisableVertexAttribArray ((PFNGLDISABLEVERTEXATTRIBARRAYPROC)gl_addr[GLDISABLEVERTEXATTRIBARRAY].func) +#define glDrawArraysEXT ((PFNGLDRAWARRAYSEXTPROC)gl_addr[GLDRAWARRAYSEXT].func) +#define glDrawArraysInstancedARB ((PFNGLDRAWARRAYSINSTANCEDARBPROC)gl_addr[GLDRAWARRAYSINSTANCEDARB].func) +#define glDrawArraysInstancedEXT ((PFNGLDRAWARRAYSINSTANCEDEXTPROC)gl_addr[GLDRAWARRAYSINSTANCEDEXT].func) +#define glDrawBuffers ((PFNGLDRAWBUFFERSPROC)gl_addr[GLDRAWBUFFERS].func) +#define glDrawBuffersARB ((PFNGLDRAWBUFFERSARBPROC)gl_addr[GLDRAWBUFFERSARB].func) +#define glDrawBuffersATI ((PFNGLDRAWBUFFERSATIPROC)gl_addr[GLDRAWBUFFERSATI].func) +#define glDrawElementsInstancedARB ((PFNGLDRAWELEMENTSINSTANCEDARBPROC)gl_addr[GLDRAWELEMENTSINSTANCEDARB].func) +#define glDrawElementsInstancedEXT ((PFNGLDRAWELEMENTSINSTANCEDEXTPROC)gl_addr[GLDRAWELEMENTSINSTANCEDEXT].func) +#define glDrawRangeElementsEXT ((PFNGLDRAWRANGEELEMENTSEXTPROC)gl_addr[GLDRAWRANGEELEMENTSEXT].func) +#define glEdgeFlagPointerEXT ((PFNGLEDGEFLAGPOINTEREXTPROC)gl_addr[GLEDGEFLAGPOINTEREXT].func) +#define glEnableClientStateIndexedEXT ((PFNGLENABLECLIENTSTATEINDEXEDEXTPROC)gl_addr[GLENABLECLIENTSTATEINDEXEDEXT].func) +#define glEnablei ((PFNGLENABLEIPROC)gl_addr[GLENABLEI].func) +#define glEnableIndexedEXT ((PFNGLENABLEINDEXEDEXTPROC)gl_addr[GLENABLEINDEXEDEXT].func) +#define glEndConditionalRender ((PFNGLENDCONDITIONALRENDERPROC)gl_addr[GLENDCONDITIONALRENDER].func) +#define glEndConditionalRenderNV ((PFNGLENDCONDITIONALRENDERNVPROC)gl_addr[GLENDCONDITIONALRENDERNV].func) +#define glEndOcclusionQueryNV ((PFNGLENDOCCLUSIONQUERYNVPROC)gl_addr[GLENDOCCLUSIONQUERYNV].func) +#define glEndQuery ((PFNGLENDQUERYPROC)gl_addr[GLENDQUERY].func) +#define glEndQueryARB ((PFNGLENDQUERYARBPROC)gl_addr[GLENDQUERYARB].func) +#define glEndTransformFeedback ((PFNGLENDTRANSFORMFEEDBACKPROC)gl_addr[GLENDTRANSFORMFEEDBACK].func) +#define glEndTransformFeedbackNV ((PFNGLENDTRANSFORMFEEDBACKNVPROC)gl_addr[GLENDTRANSFORMFEEDBACKNV].func) +#define glExecuteProgramNV ((PFNGLEXECUTEPROGRAMNVPROC)gl_addr[GLEXECUTEPROGRAMNV].func) +#define glFinalCombinerInputNV ((PFNGLFINALCOMBINERINPUTNVPROC)gl_addr[GLFINALCOMBINERINPUTNV].func) +#define glFinishFenceNV ((PFNGLFINISHFENCENVPROC)gl_addr[GLFINISHFENCENV].func) +#define glFlushMappedBufferRange ((PFNGLFLUSHMAPPEDBUFFERRANGEPROC)gl_addr[GLFLUSHMAPPEDBUFFERRANGE].func) +#define glFlushPixelDataRangeNV ((PFNGLFLUSHPIXELDATARANGENVPROC)gl_addr[GLFLUSHPIXELDATARANGENV].func) +#define glFlushVertexArrayRangeNV ((PFNGLFLUSHVERTEXARRAYRANGENVPROC)gl_addr[GLFLUSHVERTEXARRAYRANGENV].func) +#define glFogCoordd ((PFNGLFOGCOORDDPROC)gl_addr[GLFOGCOORDD].func) +#define glFogCoorddEXT ((PFNGLFOGCOORDDEXTPROC)gl_addr[GLFOGCOORDDEXT].func) +#define glFogCoorddv ((PFNGLFOGCOORDDVPROC)gl_addr[GLFOGCOORDDV].func) +#define glFogCoorddvEXT ((PFNGLFOGCOORDDVEXTPROC)gl_addr[GLFOGCOORDDVEXT].func) +#define glFogCoordf ((PFNGLFOGCOORDFPROC)gl_addr[GLFOGCOORDF].func) +#define glFogCoordfEXT ((PFNGLFOGCOORDFEXTPROC)gl_addr[GLFOGCOORDFEXT].func) +#define glFogCoordfv ((PFNGLFOGCOORDFVPROC)gl_addr[GLFOGCOORDFV].func) +#define glFogCoordfvEXT ((PFNGLFOGCOORDFVEXTPROC)gl_addr[GLFOGCOORDFVEXT].func) +#define glFogCoordhNV ((PFNGLFOGCOORDHNVPROC)gl_addr[GLFOGCOORDHNV].func) +#define glFogCoordhvNV ((PFNGLFOGCOORDHVNVPROC)gl_addr[GLFOGCOORDHVNV].func) +#define glFogCoordPointer ((PFNGLFOGCOORDPOINTERPROC)gl_addr[GLFOGCOORDPOINTER].func) +#define glFogCoordPointerEXT ((PFNGLFOGCOORDPOINTEREXTPROC)gl_addr[GLFOGCOORDPOINTEREXT].func) +#define glFramebufferDrawBufferEXT ((PFNGLFRAMEBUFFERDRAWBUFFEREXTPROC)gl_addr[GLFRAMEBUFFERDRAWBUFFEREXT].func) +#define glFramebufferDrawBuffersEXT ((PFNGLFRAMEBUFFERDRAWBUFFERSEXTPROC)gl_addr[GLFRAMEBUFFERDRAWBUFFERSEXT].func) +#define glFramebufferReadBufferEXT ((PFNGLFRAMEBUFFERREADBUFFEREXTPROC)gl_addr[GLFRAMEBUFFERREADBUFFEREXT].func) +#define glFramebufferRenderbuffer ((PFNGLFRAMEBUFFERRENDERBUFFERPROC)gl_addr[GLFRAMEBUFFERRENDERBUFFER].func) +#define glFramebufferTexture ((PFNGLFRAMEBUFFERTEXTUREPROC)gl_addr[GLFRAMEBUFFERTEXTURE].func) +#define glFramebufferTexture1D ((PFNGLFRAMEBUFFERTEXTURE1DPROC)gl_addr[GLFRAMEBUFFERTEXTURE1D].func) +#define glFramebufferTexture1DEXT ((PFNGLFRAMEBUFFERTEXTURE1DEXTPROC)gl_addr[GLFRAMEBUFFERTEXTURE1DEXT].func) +#define glFramebufferTexture2D ((PFNGLFRAMEBUFFERTEXTURE2DPROC)gl_addr[GLFRAMEBUFFERTEXTURE2D].func) +#define glFramebufferTexture3D ((PFNGLFRAMEBUFFERTEXTURE3DPROC)gl_addr[GLFRAMEBUFFERTEXTURE3D].func) +#define glFramebufferTexture3DEXT ((PFNGLFRAMEBUFFERTEXTURE3DEXTPROC)gl_addr[GLFRAMEBUFFERTEXTURE3DEXT].func) +#define glFramebufferTextureARB ((PFNGLFRAMEBUFFERTEXTUREARBPROC)gl_addr[GLFRAMEBUFFERTEXTUREARB].func) +#define glFramebufferTextureEXT ((PFNGLFRAMEBUFFERTEXTUREEXTPROC)gl_addr[GLFRAMEBUFFERTEXTUREEXT].func) +#define glFramebufferTextureFaceARB ((PFNGLFRAMEBUFFERTEXTUREFACEARBPROC)gl_addr[GLFRAMEBUFFERTEXTUREFACEARB].func) +#define glFramebufferTextureFaceEXT ((PFNGLFRAMEBUFFERTEXTUREFACEEXTPROC)gl_addr[GLFRAMEBUFFERTEXTUREFACEEXT].func) +#define glFramebufferTextureLayer ((PFNGLFRAMEBUFFERTEXTURELAYERPROC)gl_addr[GLFRAMEBUFFERTEXTURELAYER].func) +#define glFramebufferTextureLayerARB ((PFNGLFRAMEBUFFERTEXTURELAYERARBPROC)gl_addr[GLFRAMEBUFFERTEXTURELAYERARB].func) +#define glFramebufferTextureLayerEXT ((PFNGLFRAMEBUFFERTEXTURELAYEREXTPROC)gl_addr[GLFRAMEBUFFERTEXTURELAYEREXT].func) +#define glGenBuffers ((PFNGLGENBUFFERSPROC)gl_addr[GLGENBUFFERS].func) +#define glGenBuffersARB ((PFNGLGENBUFFERSARBPROC)gl_addr[GLGENBUFFERSARB].func) +#define glGenerateMipmap ((PFNGLGENERATEMIPMAPPROC)gl_addr[GLGENERATEMIPMAP].func) +#define glGenerateMipmapEXT ((PFNGLGENERATEMIPMAPEXTPROC)gl_addr[GLGENERATEMIPMAPEXT].func) +#define glGenerateMultiTexMipmapEXT ((PFNGLGENERATEMULTITEXMIPMAPEXTPROC)gl_addr[GLGENERATEMULTITEXMIPMAPEXT].func) +#define glGenerateTextureMipmapEXT ((PFNGLGENERATETEXTUREMIPMAPEXTPROC)gl_addr[GLGENERATETEXTUREMIPMAPEXT].func) +#define glGenFencesNV ((PFNGLGENFENCESNVPROC)gl_addr[GLGENFENCESNV].func) +#define glGenFramebuffers ((PFNGLGENFRAMEBUFFERSPROC)gl_addr[GLGENFRAMEBUFFERS].func) +#define glGenOcclusionQueriesNV ((PFNGLGENOCCLUSIONQUERIESNVPROC)gl_addr[GLGENOCCLUSIONQUERIESNV].func) +#define glGenProgramsARB ((PFNGLGENPROGRAMSARBPROC)gl_addr[GLGENPROGRAMSARB].func) +#define glGenProgramsNV ((PFNGLGENPROGRAMSNVPROC)gl_addr[GLGENPROGRAMSNV].func) +#define glGenQueries ((PFNGLGENQUERIESPROC)gl_addr[GLGENQUERIES].func) +#define glGenQueriesARB ((PFNGLGENQUERIESARBPROC)gl_addr[GLGENQUERIESARB].func) +#define glGenRenderbuffers ((PFNGLGENRENDERBUFFERSPROC)gl_addr[GLGENRENDERBUFFERS].func) +#define glGenSamplers ((PFNGLGENSAMPLERSPROC)gl_addr[GLGENSAMPLERS].func) +#define glGenTexturesEXT ((PFNGLGENTEXTURESEXTPROC)gl_addr[GLGENTEXTURESEXT].func) +#define glGenVertexArrays ((PFNGLGENVERTEXARRAYSPROC)gl_addr[GLGENVERTEXARRAYS].func) +#define glGetActiveAttrib ((PFNGLGETACTIVEATTRIBPROC)gl_addr[GLGETACTIVEATTRIB].func) +#define glGetActiveAttribARB ((PFNGLGETACTIVEATTRIBARBPROC)gl_addr[GLGETACTIVEATTRIBARB].func) +#define glGetActiveUniform ((PFNGLGETACTIVEUNIFORMPROC)gl_addr[GLGETACTIVEUNIFORM].func) +#define glGetActiveUniformARB ((PFNGLGETACTIVEUNIFORMARBPROC)gl_addr[GLGETACTIVEUNIFORMARB].func) +#define glGetActiveVaryingNV ((PFNGLGETACTIVEVARYINGNVPROC)gl_addr[GLGETACTIVEVARYINGNV].func) +#define glGetAttachedObjectsARB ((PFNGLGETATTACHEDOBJECTSARBPROC)gl_addr[GLGETATTACHEDOBJECTSARB].func) +#define glGetAttachedShaders ((PFNGLGETATTACHEDSHADERSPROC)gl_addr[GLGETATTACHEDSHADERS].func) +#define glGetAttribLocation ((PFNGLGETATTRIBLOCATIONPROC)gl_addr[GLGETATTRIBLOCATION].func) +#define glGetAttribLocationARB ((PFNGLGETATTRIBLOCATIONARBPROC)gl_addr[GLGETATTRIBLOCATIONARB].func) +#define glGetBooleani_v ((PFNGLGETBOOLEANI_VPROC)gl_addr[GLGETBOOLEANI_V].func) +#define glGetBooleanIndexedvEXT ((PFNGLGETBOOLEANINDEXEDVEXTPROC)gl_addr[GLGETBOOLEANINDEXEDVEXT].func) +#define glGetBufferParameteriv ((PFNGLGETBUFFERPARAMETERIVPROC)gl_addr[GLGETBUFFERPARAMETERIV].func) +#define glGetBufferParameterivARB ((PFNGLGETBUFFERPARAMETERIVARBPROC)gl_addr[GLGETBUFFERPARAMETERIVARB].func) +#define glGetBufferPointerv ((PFNGLGETBUFFERPOINTERVPROC)gl_addr[GLGETBUFFERPOINTERV].func) +#define glGetBufferPointervARB ((PFNGLGETBUFFERPOINTERVARBPROC)gl_addr[GLGETBUFFERPOINTERVARB].func) +#define glGetBufferSubData ((PFNGLGETBUFFERSUBDATAPROC)gl_addr[GLGETBUFFERSUBDATA].func) +#define glGetBufferSubDataARB ((PFNGLGETBUFFERSUBDATAARBPROC)gl_addr[GLGETBUFFERSUBDATAARB].func) +#define glGetColorTable ((PFNGLGETCOLORTABLEPROC)gl_addr[GLGETCOLORTABLE].func) +#define glGetColorTableEXT ((PFNGLGETCOLORTABLEEXTPROC)gl_addr[GLGETCOLORTABLEEXT].func) +#define glGetColorTableParameterfv ((PFNGLGETCOLORTABLEPARAMETERFVPROC)gl_addr[GLGETCOLORTABLEPARAMETERFV].func) +#define glGetColorTableParameterfvEXT ((PFNGLGETCOLORTABLEPARAMETERFVEXTPROC)gl_addr[GLGETCOLORTABLEPARAMETERFVEXT].func) +#define glGetColorTableParameteriv ((PFNGLGETCOLORTABLEPARAMETERIVPROC)gl_addr[GLGETCOLORTABLEPARAMETERIV].func) +#define glGetColorTableParameterivEXT ((PFNGLGETCOLORTABLEPARAMETERIVEXTPROC)gl_addr[GLGETCOLORTABLEPARAMETERIVEXT].func) +#define glGetCombinerInputParameterfvNV ((PFNGLGETCOMBINERINPUTPARAMETERFVNVPROC)gl_addr[GLGETCOMBINERINPUTPARAMETERFVNV].func) +#define glGetCombinerInputParameterivNV ((PFNGLGETCOMBINERINPUTPARAMETERIVNVPROC)gl_addr[GLGETCOMBINERINPUTPARAMETERIVNV].func) +#define glGetCombinerOutputParameterfvNV ((PFNGLGETCOMBINEROUTPUTPARAMETERFVNVPROC)gl_addr[GLGETCOMBINEROUTPUTPARAMETERFVNV].func) +#define glGetCombinerOutputParameterivNV ((PFNGLGETCOMBINEROUTPUTPARAMETERIVNVPROC)gl_addr[GLGETCOMBINEROUTPUTPARAMETERIVNV].func) +#define glGetCombinerStageParameterfvNV ((PFNGLGETCOMBINERSTAGEPARAMETERFVNVPROC)gl_addr[GLGETCOMBINERSTAGEPARAMETERFVNV].func) +#define glGetCompressedMultiTexImageEXT ((PFNGLGETCOMPRESSEDMULTITEXIMAGEEXTPROC)gl_addr[GLGETCOMPRESSEDMULTITEXIMAGEEXT].func) +#define glGetCompressedTexImage ((PFNGLGETCOMPRESSEDTEXIMAGEPROC)gl_addr[GLGETCOMPRESSEDTEXIMAGE].func) +#define glGetCompressedTexImageARB ((PFNGLGETCOMPRESSEDTEXIMAGEARBPROC)gl_addr[GLGETCOMPRESSEDTEXIMAGEARB].func) +#define glGetCompressedTextureImageEXT ((PFNGLGETCOMPRESSEDTEXTUREIMAGEEXTPROC)gl_addr[GLGETCOMPRESSEDTEXTUREIMAGEEXT].func) +#define glGetConvolutionFilter ((PFNGLGETCONVOLUTIONFILTERPROC)gl_addr[GLGETCONVOLUTIONFILTER].func) +#define glGetConvolutionParameterfv ((PFNGLGETCONVOLUTIONPARAMETERFVPROC)gl_addr[GLGETCONVOLUTIONPARAMETERFV].func) +#define glGetConvolutionParameteriv ((PFNGLGETCONVOLUTIONPARAMETERIVPROC)gl_addr[GLGETCONVOLUTIONPARAMETERIV].func) +#define glGetDoubleIndexedvEXT ((PFNGLGETDOUBLEINDEXEDVEXTPROC)gl_addr[GLGETDOUBLEINDEXEDVEXT].func) +#define glGetFenceivNV ((PFNGLGETFENCEIVNVPROC)gl_addr[GLGETFENCEIVNV].func) +#define glGetFinalCombinerInputParameterfvNV ((PFNGLGETFINALCOMBINERINPUTPARAMETERFVNVPROC)gl_addr[GLGETFINALCOMBINERINPUTPARAMETERFVNV].func) +#define glGetFinalCombinerInputParameterivNV ((PFNGLGETFINALCOMBINERINPUTPARAMETERIVNVPROC)gl_addr[GLGETFINALCOMBINERINPUTPARAMETERIVNV].func) +#define glGetFloatIndexedvEXT ((PFNGLGETFLOATINDEXEDVEXTPROC)gl_addr[GLGETFLOATINDEXEDVEXT].func) +#define glGetFragDataLocation ((PFNGLGETFRAGDATALOCATIONPROC)gl_addr[GLGETFRAGDATALOCATION].func) +#define glGetFragDataLocationEXT ((PFNGLGETFRAGDATALOCATIONEXTPROC)gl_addr[GLGETFRAGDATALOCATIONEXT].func) +#define glGetFramebufferAttachmentParameteriv ((PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC)gl_addr[GLGETFRAMEBUFFERATTACHMENTPARAMETERIV].func) +#define glGetFramebufferAttachmentParameterivEXT ((PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC)gl_addr[GLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXT].func) +#define glGetFramebufferParameterivEXT ((PFNGLGETFRAMEBUFFERPARAMETERIVEXTPROC)gl_addr[GLGETFRAMEBUFFERPARAMETERIVEXT].func) +#define glGetHandleARB ((PFNGLGETHANDLEARBPROC)gl_addr[GLGETHANDLEARB].func) +#define glGetHistogram ((PFNGLGETHISTOGRAMPROC)gl_addr[GLGETHISTOGRAM].func) +#define glGetHistogramParameterfv ((PFNGLGETHISTOGRAMPARAMETERFVPROC)gl_addr[GLGETHISTOGRAMPARAMETERFV].func) +#define glGetHistogramParameteriv ((PFNGLGETHISTOGRAMPARAMETERIVPROC)gl_addr[GLGETHISTOGRAMPARAMETERIV].func) +#define glGetInfoLogARB ((PFNGLGETINFOLOGARBPROC)gl_addr[GLGETINFOLOGARB].func) +#define glGetIntegeri_v ((PFNGLGETINTEGERI_VPROC)gl_addr[GLGETINTEGERI_V].func) +#define glGetIntegerIndexedvEXT ((PFNGLGETINTEGERINDEXEDVEXTPROC)gl_addr[GLGETINTEGERINDEXEDVEXT].func) +#define glGetMinmax ((PFNGLGETMINMAXPROC)gl_addr[GLGETMINMAX].func) +#define glGetMinmaxParameterfv ((PFNGLGETMINMAXPARAMETERFVPROC)gl_addr[GLGETMINMAXPARAMETERFV].func) +#define glGetMinmaxParameteriv ((PFNGLGETMINMAXPARAMETERIVPROC)gl_addr[GLGETMINMAXPARAMETERIV].func) +#define glGetMultisamplefvNV ((PFNGLGETMULTISAMPLEFVNVPROC)gl_addr[GLGETMULTISAMPLEFVNV].func) +#define glGetMultiTexEnvfvEXT ((PFNGLGETMULTITEXENVFVEXTPROC)gl_addr[GLGETMULTITEXENVFVEXT].func) +#define glGetMultiTexEnvivEXT ((PFNGLGETMULTITEXENVIVEXTPROC)gl_addr[GLGETMULTITEXENVIVEXT].func) +#define glGetMultiTexGendvEXT ((PFNGLGETMULTITEXGENDVEXTPROC)gl_addr[GLGETMULTITEXGENDVEXT].func) +#define glGetMultiTexGenfvEXT ((PFNGLGETMULTITEXGENFVEXTPROC)gl_addr[GLGETMULTITEXGENFVEXT].func) +#define glGetMultiTexGenivEXT ((PFNGLGETMULTITEXGENIVEXTPROC)gl_addr[GLGETMULTITEXGENIVEXT].func) +#define glGetMultiTexImageEXT ((PFNGLGETMULTITEXIMAGEEXTPROC)gl_addr[GLGETMULTITEXIMAGEEXT].func) +#define glGetMultiTexLevelParameterfvEXT ((PFNGLGETMULTITEXLEVELPARAMETERFVEXTPROC)gl_addr[GLGETMULTITEXLEVELPARAMETERFVEXT].func) +#define glGetMultiTexLevelParameterivEXT ((PFNGLGETMULTITEXLEVELPARAMETERIVEXTPROC)gl_addr[GLGETMULTITEXLEVELPARAMETERIVEXT].func) +#define glGetMultiTexParameterfvEXT ((PFNGLGETMULTITEXPARAMETERFVEXTPROC)gl_addr[GLGETMULTITEXPARAMETERFVEXT].func) +#define glGetMultiTexParameterIivEXT ((PFNGLGETMULTITEXPARAMETERIIVEXTPROC)gl_addr[GLGETMULTITEXPARAMETERIIVEXT].func) +#define glGetMultiTexParameterIuivEXT ((PFNGLGETMULTITEXPARAMETERIUIVEXTPROC)gl_addr[GLGETMULTITEXPARAMETERIUIVEXT].func) +#define glGetMultiTexParameterivEXT ((PFNGLGETMULTITEXPARAMETERIVEXTPROC)gl_addr[GLGETMULTITEXPARAMETERIVEXT].func) +#define glGetNamedBufferParameterivEXT ((PFNGLGETNAMEDBUFFERPARAMETERIVEXTPROC)gl_addr[GLGETNAMEDBUFFERPARAMETERIVEXT].func) +#define glGetNamedBufferPointervEXT ((PFNGLGETNAMEDBUFFERPOINTERVEXTPROC)gl_addr[GLGETNAMEDBUFFERPOINTERVEXT].func) +#define glGetNamedBufferSubDataEXT ((PFNGLGETNAMEDBUFFERSUBDATAEXTPROC)gl_addr[GLGETNAMEDBUFFERSUBDATAEXT].func) +#define glGetNamedFramebufferAttachmentParameterivEXT ((PFNGLGETNAMEDFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC)gl_addr[GLGETNAMEDFRAMEBUFFERATTACHMENTPARAMETERIVEXT].func) +#define glGetNamedProgramivEXT ((PFNGLGETNAMEDPROGRAMIVEXTPROC)gl_addr[GLGETNAMEDPROGRAMIVEXT].func) +#define glGetNamedProgramLocalParameterdvEXT ((PFNGLGETNAMEDPROGRAMLOCALPARAMETERDVEXTPROC)gl_addr[GLGETNAMEDPROGRAMLOCALPARAMETERDVEXT].func) +#define glGetNamedProgramLocalParameterfvEXT ((PFNGLGETNAMEDPROGRAMLOCALPARAMETERFVEXTPROC)gl_addr[GLGETNAMEDPROGRAMLOCALPARAMETERFVEXT].func) +#define glGetNamedProgramLocalParameterIivEXT ((PFNGLGETNAMEDPROGRAMLOCALPARAMETERIIVEXTPROC)gl_addr[GLGETNAMEDPROGRAMLOCALPARAMETERIIVEXT].func) +#define glGetNamedProgramLocalParameterIuivEXT ((PFNGLGETNAMEDPROGRAMLOCALPARAMETERIUIVEXTPROC)gl_addr[GLGETNAMEDPROGRAMLOCALPARAMETERIUIVEXT].func) +#define glGetNamedProgramStringEXT ((PFNGLGETNAMEDPROGRAMSTRINGEXTPROC)gl_addr[GLGETNAMEDPROGRAMSTRINGEXT].func) +#define glGetNamedRenderbufferParameterivEXT ((PFNGLGETNAMEDRENDERBUFFERPARAMETERIVEXTPROC)gl_addr[GLGETNAMEDRENDERBUFFERPARAMETERIVEXT].func) +#define glGetObjectParameterfvARB ((PFNGLGETOBJECTPARAMETERFVARBPROC)gl_addr[GLGETOBJECTPARAMETERFVARB].func) +#define glGetObjectParameterivARB ((PFNGLGETOBJECTPARAMETERIVARBPROC)gl_addr[GLGETOBJECTPARAMETERIVARB].func) +#define glGetOcclusionQueryivNV ((PFNGLGETOCCLUSIONQUERYIVNVPROC)gl_addr[GLGETOCCLUSIONQUERYIVNV].func) +#define glGetOcclusionQueryuivNV ((PFNGLGETOCCLUSIONQUERYUIVNVPROC)gl_addr[GLGETOCCLUSIONQUERYUIVNV].func) +#define glGetPointerIndexedvEXT ((PFNGLGETPOINTERINDEXEDVEXTPROC)gl_addr[GLGETPOINTERINDEXEDVEXT].func) +#define glGetPointervEXT ((PFNGLGETPOINTERVEXTPROC)gl_addr[GLGETPOINTERVEXT].func) +#define glGetProgramEnvParameterdvARB ((PFNGLGETPROGRAMENVPARAMETERDVARBPROC)gl_addr[GLGETPROGRAMENVPARAMETERDVARB].func) +#define glGetProgramEnvParameterIivNV ((PFNGLGETPROGRAMENVPARAMETERIIVNVPROC)gl_addr[GLGETPROGRAMENVPARAMETERIIVNV].func) +#define glGetProgramEnvParameterIuivNV ((PFNGLGETPROGRAMENVPARAMETERIUIVNVPROC)gl_addr[GLGETPROGRAMENVPARAMETERIUIVNV].func) +#define glGetProgramInfoLog ((PFNGLGETPROGRAMINFOLOGPROC)gl_addr[GLGETPROGRAMINFOLOG].func) +#define glGetProgramiv ((PFNGLGETPROGRAMIVPROC)gl_addr[GLGETPROGRAMIV].func) +#define glGetProgramivNV ((PFNGLGETPROGRAMIVNVPROC)gl_addr[GLGETPROGRAMIVNV].func) +#define glGetProgramLocalParameterdvARB ((PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC)gl_addr[GLGETPROGRAMLOCALPARAMETERDVARB].func) +#define glGetProgramLocalParameterfvARB ((PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC)gl_addr[GLGETPROGRAMLOCALPARAMETERFVARB].func) +#define glGetProgramLocalParameterIivNV ((PFNGLGETPROGRAMLOCALPARAMETERIIVNVPROC)gl_addr[GLGETPROGRAMLOCALPARAMETERIIVNV].func) +#define glGetProgramLocalParameterIuivNV ((PFNGLGETPROGRAMLOCALPARAMETERIUIVNVPROC)gl_addr[GLGETPROGRAMLOCALPARAMETERIUIVNV].func) +#define glGetProgramNamedParameterdvNV ((PFNGLGETPROGRAMNAMEDPARAMETERDVNVPROC)gl_addr[GLGETPROGRAMNAMEDPARAMETERDVNV].func) +#define glGetProgramNamedParameterfvNV ((PFNGLGETPROGRAMNAMEDPARAMETERFVNVPROC)gl_addr[GLGETPROGRAMNAMEDPARAMETERFVNV].func) +#define glGetProgramParameterdvNV ((PFNGLGETPROGRAMPARAMETERDVNVPROC)gl_addr[GLGETPROGRAMPARAMETERDVNV].func) +#define glGetProgramParameterfvNV ((PFNGLGETPROGRAMPARAMETERFVNVPROC)gl_addr[GLGETPROGRAMPARAMETERFVNV].func) +#define glGetProgramStringARB ((PFNGLGETPROGRAMSTRINGARBPROC)gl_addr[GLGETPROGRAMSTRINGARB].func) +#define glGetProgramStringNV ((PFNGLGETPROGRAMSTRINGNVPROC)gl_addr[GLGETPROGRAMSTRINGNV].func) +#define glGetQueryiv ((PFNGLGETQUERYIVPROC)gl_addr[GLGETQUERYIV].func) +#define glGetQueryivARB ((PFNGLGETQUERYIVARBPROC)gl_addr[GLGETQUERYIVARB].func) +#define glGetQueryObjecti64vEXT ((PFNGLGETQUERYOBJECTI64VEXTPROC)gl_addr[GLGETQUERYOBJECTI64VEXT].func) +#define glGetQueryObjectiv ((PFNGLGETQUERYOBJECTIVPROC)gl_addr[GLGETQUERYOBJECTIV].func) +#define glGetQueryObjectivARB ((PFNGLGETQUERYOBJECTIVARBPROC)gl_addr[GLGETQUERYOBJECTIVARB].func) +#define glGetQueryObjectui64v ((PFNGLGETQUERYOBJECTUI64VPROC)gl_addr[GLGETQUERYOBJECTUI64V].func) +#define glGetQueryObjectui64vEXT ((PFNGLGETQUERYOBJECTUI64VEXTPROC)gl_addr[GLGETQUERYOBJECTUI64VEXT].func) +#define glGetQueryObjectuiv ((PFNGLGETQUERYOBJECTUIVPROC)gl_addr[GLGETQUERYOBJECTUIV].func) +#define glGetQueryObjectuivARB ((PFNGLGETQUERYOBJECTUIVARBPROC)gl_addr[GLGETQUERYOBJECTUIVARB].func) +#define glGetRenderbufferParameteriv ((PFNGLGETRENDERBUFFERPARAMETERIVPROC)gl_addr[GLGETRENDERBUFFERPARAMETERIV].func) +#define glGetRenderbufferParameterivEXT ((PFNGLGETRENDERBUFFERPARAMETERIVEXTPROC)gl_addr[GLGETRENDERBUFFERPARAMETERIVEXT].func) +#define glGetSeparableFilter ((PFNGLGETSEPARABLEFILTERPROC)gl_addr[GLGETSEPARABLEFILTER].func) +#define glGetShaderInfoLog ((PFNGLGETSHADERINFOLOGPROC)gl_addr[GLGETSHADERINFOLOG].func) +#define glGetShaderiv ((PFNGLGETSHADERIVPROC)gl_addr[GLGETSHADERIV].func) +#define glGetShaderSource ((PFNGLGETSHADERSOURCEPROC)gl_addr[GLGETSHADERSOURCE].func) +#define glGetShaderSourceARB ((PFNGLGETSHADERSOURCEARBPROC)gl_addr[GLGETSHADERSOURCEARB].func) +#define glGetStringi ((PFNGLGETSTRINGIPROC)gl_addr[GLGETSTRINGI].func) +#define glGetTexParameterIiv ((PFNGLGETTEXPARAMETERIIVPROC)gl_addr[GLGETTEXPARAMETERIIV].func) +#define glGetTexParameterIivEXT ((PFNGLGETTEXPARAMETERIIVEXTPROC)gl_addr[GLGETTEXPARAMETERIIVEXT].func) +#define glGetTexParameterIuiv ((PFNGLGETTEXPARAMETERIUIVPROC)gl_addr[GLGETTEXPARAMETERIUIV].func) +#define glGetTexParameterIuivEXT ((PFNGLGETTEXPARAMETERIUIVEXTPROC)gl_addr[GLGETTEXPARAMETERIUIVEXT].func) +#define glGetTextureLevelParameterfvEXT ((PFNGLGETTEXTURELEVELPARAMETERFVEXTPROC)gl_addr[GLGETTEXTURELEVELPARAMETERFVEXT].func) +#define glGetTextureLevelParameterivEXT ((PFNGLGETTEXTURELEVELPARAMETERIVEXTPROC)gl_addr[GLGETTEXTURELEVELPARAMETERIVEXT].func) +#define glGetTextureParameterfvEXT ((PFNGLGETTEXTUREPARAMETERFVEXTPROC)gl_addr[GLGETTEXTUREPARAMETERFVEXT].func) +#define glGetTextureParameterIivEXT ((PFNGLGETTEXTUREPARAMETERIIVEXTPROC)gl_addr[GLGETTEXTUREPARAMETERIIVEXT].func) +#define glGetTextureParameterIuivEXT ((PFNGLGETTEXTUREPARAMETERIUIVEXTPROC)gl_addr[GLGETTEXTUREPARAMETERIUIVEXT].func) +#define glGetTextureParameterivEXT ((PFNGLGETTEXTUREPARAMETERIVEXTPROC)gl_addr[GLGETTEXTUREPARAMETERIVEXT].func) +#define glGetTrackMatrixivNV ((PFNGLGETTRACKMATRIXIVNVPROC)gl_addr[GLGETTRACKMATRIXIVNV].func) +#define glGetTransformFeedbackVarying ((PFNGLGETTRANSFORMFEEDBACKVARYINGPROC)gl_addr[GLGETTRANSFORMFEEDBACKVARYING].func) +#define glGetTransformFeedbackVaryingNV ((PFNGLGETTRANSFORMFEEDBACKVARYINGNVPROC)gl_addr[GLGETTRANSFORMFEEDBACKVARYINGNV].func) +#define glGetUniformBufferSizeEXT ((PFNGLGETUNIFORMBUFFERSIZEEXTPROC)gl_addr[GLGETUNIFORMBUFFERSIZEEXT].func) +#define glGetUniformfv ((PFNGLGETUNIFORMFVPROC)gl_addr[GLGETUNIFORMFV].func) +#define glGetUniformfvARB ((PFNGLGETUNIFORMFVARBPROC)gl_addr[GLGETUNIFORMFVARB].func) +#define glGetUniformiv ((PFNGLGETUNIFORMIVPROC)gl_addr[GLGETUNIFORMIV].func) +#define glGetUniformivARB ((PFNGLGETUNIFORMIVARBPROC)gl_addr[GLGETUNIFORMIVARB].func) +#define glGetUniformLocation ((PFNGLGETUNIFORMLOCATIONPROC)gl_addr[GLGETUNIFORMLOCATION].func) +#define glGetUniformLocationARB ((PFNGLGETUNIFORMLOCATIONARBPROC)gl_addr[GLGETUNIFORMLOCATIONARB].func) +#define glGetUniformOffsetEXT ((PFNGLGETUNIFORMOFFSETEXTPROC)gl_addr[GLGETUNIFORMOFFSETEXT].func) +#define glGetUniformuiv ((PFNGLGETUNIFORMUIVPROC)gl_addr[GLGETUNIFORMUIV].func) +#define glGetUniformuivEXT ((PFNGLGETUNIFORMUIVEXTPROC)gl_addr[GLGETUNIFORMUIVEXT].func) +#define glGetVaryingLocationNV ((PFNGLGETVARYINGLOCATIONNVPROC)gl_addr[GLGETVARYINGLOCATIONNV].func) +#define glGetVertexAttribdv ((PFNGLGETVERTEXATTRIBDVPROC)gl_addr[GLGETVERTEXATTRIBDV].func) +#define glGetVertexAttribdvARB ((PFNGLGETVERTEXATTRIBDVARBPROC)gl_addr[GLGETVERTEXATTRIBDVARB].func) +#define glGetVertexAttribdvNV ((PFNGLGETVERTEXATTRIBDVNVPROC)gl_addr[GLGETVERTEXATTRIBDVNV].func) +#define glGetVertexAttribfv ((PFNGLGETVERTEXATTRIBFVPROC)gl_addr[GLGETVERTEXATTRIBFV].func) +#define glGetVertexAttribfvARB ((PFNGLGETVERTEXATTRIBFVARBPROC)gl_addr[GLGETVERTEXATTRIBFVARB].func) +#define glGetVertexAttribfvNV ((PFNGLGETVERTEXATTRIBFVNVPROC)gl_addr[GLGETVERTEXATTRIBFVNV].func) +#define glGetVertexAttribIiv ((PFNGLGETVERTEXATTRIBIIVPROC)gl_addr[GLGETVERTEXATTRIBIIV].func) +#define glGetVertexAttribIivEXT ((PFNGLGETVERTEXATTRIBIIVEXTPROC)gl_addr[GLGETVERTEXATTRIBIIVEXT].func) +#define glGetVertexAttribIuiv ((PFNGLGETVERTEXATTRIBIUIVPROC)gl_addr[GLGETVERTEXATTRIBIUIV].func) +#define glGetVertexAttribIuivEXT ((PFNGLGETVERTEXATTRIBIUIVEXTPROC)gl_addr[GLGETVERTEXATTRIBIUIVEXT].func) +#define glGetVertexAttribiv ((PFNGLGETVERTEXATTRIBIVPROC)gl_addr[GLGETVERTEXATTRIBIV].func) +#define glGetVertexAttribivARB ((PFNGLGETVERTEXATTRIBIVARBPROC)gl_addr[GLGETVERTEXATTRIBIVARB].func) +#define glGetVertexAttribivNV ((PFNGLGETVERTEXATTRIBIVNVPROC)gl_addr[GLGETVERTEXATTRIBIVNV].func) +#define glGetVertexAttribPointerv ((PFNGLGETVERTEXATTRIBPOINTERVPROC)gl_addr[GLGETVERTEXATTRIBPOINTERV].func) +#define glGetVertexAttribPointervARB ((PFNGLGETVERTEXATTRIBPOINTERVARBPROC)gl_addr[GLGETVERTEXATTRIBPOINTERVARB].func) +#define glGetVertexAttribPointervNV ((PFNGLGETVERTEXATTRIBPOINTERVNVPROC)gl_addr[GLGETVERTEXATTRIBPOINTERVNV].func) +#define glGetVideoi64vNV ((PFNGLGETVIDEOI64VNVPROC)gl_addr[GLGETVIDEOI64VNV].func) +#define glGetVideoivNV ((PFNGLGETVIDEOIVNVPROC)gl_addr[GLGETVIDEOIVNV].func) +#define glGetVideoui64vNV ((PFNGLGETVIDEOUI64VNVPROC)gl_addr[GLGETVIDEOUI64VNV].func) +#define glGetVideouivNV ((PFNGLGETVIDEOUIVNVPROC)gl_addr[GLGETVIDEOUIVNV].func) +#define glHistogram ((PFNGLHISTOGRAMPROC)gl_addr[GLHISTOGRAM].func) +#define glIndexPointerEXT ((PFNGLINDEXPOINTEREXTPROC)gl_addr[GLINDEXPOINTEREXT].func) +#define glIsBuffer ((PFNGLISBUFFERPROC)gl_addr[GLISBUFFER].func) +#define glIsEnabledi ((PFNGLISENABLEDIPROC)gl_addr[GLISENABLEDI].func) +#define glIsEnabledIndexedEXT ((PFNGLISENABLEDINDEXEDEXTPROC)gl_addr[GLISENABLEDINDEXEDEXT].func) +#define glIsFenceNV ((PFNGLISFENCENVPROC)gl_addr[GLISFENCENV].func) +#define glIsFramebuffer ((PFNGLISFRAMEBUFFERPROC)gl_addr[GLISFRAMEBUFFER].func) +#define glIsFramebufferEXT ((PFNGLISFRAMEBUFFEREXTPROC)gl_addr[GLISFRAMEBUFFEREXT].func) +#define glIsOcclusionQueryNV ((PFNGLISOCCLUSIONQUERYNVPROC)gl_addr[GLISOCCLUSIONQUERYNV].func) +#define glIsProgram ((PFNGLISPROGRAMPROC)gl_addr[GLISPROGRAM].func) +#define glIsProgramARB ((PFNGLISPROGRAMARBPROC)gl_addr[GLISPROGRAMARB].func) +#define glIsProgramNV ((PFNGLISPROGRAMNVPROC)gl_addr[GLISPROGRAMNV].func) +#define glIsQuery ((PFNGLISQUERYPROC)gl_addr[GLISQUERY].func) +#define glIsQueryARB ((PFNGLISQUERYARBPROC)gl_addr[GLISQUERYARB].func) +#define glIsRenderbuffer ((PFNGLISRENDERBUFFERPROC)gl_addr[GLISRENDERBUFFER].func) +#define glIsRenderbufferEXT ((PFNGLISRENDERBUFFEREXTPROC)gl_addr[GLISRENDERBUFFEREXT].func) +#define glIsShader ((PFNGLISSHADERPROC)gl_addr[GLISSHADER].func) +#define glIsTextureEXT ((PFNGLISTEXTUREEXTPROC)gl_addr[GLISTEXTUREEXT].func) +#define glIsVertexArray ((PFNGLISVERTEXARRAYPROC)gl_addr[GLISVERTEXARRAY].func) +#define glLinkProgram ((PFNGLLINKPROGRAMPROC)gl_addr[GLLINKPROGRAM].func) +#define glLinkProgramARB ((PFNGLLINKPROGRAMARBPROC)gl_addr[GLLINKPROGRAMARB].func) +#define glLoadProgramNV ((PFNGLLOADPROGRAMNVPROC)gl_addr[GLLOADPROGRAMNV].func) +#define glLoadTransposeMatrixd ((PFNGLLOADTRANSPOSEMATRIXDPROC)gl_addr[GLLOADTRANSPOSEMATRIXD].func) +#define glLoadTransposeMatrixdARB ((PFNGLLOADTRANSPOSEMATRIXDARBPROC)gl_addr[GLLOADTRANSPOSEMATRIXDARB].func) +#define glLoadTransposeMatrixfARB ((PFNGLLOADTRANSPOSEMATRIXFARBPROC)gl_addr[GLLOADTRANSPOSEMATRIXFARB].func) +#define glLockArraysEXT ((PFNGLLOCKARRAYSEXTPROC)gl_addr[GLLOCKARRAYSEXT].func) +#define glMapBuffer ((PFNGLMAPBUFFERPROC)gl_addr[GLMAPBUFFER].func) +#define glMapBufferARB ((PFNGLMAPBUFFERARBPROC)gl_addr[GLMAPBUFFERARB].func) +#define glMapBufferRange ((PFNGLMAPBUFFERRANGEPROC)gl_addr[GLMAPBUFFERRANGE].func) +#define glMatrixFrustumEXT ((PFNGLMATRIXFRUSTUMEXTPROC)gl_addr[GLMATRIXFRUSTUMEXT].func) +#define glMatrixLoaddEXT ((PFNGLMATRIXLOADDEXTPROC)gl_addr[GLMATRIXLOADDEXT].func) +#define glMatrixLoadfEXT ((PFNGLMATRIXLOADFEXTPROC)gl_addr[GLMATRIXLOADFEXT].func) +#define glMatrixLoadIdentityEXT ((PFNGLMATRIXLOADIDENTITYEXTPROC)gl_addr[GLMATRIXLOADIDENTITYEXT].func) +#define glMatrixLoadTransposedEXT ((PFNGLMATRIXLOADTRANSPOSEDEXTPROC)gl_addr[GLMATRIXLOADTRANSPOSEDEXT].func) +#define glMatrixLoadTransposefEXT ((PFNGLMATRIXLOADTRANSPOSEFEXTPROC)gl_addr[GLMATRIXLOADTRANSPOSEFEXT].func) +#define glMatrixMultdEXT ((PFNGLMATRIXMULTDEXTPROC)gl_addr[GLMATRIXMULTDEXT].func) +#define glMatrixMultfEXT ((PFNGLMATRIXMULTFEXTPROC)gl_addr[GLMATRIXMULTFEXT].func) +#define glMatrixMultTransposedEXT ((PFNGLMATRIXMULTTRANSPOSEDEXTPROC)gl_addr[GLMATRIXMULTTRANSPOSEDEXT].func) +#define glMatrixMultTransposefEXT ((PFNGLMATRIXMULTTRANSPOSEFEXTPROC)gl_addr[GLMATRIXMULTTRANSPOSEFEXT].func) +#define glMatrixOrthoEXT ((PFNGLMATRIXORTHOEXTPROC)gl_addr[GLMATRIXORTHOEXT].func) +#define glMatrixPopEXT ((PFNGLMATRIXPOPEXTPROC)gl_addr[GLMATRIXPOPEXT].func) +#define glMatrixPushEXT ((PFNGLMATRIXPUSHEXTPROC)gl_addr[GLMATRIXPUSHEXT].func) +#define glMatrixRotatedEXT ((PFNGLMATRIXROTATEDEXTPROC)gl_addr[GLMATRIXROTATEDEXT].func) +#define glMatrixRotatefEXT ((PFNGLMATRIXROTATEFEXTPROC)gl_addr[GLMATRIXROTATEFEXT].func) +#define glMatrixScaledEXT ((PFNGLMATRIXSCALEDEXTPROC)gl_addr[GLMATRIXSCALEDEXT].func) +#define glMatrixScalefEXT ((PFNGLMATRIXSCALEFEXTPROC)gl_addr[GLMATRIXSCALEFEXT].func) +#define glMatrixTranslatedEXT ((PFNGLMATRIXTRANSLATEDEXTPROC)gl_addr[GLMATRIXTRANSLATEDEXT].func) +#define glMatrixTranslatefEXT ((PFNGLMATRIXTRANSLATEFEXTPROC)gl_addr[GLMATRIXTRANSLATEFEXT].func) +#define glMinmax ((PFNGLMINMAXPROC)gl_addr[GLMINMAX].func) +#define glMultiDrawArrays ((PFNGLMULTIDRAWARRAYSPROC)gl_addr[GLMULTIDRAWARRAYS].func) +#define glMultiDrawArraysEXT ((PFNGLMULTIDRAWARRAYSEXTPROC)gl_addr[GLMULTIDRAWARRAYSEXT].func) +#define glMultiDrawElements ((PFNGLMULTIDRAWELEMENTSPROC)gl_addr[GLMULTIDRAWELEMENTS].func) +#define glMultiDrawElementsEXT ((PFNGLMULTIDRAWELEMENTSEXTPROC)gl_addr[GLMULTIDRAWELEMENTSEXT].func) +#define glMultiTexBufferEXT ((PFNGLMULTITEXBUFFEREXTPROC)gl_addr[GLMULTITEXBUFFEREXT].func) +#define glMultiTexCoord1d ((PFNGLMULTITEXCOORD1DPROC)gl_addr[GLMULTITEXCOORD1D].func) +#define glMultiTexCoord1dARB ((PFNGLMULTITEXCOORD1DARBPROC)gl_addr[GLMULTITEXCOORD1DARB].func) +#define glMultiTexCoord1dv ((PFNGLMULTITEXCOORD1DVPROC)gl_addr[GLMULTITEXCOORD1DV].func) +#define glMultiTexCoord1dvARB ((PFNGLMULTITEXCOORD1DVARBPROC)gl_addr[GLMULTITEXCOORD1DVARB].func) +#define glMultiTexCoord1f ((PFNGLMULTITEXCOORD1FPROC)gl_addr[GLMULTITEXCOORD1F].func) +#define glMultiTexCoord1fARB ((PFNGLMULTITEXCOORD1FARBPROC)gl_addr[GLMULTITEXCOORD1FARB].func) +#define glMultiTexCoord1fv ((PFNGLMULTITEXCOORD1FVPROC)gl_addr[GLMULTITEXCOORD1FV].func) +#define glMultiTexCoord1fvARB ((PFNGLMULTITEXCOORD1FVARBPROC)gl_addr[GLMULTITEXCOORD1FVARB].func) +#define glMultiTexCoord1hNV ((PFNGLMULTITEXCOORD1HNVPROC)gl_addr[GLMULTITEXCOORD1HNV].func) +#define glMultiTexCoord1hvNV ((PFNGLMULTITEXCOORD1HVNVPROC)gl_addr[GLMULTITEXCOORD1HVNV].func) +#define glMultiTexCoord1i ((PFNGLMULTITEXCOORD1IPROC)gl_addr[GLMULTITEXCOORD1I].func) +#define glMultiTexCoord1iARB ((PFNGLMULTITEXCOORD1IARBPROC)gl_addr[GLMULTITEXCOORD1IARB].func) +#define glMultiTexCoord1iv ((PFNGLMULTITEXCOORD1IVPROC)gl_addr[GLMULTITEXCOORD1IV].func) +#define glMultiTexCoord1ivARB ((PFNGLMULTITEXCOORD1IVARBPROC)gl_addr[GLMULTITEXCOORD1IVARB].func) +#define glMultiTexCoord1s ((PFNGLMULTITEXCOORD1SPROC)gl_addr[GLMULTITEXCOORD1S].func) +#define glMultiTexCoord1sARB ((PFNGLMULTITEXCOORD1SARBPROC)gl_addr[GLMULTITEXCOORD1SARB].func) +#define glMultiTexCoord1sv ((PFNGLMULTITEXCOORD1SVPROC)gl_addr[GLMULTITEXCOORD1SV].func) +#define glMultiTexCoord1svARB ((PFNGLMULTITEXCOORD1SVARBPROC)gl_addr[GLMULTITEXCOORD1SVARB].func) +#define glMultiTexCoord2d ((PFNGLMULTITEXCOORD2DPROC)gl_addr[GLMULTITEXCOORD2D].func) +#define glMultiTexCoord2dARB ((PFNGLMULTITEXCOORD2DARBPROC)gl_addr[GLMULTITEXCOORD2DARB].func) +#define glMultiTexCoord2dv ((PFNGLMULTITEXCOORD2DVPROC)gl_addr[GLMULTITEXCOORD2DV].func) +#define glMultiTexCoord2dvARB ((PFNGLMULTITEXCOORD2DVARBPROC)gl_addr[GLMULTITEXCOORD2DVARB].func) +#define glMultiTexCoord2fARB ((PFNGLMULTITEXCOORD2FARBPROC)gl_addr[GLMULTITEXCOORD2FARB].func) +#define glMultiTexCoord2fvARB ((PFNGLMULTITEXCOORD2FVARBPROC)gl_addr[GLMULTITEXCOORD2FVARB].func) +#define glMultiTexCoord2hNV ((PFNGLMULTITEXCOORD2HNVPROC)gl_addr[GLMULTITEXCOORD2HNV].func) +#define glMultiTexCoord2hvNV ((PFNGLMULTITEXCOORD2HVNVPROC)gl_addr[GLMULTITEXCOORD2HVNV].func) +#define glMultiTexCoord2i ((PFNGLMULTITEXCOORD2IPROC)gl_addr[GLMULTITEXCOORD2I].func) +#define glMultiTexCoord2iARB ((PFNGLMULTITEXCOORD2IARBPROC)gl_addr[GLMULTITEXCOORD2IARB].func) +#define glMultiTexCoord2iv ((PFNGLMULTITEXCOORD2IVPROC)gl_addr[GLMULTITEXCOORD2IV].func) +#define glMultiTexCoord2ivARB ((PFNGLMULTITEXCOORD2IVARBPROC)gl_addr[GLMULTITEXCOORD2IVARB].func) +#define glMultiTexCoord2s ((PFNGLMULTITEXCOORD2SPROC)gl_addr[GLMULTITEXCOORD2S].func) +#define glMultiTexCoord2sARB ((PFNGLMULTITEXCOORD2SARBPROC)gl_addr[GLMULTITEXCOORD2SARB].func) +#define glMultiTexCoord2sv ((PFNGLMULTITEXCOORD2SVPROC)gl_addr[GLMULTITEXCOORD2SV].func) +#define glMultiTexCoord2svARB ((PFNGLMULTITEXCOORD2SVARBPROC)gl_addr[GLMULTITEXCOORD2SVARB].func) +#define glMultiTexCoord3d ((PFNGLMULTITEXCOORD3DPROC)gl_addr[GLMULTITEXCOORD3D].func) +#define glMultiTexCoord3dARB ((PFNGLMULTITEXCOORD3DARBPROC)gl_addr[GLMULTITEXCOORD3DARB].func) +#define glMultiTexCoord3dv ((PFNGLMULTITEXCOORD3DVPROC)gl_addr[GLMULTITEXCOORD3DV].func) +#define glMultiTexCoord3dvARB ((PFNGLMULTITEXCOORD3DVARBPROC)gl_addr[GLMULTITEXCOORD3DVARB].func) +#define glMultiTexCoord3f ((PFNGLMULTITEXCOORD3FPROC)gl_addr[GLMULTITEXCOORD3F].func) +#define glMultiTexCoord3fARB ((PFNGLMULTITEXCOORD3FARBPROC)gl_addr[GLMULTITEXCOORD3FARB].func) +#define glMultiTexCoord3fv ((PFNGLMULTITEXCOORD3FVPROC)gl_addr[GLMULTITEXCOORD3FV].func) +#define glMultiTexCoord3fvARB ((PFNGLMULTITEXCOORD3FVARBPROC)gl_addr[GLMULTITEXCOORD3FVARB].func) +#define glMultiTexCoord3hNV ((PFNGLMULTITEXCOORD3HNVPROC)gl_addr[GLMULTITEXCOORD3HNV].func) +#define glMultiTexCoord3hvNV ((PFNGLMULTITEXCOORD3HVNVPROC)gl_addr[GLMULTITEXCOORD3HVNV].func) +#define glMultiTexCoord3i ((PFNGLMULTITEXCOORD3IPROC)gl_addr[GLMULTITEXCOORD3I].func) +#define glMultiTexCoord3iARB ((PFNGLMULTITEXCOORD3IARBPROC)gl_addr[GLMULTITEXCOORD3IARB].func) +#define glMultiTexCoord3iv ((PFNGLMULTITEXCOORD3IVPROC)gl_addr[GLMULTITEXCOORD3IV].func) +#define glMultiTexCoord3ivARB ((PFNGLMULTITEXCOORD3IVARBPROC)gl_addr[GLMULTITEXCOORD3IVARB].func) +#define glMultiTexCoord3s ((PFNGLMULTITEXCOORD3SPROC)gl_addr[GLMULTITEXCOORD3S].func) +#define glMultiTexCoord3sARB ((PFNGLMULTITEXCOORD3SARBPROC)gl_addr[GLMULTITEXCOORD3SARB].func) +#define glMultiTexCoord3sv ((PFNGLMULTITEXCOORD3SVPROC)gl_addr[GLMULTITEXCOORD3SV].func) +#define glMultiTexCoord3svARB ((PFNGLMULTITEXCOORD3SVARBPROC)gl_addr[GLMULTITEXCOORD3SVARB].func) +#define glMultiTexCoord4d ((PFNGLMULTITEXCOORD4DPROC)gl_addr[GLMULTITEXCOORD4D].func) +#define glMultiTexCoord4dARB ((PFNGLMULTITEXCOORD4DARBPROC)gl_addr[GLMULTITEXCOORD4DARB].func) +#define glMultiTexCoord4dv ((PFNGLMULTITEXCOORD4DVPROC)gl_addr[GLMULTITEXCOORD4DV].func) +#define glMultiTexCoord4dvARB ((PFNGLMULTITEXCOORD4DVARBPROC)gl_addr[GLMULTITEXCOORD4DVARB].func) +#define glMultiTexCoord4f ((PFNGLMULTITEXCOORD4FPROC)gl_addr[GLMULTITEXCOORD4F].func) +#define glMultiTexCoord4fARB ((PFNGLMULTITEXCOORD4FARBPROC)gl_addr[GLMULTITEXCOORD4FARB].func) +#define glMultiTexCoord4fv ((PFNGLMULTITEXCOORD4FVPROC)gl_addr[GLMULTITEXCOORD4FV].func) +#define glMultiTexCoord4fvARB ((PFNGLMULTITEXCOORD4FVARBPROC)gl_addr[GLMULTITEXCOORD4FVARB].func) +#define glMultiTexCoord4hNV ((PFNGLMULTITEXCOORD4HNVPROC)gl_addr[GLMULTITEXCOORD4HNV].func) +#define glMultiTexCoord4hvNV ((PFNGLMULTITEXCOORD4HVNVPROC)gl_addr[GLMULTITEXCOORD4HVNV].func) +#define glMultiTexCoord4i ((PFNGLMULTITEXCOORD4IPROC)gl_addr[GLMULTITEXCOORD4I].func) +#define glMultiTexCoord4iARB ((PFNGLMULTITEXCOORD4IARBPROC)gl_addr[GLMULTITEXCOORD4IARB].func) +#define glMultiTexCoord4iv ((PFNGLMULTITEXCOORD4IVPROC)gl_addr[GLMULTITEXCOORD4IV].func) +#define glMultiTexCoord4ivARB ((PFNGLMULTITEXCOORD4IVARBPROC)gl_addr[GLMULTITEXCOORD4IVARB].func) +#define glMultiTexCoord4s ((PFNGLMULTITEXCOORD4SPROC)gl_addr[GLMULTITEXCOORD4S].func) +#define glMultiTexCoord4sARB ((PFNGLMULTITEXCOORD4SARBPROC)gl_addr[GLMULTITEXCOORD4SARB].func) +#define glMultiTexCoord4sv ((PFNGLMULTITEXCOORD4SVPROC)gl_addr[GLMULTITEXCOORD4SV].func) +#define glMultiTexCoord4svARB ((PFNGLMULTITEXCOORD4SVARBPROC)gl_addr[GLMULTITEXCOORD4SVARB].func) +#define glMultiTexCoordPointerEXT ((PFNGLMULTITEXCOORDPOINTEREXTPROC)gl_addr[GLMULTITEXCOORDPOINTEREXT].func) +#define glMultiTexEnvfEXT ((PFNGLMULTITEXENVFEXTPROC)gl_addr[GLMULTITEXENVFEXT].func) +#define glMultiTexEnvfvEXT ((PFNGLMULTITEXENVFVEXTPROC)gl_addr[GLMULTITEXENVFVEXT].func) +#define glMultiTexEnviEXT ((PFNGLMULTITEXENVIEXTPROC)gl_addr[GLMULTITEXENVIEXT].func) +#define glMultiTexEnvivEXT ((PFNGLMULTITEXENVIVEXTPROC)gl_addr[GLMULTITEXENVIVEXT].func) +#define glMultiTexGendEXT ((PFNGLMULTITEXGENDEXTPROC)gl_addr[GLMULTITEXGENDEXT].func) +#define glMultiTexGendvEXT ((PFNGLMULTITEXGENDVEXTPROC)gl_addr[GLMULTITEXGENDVEXT].func) +#define glMultiTexGenfEXT ((PFNGLMULTITEXGENFEXTPROC)gl_addr[GLMULTITEXGENFEXT].func) +#define glMultiTexGenfvEXT ((PFNGLMULTITEXGENFVEXTPROC)gl_addr[GLMULTITEXGENFVEXT].func) +#define glMultiTexGeniEXT ((PFNGLMULTITEXGENIEXTPROC)gl_addr[GLMULTITEXGENIEXT].func) +#define glMultiTexGenivEXT ((PFNGLMULTITEXGENIVEXTPROC)gl_addr[GLMULTITEXGENIVEXT].func) +#define glMultiTexImage1DEXT ((PFNGLMULTITEXIMAGE1DEXTPROC)gl_addr[GLMULTITEXIMAGE1DEXT].func) +#define glMultiTexImage2DEXT ((PFNGLMULTITEXIMAGE2DEXTPROC)gl_addr[GLMULTITEXIMAGE2DEXT].func) +#define glMultiTexImage3DEXT ((PFNGLMULTITEXIMAGE3DEXTPROC)gl_addr[GLMULTITEXIMAGE3DEXT].func) +#define glMultiTexParameterfEXT ((PFNGLMULTITEXPARAMETERFEXTPROC)gl_addr[GLMULTITEXPARAMETERFEXT].func) +#define glMultiTexParameterfvEXT ((PFNGLMULTITEXPARAMETERFVEXTPROC)gl_addr[GLMULTITEXPARAMETERFVEXT].func) +#define glMultiTexParameteriEXT ((PFNGLMULTITEXPARAMETERIEXTPROC)gl_addr[GLMULTITEXPARAMETERIEXT].func) +#define glMultiTexParameterIivEXT ((PFNGLMULTITEXPARAMETERIIVEXTPROC)gl_addr[GLMULTITEXPARAMETERIIVEXT].func) +#define glMultiTexParameterIuivEXT ((PFNGLMULTITEXPARAMETERIUIVEXTPROC)gl_addr[GLMULTITEXPARAMETERIUIVEXT].func) +#define glMultiTexParameterivEXT ((PFNGLMULTITEXPARAMETERIVEXTPROC)gl_addr[GLMULTITEXPARAMETERIVEXT].func) +#define glMultiTexRenderbufferEXT ((PFNGLMULTITEXRENDERBUFFEREXTPROC)gl_addr[GLMULTITEXRENDERBUFFEREXT].func) +#define glMultiTexSubImage1DEXT ((PFNGLMULTITEXSUBIMAGE1DEXTPROC)gl_addr[GLMULTITEXSUBIMAGE1DEXT].func) +#define glMultiTexSubImage2DEXT ((PFNGLMULTITEXSUBIMAGE2DEXTPROC)gl_addr[GLMULTITEXSUBIMAGE2DEXT].func) +#define glMultiTexSubImage3DEXT ((PFNGLMULTITEXSUBIMAGE3DEXTPROC)gl_addr[GLMULTITEXSUBIMAGE3DEXT].func) +#define glMultTransposeMatrixd ((PFNGLMULTTRANSPOSEMATRIXDPROC)gl_addr[GLMULTTRANSPOSEMATRIXD].func) +#define glMultTransposeMatrixdARB ((PFNGLMULTTRANSPOSEMATRIXDARBPROC)gl_addr[GLMULTTRANSPOSEMATRIXDARB].func) +#define glMultTransposeMatrixfARB ((PFNGLMULTTRANSPOSEMATRIXFARBPROC)gl_addr[GLMULTTRANSPOSEMATRIXFARB].func) +#define glNamedFramebufferRenderbufferEXT ((PFNGLNAMEDFRAMEBUFFERRENDERBUFFEREXTPROC)gl_addr[GLNAMEDFRAMEBUFFERRENDERBUFFEREXT].func) +#define glNamedFramebufferTexture1DEXT ((PFNGLNAMEDFRAMEBUFFERTEXTURE1DEXTPROC)gl_addr[GLNAMEDFRAMEBUFFERTEXTURE1DEXT].func) +#define glNamedFramebufferTexture2DEXT ((PFNGLNAMEDFRAMEBUFFERTEXTURE2DEXTPROC)gl_addr[GLNAMEDFRAMEBUFFERTEXTURE2DEXT].func) +#define glNamedFramebufferTexture3DEXT ((PFNGLNAMEDFRAMEBUFFERTEXTURE3DEXTPROC)gl_addr[GLNAMEDFRAMEBUFFERTEXTURE3DEXT].func) +#define glNamedFramebufferTextureEXT ((PFNGLNAMEDFRAMEBUFFERTEXTUREEXTPROC)gl_addr[GLNAMEDFRAMEBUFFERTEXTUREEXT].func) +#define glNamedFramebufferTextureFaceEXT ((PFNGLNAMEDFRAMEBUFFERTEXTUREFACEEXTPROC)gl_addr[GLNAMEDFRAMEBUFFERTEXTUREFACEEXT].func) +#define glNamedFramebufferTextureLayerEXT ((PFNGLNAMEDFRAMEBUFFERTEXTURELAYEREXTPROC)gl_addr[GLNAMEDFRAMEBUFFERTEXTURELAYEREXT].func) +#define glNamedProgramLocalParameter4dEXT ((PFNGLNAMEDPROGRAMLOCALPARAMETER4DEXTPROC)gl_addr[GLNAMEDPROGRAMLOCALPARAMETER4DEXT].func) +#define glNamedProgramLocalParameter4dvEXT ((PFNGLNAMEDPROGRAMLOCALPARAMETER4DVEXTPROC)gl_addr[GLNAMEDPROGRAMLOCALPARAMETER4DVEXT].func) +#define glNamedProgramLocalParameter4fEXT ((PFNGLNAMEDPROGRAMLOCALPARAMETER4FEXTPROC)gl_addr[GLNAMEDPROGRAMLOCALPARAMETER4FEXT].func) +#define glNamedProgramLocalParameter4fvEXT ((PFNGLNAMEDPROGRAMLOCALPARAMETER4FVEXTPROC)gl_addr[GLNAMEDPROGRAMLOCALPARAMETER4FVEXT].func) +#define glNamedProgramLocalParameterI4iEXT ((PFNGLNAMEDPROGRAMLOCALPARAMETERI4IEXTPROC)gl_addr[GLNAMEDPROGRAMLOCALPARAMETERI4IEXT].func) +#define glNamedProgramLocalParameterI4ivEXT ((PFNGLNAMEDPROGRAMLOCALPARAMETERI4IVEXTPROC)gl_addr[GLNAMEDPROGRAMLOCALPARAMETERI4IVEXT].func) +#define glNamedProgramLocalParameterI4uiEXT ((PFNGLNAMEDPROGRAMLOCALPARAMETERI4UIEXTPROC)gl_addr[GLNAMEDPROGRAMLOCALPARAMETERI4UIEXT].func) +#define glNamedProgramLocalParameterI4uivEXT ((PFNGLNAMEDPROGRAMLOCALPARAMETERI4UIVEXTPROC)gl_addr[GLNAMEDPROGRAMLOCALPARAMETERI4UIVEXT].func) +#define glNamedProgramLocalParameters4fvEXT ((PFNGLNAMEDPROGRAMLOCALPARAMETERS4FVEXTPROC)gl_addr[GLNAMEDPROGRAMLOCALPARAMETERS4FVEXT].func) +#define glNamedProgramLocalParametersI4ivEXT ((PFNGLNAMEDPROGRAMLOCALPARAMETERSI4IVEXTPROC)gl_addr[GLNAMEDPROGRAMLOCALPARAMETERSI4IVEXT].func) +#define glNamedProgramLocalParametersI4uivEXT ((PFNGLNAMEDPROGRAMLOCALPARAMETERSI4UIVEXTPROC)gl_addr[GLNAMEDPROGRAMLOCALPARAMETERSI4UIVEXT].func) +#define glNamedProgramStringEXT ((PFNGLNAMEDPROGRAMSTRINGEXTPROC)gl_addr[GLNAMEDPROGRAMSTRINGEXT].func) +#define glNamedRenderbufferStorageEXT ((PFNGLNAMEDRENDERBUFFERSTORAGEEXTPROC)gl_addr[GLNAMEDRENDERBUFFERSTORAGEEXT].func) +#define glNamedRenderbufferStorageMultisampleCoverageEXT ((PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLECOVERAGEEXTPROC)gl_addr[GLNAMEDRENDERBUFFERSTORAGEMULTISAMPLECOVERAGEEXT].func) +#define glNamedRenderbufferStorageMultisampleEXT ((PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC)gl_addr[GLNAMEDRENDERBUFFERSTORAGEMULTISAMPLEEXT].func) +#define glNormal3hNV ((PFNGLNORMAL3HNVPROC)gl_addr[GLNORMAL3HNV].func) +#define glNormal3hvNV ((PFNGLNORMAL3HVNVPROC)gl_addr[GLNORMAL3HVNV].func) +#define glNormalPointerEXT ((PFNGLNORMALPOINTEREXTPROC)gl_addr[GLNORMALPOINTEREXT].func) +#define glPixelDataRangeNV ((PFNGLPIXELDATARANGENVPROC)gl_addr[GLPIXELDATARANGENV].func) +#define glPointParameterfARB ((PFNGLPOINTPARAMETERFARBPROC)gl_addr[GLPOINTPARAMETERFARB].func) +#define glPointParameterfEXT ((PFNGLPOINTPARAMETERFEXTPROC)gl_addr[GLPOINTPARAMETERFEXT].func) +#define glPointParameterfvARB ((PFNGLPOINTPARAMETERFVARBPROC)gl_addr[GLPOINTPARAMETERFVARB].func) +#define glPointParameterfvEXT ((PFNGLPOINTPARAMETERFVEXTPROC)gl_addr[GLPOINTPARAMETERFVEXT].func) +#define glPointParameteriNV ((PFNGLPOINTPARAMETERINVPROC)gl_addr[GLPOINTPARAMETERINV].func) +#define glPointParameteriv ((PFNGLPOINTPARAMETERIVPROC)gl_addr[GLPOINTPARAMETERIV].func) +#define glPointParameterivNV ((PFNGLPOINTPARAMETERIVNVPROC)gl_addr[GLPOINTPARAMETERIVNV].func) +#define glPresentFrameDualFillNV ((PFNGLPRESENTFRAMEDUALFILLNVPROC)gl_addr[GLPRESENTFRAMEDUALFILLNV].func) +#define glPresentFrameKeyedNV ((PFNGLPRESENTFRAMEKEYEDNVPROC)gl_addr[GLPRESENTFRAMEKEYEDNV].func) +#define glPrimitiveRestartNV ((PFNGLPRIMITIVERESTARTNVPROC)gl_addr[GLPRIMITIVERESTARTNV].func) +#define glPrioritizeTexturesEXT ((PFNGLPRIORITIZETEXTURESEXTPROC)gl_addr[GLPRIORITIZETEXTURESEXT].func) +#define glProgramBufferParametersIivNV ((PFNGLPROGRAMBUFFERPARAMETERSIIVNVPROC)gl_addr[GLPROGRAMBUFFERPARAMETERSIIVNV].func) +#define glProgramBufferParametersIuivNV ((PFNGLPROGRAMBUFFERPARAMETERSIUIVNVPROC)gl_addr[GLPROGRAMBUFFERPARAMETERSIUIVNV].func) +#define glProgramEnvParameter4dARB ((PFNGLPROGRAMENVPARAMETER4DARBPROC)gl_addr[GLPROGRAMENVPARAMETER4DARB].func) +#define glProgramEnvParameter4dvARB ((PFNGLPROGRAMENVPARAMETER4DVARBPROC)gl_addr[GLPROGRAMENVPARAMETER4DVARB].func) +#define glProgramEnvParameterI4iNV ((PFNGLPROGRAMENVPARAMETERI4INVPROC)gl_addr[GLPROGRAMENVPARAMETERI4INV].func) +#define glProgramEnvParameterI4ivNV ((PFNGLPROGRAMENVPARAMETERI4IVNVPROC)gl_addr[GLPROGRAMENVPARAMETERI4IVNV].func) +#define glProgramEnvParameterI4uiNV ((PFNGLPROGRAMENVPARAMETERI4UINVPROC)gl_addr[GLPROGRAMENVPARAMETERI4UINV].func) +#define glProgramEnvParameterI4uivNV ((PFNGLPROGRAMENVPARAMETERI4UIVNVPROC)gl_addr[GLPROGRAMENVPARAMETERI4UIVNV].func) +#define glProgramEnvParametersI4ivNV ((PFNGLPROGRAMENVPARAMETERSI4IVNVPROC)gl_addr[GLPROGRAMENVPARAMETERSI4IVNV].func) +#define glProgramEnvParametersI4uivNV ((PFNGLPROGRAMENVPARAMETERSI4UIVNVPROC)gl_addr[GLPROGRAMENVPARAMETERSI4UIVNV].func) +#define glProgramLocalParameter4dARB ((PFNGLPROGRAMLOCALPARAMETER4DARBPROC)gl_addr[GLPROGRAMLOCALPARAMETER4DARB].func) +#define glProgramLocalParameter4dvARB ((PFNGLPROGRAMLOCALPARAMETER4DVARBPROC)gl_addr[GLPROGRAMLOCALPARAMETER4DVARB].func) +#define glProgramLocalParameterI4iNV ((PFNGLPROGRAMLOCALPARAMETERI4INVPROC)gl_addr[GLPROGRAMLOCALPARAMETERI4INV].func) +#define glProgramLocalParameterI4ivNV ((PFNGLPROGRAMLOCALPARAMETERI4IVNVPROC)gl_addr[GLPROGRAMLOCALPARAMETERI4IVNV].func) +#define glProgramLocalParameterI4uiNV ((PFNGLPROGRAMLOCALPARAMETERI4UINVPROC)gl_addr[GLPROGRAMLOCALPARAMETERI4UINV].func) +#define glProgramLocalParameterI4uivNV ((PFNGLPROGRAMLOCALPARAMETERI4UIVNVPROC)gl_addr[GLPROGRAMLOCALPARAMETERI4UIVNV].func) +#define glProgramLocalParametersI4ivNV ((PFNGLPROGRAMLOCALPARAMETERSI4IVNVPROC)gl_addr[GLPROGRAMLOCALPARAMETERSI4IVNV].func) +#define glProgramLocalParametersI4uivNV ((PFNGLPROGRAMLOCALPARAMETERSI4UIVNVPROC)gl_addr[GLPROGRAMLOCALPARAMETERSI4UIVNV].func) +#define glProgramNamedParameter4dNV ((PFNGLPROGRAMNAMEDPARAMETER4DNVPROC)gl_addr[GLPROGRAMNAMEDPARAMETER4DNV].func) +#define glProgramNamedParameter4dvNV ((PFNGLPROGRAMNAMEDPARAMETER4DVNVPROC)gl_addr[GLPROGRAMNAMEDPARAMETER4DVNV].func) +#define glProgramNamedParameter4fNV ((PFNGLPROGRAMNAMEDPARAMETER4FNVPROC)gl_addr[GLPROGRAMNAMEDPARAMETER4FNV].func) +#define glProgramNamedParameter4fvNV ((PFNGLPROGRAMNAMEDPARAMETER4FVNVPROC)gl_addr[GLPROGRAMNAMEDPARAMETER4FVNV].func) +#define glProgramParameter4dNV ((PFNGLPROGRAMPARAMETER4DNVPROC)gl_addr[GLPROGRAMPARAMETER4DNV].func) +#define glProgramParameter4dvNV ((PFNGLPROGRAMPARAMETER4DVNVPROC)gl_addr[GLPROGRAMPARAMETER4DVNV].func) +#define glProgramParameter4fNV ((PFNGLPROGRAMPARAMETER4FNVPROC)gl_addr[GLPROGRAMPARAMETER4FNV].func) +#define glProgramParameter4fvNV ((PFNGLPROGRAMPARAMETER4FVNVPROC)gl_addr[GLPROGRAMPARAMETER4FVNV].func) +#define glProgramParameteriARB ((PFNGLPROGRAMPARAMETERIARBPROC)gl_addr[GLPROGRAMPARAMETERIARB].func) +#define glProgramParameteriEXT ((PFNGLPROGRAMPARAMETERIEXTPROC)gl_addr[GLPROGRAMPARAMETERIEXT].func) +#define glProgramParameters4dvNV ((PFNGLPROGRAMPARAMETERS4DVNVPROC)gl_addr[GLPROGRAMPARAMETERS4DVNV].func) +#define glProgramParameters4fvNV ((PFNGLPROGRAMPARAMETERS4FVNVPROC)gl_addr[GLPROGRAMPARAMETERS4FVNV].func) +#define glProgramStringARB ((PFNGLPROGRAMSTRINGARBPROC)gl_addr[GLPROGRAMSTRINGARB].func) +#define glProgramUniform1fEXT ((PFNGLPROGRAMUNIFORM1FEXTPROC)gl_addr[GLPROGRAMUNIFORM1FEXT].func) +#define glProgramUniform1fvEXT ((PFNGLPROGRAMUNIFORM1FVEXTPROC)gl_addr[GLPROGRAMUNIFORM1FVEXT].func) +#define glProgramUniform1iEXT ((PFNGLPROGRAMUNIFORM1IEXTPROC)gl_addr[GLPROGRAMUNIFORM1IEXT].func) +#define glProgramUniform1ivEXT ((PFNGLPROGRAMUNIFORM1IVEXTPROC)gl_addr[GLPROGRAMUNIFORM1IVEXT].func) +#define glProgramUniform1uiEXT ((PFNGLPROGRAMUNIFORM1UIEXTPROC)gl_addr[GLPROGRAMUNIFORM1UIEXT].func) +#define glProgramUniform1uivEXT ((PFNGLPROGRAMUNIFORM1UIVEXTPROC)gl_addr[GLPROGRAMUNIFORM1UIVEXT].func) +#define glProgramUniform2fEXT ((PFNGLPROGRAMUNIFORM2FEXTPROC)gl_addr[GLPROGRAMUNIFORM2FEXT].func) +#define glProgramUniform2fvEXT ((PFNGLPROGRAMUNIFORM2FVEXTPROC)gl_addr[GLPROGRAMUNIFORM2FVEXT].func) +#define glProgramUniform2iEXT ((PFNGLPROGRAMUNIFORM2IEXTPROC)gl_addr[GLPROGRAMUNIFORM2IEXT].func) +#define glProgramUniform2ivEXT ((PFNGLPROGRAMUNIFORM2IVEXTPROC)gl_addr[GLPROGRAMUNIFORM2IVEXT].func) +#define glProgramUniform2uiEXT ((PFNGLPROGRAMUNIFORM2UIEXTPROC)gl_addr[GLPROGRAMUNIFORM2UIEXT].func) +#define glProgramUniform2uivEXT ((PFNGLPROGRAMUNIFORM2UIVEXTPROC)gl_addr[GLPROGRAMUNIFORM2UIVEXT].func) +#define glProgramUniform3fEXT ((PFNGLPROGRAMUNIFORM3FEXTPROC)gl_addr[GLPROGRAMUNIFORM3FEXT].func) +#define glProgramUniform3fvEXT ((PFNGLPROGRAMUNIFORM3FVEXTPROC)gl_addr[GLPROGRAMUNIFORM3FVEXT].func) +#define glProgramUniform3iEXT ((PFNGLPROGRAMUNIFORM3IEXTPROC)gl_addr[GLPROGRAMUNIFORM3IEXT].func) +#define glProgramUniform3ivEXT ((PFNGLPROGRAMUNIFORM3IVEXTPROC)gl_addr[GLPROGRAMUNIFORM3IVEXT].func) +#define glProgramUniform3uiEXT ((PFNGLPROGRAMUNIFORM3UIEXTPROC)gl_addr[GLPROGRAMUNIFORM3UIEXT].func) +#define glProgramUniform3uivEXT ((PFNGLPROGRAMUNIFORM3UIVEXTPROC)gl_addr[GLPROGRAMUNIFORM3UIVEXT].func) +#define glProgramUniform4fEXT ((PFNGLPROGRAMUNIFORM4FEXTPROC)gl_addr[GLPROGRAMUNIFORM4FEXT].func) +#define glProgramUniform4fvEXT ((PFNGLPROGRAMUNIFORM4FVEXTPROC)gl_addr[GLPROGRAMUNIFORM4FVEXT].func) +#define glProgramUniform4iEXT ((PFNGLPROGRAMUNIFORM4IEXTPROC)gl_addr[GLPROGRAMUNIFORM4IEXT].func) +#define glProgramUniform4ivEXT ((PFNGLPROGRAMUNIFORM4IVEXTPROC)gl_addr[GLPROGRAMUNIFORM4IVEXT].func) +#define glProgramUniform4uiEXT ((PFNGLPROGRAMUNIFORM4UIEXTPROC)gl_addr[GLPROGRAMUNIFORM4UIEXT].func) +#define glProgramUniform4uivEXT ((PFNGLPROGRAMUNIFORM4UIVEXTPROC)gl_addr[GLPROGRAMUNIFORM4UIVEXT].func) +#define glProgramUniformMatrix2fvEXT ((PFNGLPROGRAMUNIFORMMATRIX2FVEXTPROC)gl_addr[GLPROGRAMUNIFORMMATRIX2FVEXT].func) +#define glProgramUniformMatrix2x3fvEXT ((PFNGLPROGRAMUNIFORMMATRIX2X3FVEXTPROC)gl_addr[GLPROGRAMUNIFORMMATRIX2X3FVEXT].func) +#define glProgramUniformMatrix2x4fvEXT ((PFNGLPROGRAMUNIFORMMATRIX2X4FVEXTPROC)gl_addr[GLPROGRAMUNIFORMMATRIX2X4FVEXT].func) +#define glProgramUniformMatrix3fvEXT ((PFNGLPROGRAMUNIFORMMATRIX3FVEXTPROC)gl_addr[GLPROGRAMUNIFORMMATRIX3FVEXT].func) +#define glProgramUniformMatrix3x2fvEXT ((PFNGLPROGRAMUNIFORMMATRIX3X2FVEXTPROC)gl_addr[GLPROGRAMUNIFORMMATRIX3X2FVEXT].func) +#define glProgramUniformMatrix3x4fvEXT ((PFNGLPROGRAMUNIFORMMATRIX3X4FVEXTPROC)gl_addr[GLPROGRAMUNIFORMMATRIX3X4FVEXT].func) +#define glProgramUniformMatrix4fvEXT ((PFNGLPROGRAMUNIFORMMATRIX4FVEXTPROC)gl_addr[GLPROGRAMUNIFORMMATRIX4FVEXT].func) +#define glProgramUniformMatrix4x2fvEXT ((PFNGLPROGRAMUNIFORMMATRIX4X2FVEXTPROC)gl_addr[GLPROGRAMUNIFORMMATRIX4X2FVEXT].func) +#define glProgramUniformMatrix4x3fvEXT ((PFNGLPROGRAMUNIFORMMATRIX4X3FVEXTPROC)gl_addr[GLPROGRAMUNIFORMMATRIX4X3FVEXT].func) +#define glProgramVertexLimitNV ((PFNGLPROGRAMVERTEXLIMITNVPROC)gl_addr[GLPROGRAMVERTEXLIMITNV].func) +#define glPushClientAttribDefaultEXT ((PFNGLPUSHCLIENTATTRIBDEFAULTEXTPROC)gl_addr[GLPUSHCLIENTATTRIBDEFAULTEXT].func) +#define glQueryCounter ((PFNGLQUERYCOUNTERPROC)gl_addr[GLQUERYCOUNTER].func) +#define glRenderbufferStorage ((PFNGLRENDERBUFFERSTORAGEPROC)gl_addr[GLRENDERBUFFERSTORAGE].func) +#define glRenderbufferStorageMultisample ((PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC)gl_addr[GLRENDERBUFFERSTORAGEMULTISAMPLE].func) +#define glRenderbufferStorageMultisampleEXT ((PFNGLRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC)gl_addr[GLRENDERBUFFERSTORAGEMULTISAMPLEEXT].func) +#define glRequestResidentProgramsNV ((PFNGLREQUESTRESIDENTPROGRAMSNVPROC)gl_addr[GLREQUESTRESIDENTPROGRAMSNV].func) +#define glResetHistogram ((PFNGLRESETHISTOGRAMPROC)gl_addr[GLRESETHISTOGRAM].func) +#define glResetMinmax ((PFNGLRESETMINMAXPROC)gl_addr[GLRESETMINMAX].func) +#define glSampleCoverage ((PFNGLSAMPLECOVERAGEPROC)gl_addr[GLSAMPLECOVERAGE].func) +#define glSampleCoverageARB ((PFNGLSAMPLECOVERAGEARBPROC)gl_addr[GLSAMPLECOVERAGEARB].func) +#define glSampleMaskIndexedNV ((PFNGLSAMPLEMASKINDEXEDNVPROC)gl_addr[GLSAMPLEMASKINDEXEDNV].func) +#define glSamplerParameterf ((PFNGLSAMPLERPARAMETERFPROC)gl_addr[GLSAMPLERPARAMETERF].func) +#define glSamplerParameterfv ((PFNGLSAMPLERPARAMETERFVPROC)gl_addr[GLSAMPLERPARAMETERFV].func) +#define glSamplerParameteri ((PFNGLSAMPLERPARAMETERIPROC)gl_addr[GLSAMPLERPARAMETERI].func) +#define glSecondaryColor3b ((PFNGLSECONDARYCOLOR3BPROC)gl_addr[GLSECONDARYCOLOR3B].func) +#define glSecondaryColor3bEXT ((PFNGLSECONDARYCOLOR3BEXTPROC)gl_addr[GLSECONDARYCOLOR3BEXT].func) +#define glSecondaryColor3bv ((PFNGLSECONDARYCOLOR3BVPROC)gl_addr[GLSECONDARYCOLOR3BV].func) +#define glSecondaryColor3bvEXT ((PFNGLSECONDARYCOLOR3BVEXTPROC)gl_addr[GLSECONDARYCOLOR3BVEXT].func) +#define glSecondaryColor3d ((PFNGLSECONDARYCOLOR3DPROC)gl_addr[GLSECONDARYCOLOR3D].func) +#define glSecondaryColor3dEXT ((PFNGLSECONDARYCOLOR3DEXTPROC)gl_addr[GLSECONDARYCOLOR3DEXT].func) +#define glSecondaryColor3dv ((PFNGLSECONDARYCOLOR3DVPROC)gl_addr[GLSECONDARYCOLOR3DV].func) +#define glSecondaryColor3dvEXT ((PFNGLSECONDARYCOLOR3DVEXTPROC)gl_addr[GLSECONDARYCOLOR3DVEXT].func) +#define glSecondaryColor3f ((PFNGLSECONDARYCOLOR3FPROC)gl_addr[GLSECONDARYCOLOR3F].func) +#define glSecondaryColor3fEXT ((PFNGLSECONDARYCOLOR3FEXTPROC)gl_addr[GLSECONDARYCOLOR3FEXT].func) +#define glSecondaryColor3fv ((PFNGLSECONDARYCOLOR3FVPROC)gl_addr[GLSECONDARYCOLOR3FV].func) +#define glSecondaryColor3fvEXT ((PFNGLSECONDARYCOLOR3FVEXTPROC)gl_addr[GLSECONDARYCOLOR3FVEXT].func) +#define glSecondaryColor3hNV ((PFNGLSECONDARYCOLOR3HNVPROC)gl_addr[GLSECONDARYCOLOR3HNV].func) +#define glSecondaryColor3hvNV ((PFNGLSECONDARYCOLOR3HVNVPROC)gl_addr[GLSECONDARYCOLOR3HVNV].func) +#define glSecondaryColor3i ((PFNGLSECONDARYCOLOR3IPROC)gl_addr[GLSECONDARYCOLOR3I].func) +#define glSecondaryColor3iEXT ((PFNGLSECONDARYCOLOR3IEXTPROC)gl_addr[GLSECONDARYCOLOR3IEXT].func) +#define glSecondaryColor3iv ((PFNGLSECONDARYCOLOR3IVPROC)gl_addr[GLSECONDARYCOLOR3IV].func) +#define glSecondaryColor3ivEXT ((PFNGLSECONDARYCOLOR3IVEXTPROC)gl_addr[GLSECONDARYCOLOR3IVEXT].func) +#define glSecondaryColor3s ((PFNGLSECONDARYCOLOR3SPROC)gl_addr[GLSECONDARYCOLOR3S].func) +#define glSecondaryColor3sEXT ((PFNGLSECONDARYCOLOR3SEXTPROC)gl_addr[GLSECONDARYCOLOR3SEXT].func) +#define glSecondaryColor3sv ((PFNGLSECONDARYCOLOR3SVPROC)gl_addr[GLSECONDARYCOLOR3SV].func) +#define glSecondaryColor3svEXT ((PFNGLSECONDARYCOLOR3SVEXTPROC)gl_addr[GLSECONDARYCOLOR3SVEXT].func) +#define glSecondaryColor3ub ((PFNGLSECONDARYCOLOR3UBPROC)gl_addr[GLSECONDARYCOLOR3UB].func) +#define glSecondaryColor3ubEXT ((PFNGLSECONDARYCOLOR3UBEXTPROC)gl_addr[GLSECONDARYCOLOR3UBEXT].func) +#define glSecondaryColor3ubv ((PFNGLSECONDARYCOLOR3UBVPROC)gl_addr[GLSECONDARYCOLOR3UBV].func) +#define glSecondaryColor3ubvEXT ((PFNGLSECONDARYCOLOR3UBVEXTPROC)gl_addr[GLSECONDARYCOLOR3UBVEXT].func) +#define glSecondaryColor3ui ((PFNGLSECONDARYCOLOR3UIPROC)gl_addr[GLSECONDARYCOLOR3UI].func) +#define glSecondaryColor3uiEXT ((PFNGLSECONDARYCOLOR3UIEXTPROC)gl_addr[GLSECONDARYCOLOR3UIEXT].func) +#define glSecondaryColor3uiv ((PFNGLSECONDARYCOLOR3UIVPROC)gl_addr[GLSECONDARYCOLOR3UIV].func) +#define glSecondaryColor3uivEXT ((PFNGLSECONDARYCOLOR3UIVEXTPROC)gl_addr[GLSECONDARYCOLOR3UIVEXT].func) +#define glSecondaryColor3us ((PFNGLSECONDARYCOLOR3USPROC)gl_addr[GLSECONDARYCOLOR3US].func) +#define glSecondaryColor3usEXT ((PFNGLSECONDARYCOLOR3USEXTPROC)gl_addr[GLSECONDARYCOLOR3USEXT].func) +#define glSecondaryColor3usv ((PFNGLSECONDARYCOLOR3USVPROC)gl_addr[GLSECONDARYCOLOR3USV].func) +#define glSecondaryColor3usvEXT ((PFNGLSECONDARYCOLOR3USVEXTPROC)gl_addr[GLSECONDARYCOLOR3USVEXT].func) +#define glSecondaryColorPointer ((PFNGLSECONDARYCOLORPOINTERPROC)gl_addr[GLSECONDARYCOLORPOINTER].func) +#define glSecondaryColorPointerEXT ((PFNGLSECONDARYCOLORPOINTEREXTPROC)gl_addr[GLSECONDARYCOLORPOINTEREXT].func) +#define glSeparableFilter2D ((PFNGLSEPARABLEFILTER2DPROC)gl_addr[GLSEPARABLEFILTER2D].func) +#define glSetFenceNV ((PFNGLSETFENCENVPROC)gl_addr[GLSETFENCENV].func) +#define glShaderSource ((PFNGLSHADERSOURCEPROC)gl_addr[GLSHADERSOURCE].func) +#define glShaderSourceARB ((PFNGLSHADERSOURCEARBPROC)gl_addr[GLSHADERSOURCEARB].func) +#define glStencilFuncSeparate ((PFNGLSTENCILFUNCSEPARATEPROC)gl_addr[GLSTENCILFUNCSEPARATE].func) +#define glStencilMaskSeparate ((PFNGLSTENCILMASKSEPARATEPROC)gl_addr[GLSTENCILMASKSEPARATE].func) +#define glStencilOpSeparate ((PFNGLSTENCILOPSEPARATEPROC)gl_addr[GLSTENCILOPSEPARATE].func) +#define glTestFenceNV ((PFNGLTESTFENCENVPROC)gl_addr[GLTESTFENCENV].func) +#define glTexBufferARB ((PFNGLTEXBUFFERARBPROC)gl_addr[GLTEXBUFFERARB].func) +#define glTexBufferEXT ((PFNGLTEXBUFFEREXTPROC)gl_addr[GLTEXBUFFEREXT].func) +#define glTexCoord1hNV ((PFNGLTEXCOORD1HNVPROC)gl_addr[GLTEXCOORD1HNV].func) +#define glTexCoord1hvNV ((PFNGLTEXCOORD1HVNVPROC)gl_addr[GLTEXCOORD1HVNV].func) +#define glTexCoord2hNV ((PFNGLTEXCOORD2HNVPROC)gl_addr[GLTEXCOORD2HNV].func) +#define glTexCoord2hvNV ((PFNGLTEXCOORD2HVNVPROC)gl_addr[GLTEXCOORD2HVNV].func) +#define glTexCoord3hNV ((PFNGLTEXCOORD3HNVPROC)gl_addr[GLTEXCOORD3HNV].func) +#define glTexCoord3hvNV ((PFNGLTEXCOORD3HVNVPROC)gl_addr[GLTEXCOORD3HVNV].func) +#define glTexCoord4hNV ((PFNGLTEXCOORD4HNVPROC)gl_addr[GLTEXCOORD4HNV].func) +#define glTexCoord4hvNV ((PFNGLTEXCOORD4HVNVPROC)gl_addr[GLTEXCOORD4HVNV].func) +#define glTexCoordPointerEXT ((PFNGLTEXCOORDPOINTEREXTPROC)gl_addr[GLTEXCOORDPOINTEREXT].func) +#define glTexImage3D ((PFNGLTEXIMAGE3DPROC)gl_addr[GLTEXIMAGE3D].func) +#define glTexImage3DEXT ((PFNGLTEXIMAGE3DEXTPROC)gl_addr[GLTEXIMAGE3DEXT].func) +#define glTexParameterIiv ((PFNGLTEXPARAMETERIIVPROC)gl_addr[GLTEXPARAMETERIIV].func) +#define glTexParameterIivEXT ((PFNGLTEXPARAMETERIIVEXTPROC)gl_addr[GLTEXPARAMETERIIVEXT].func) +#define glTexParameterIuiv ((PFNGLTEXPARAMETERIUIVPROC)gl_addr[GLTEXPARAMETERIUIV].func) +#define glTexParameterIuivEXT ((PFNGLTEXPARAMETERIUIVEXTPROC)gl_addr[GLTEXPARAMETERIUIVEXT].func) +#define glTexRenderbufferNV ((PFNGLTEXRENDERBUFFERNVPROC)gl_addr[GLTEXRENDERBUFFERNV].func) +#define glTexStorage2D ((PFNGLTEXSTORAGE2DPROC)gl_addr[GLTEXSTORAGE2D].func) +#define glTexSubImage3D ((PFNGLTEXSUBIMAGE3DPROC)gl_addr[GLTEXSUBIMAGE3D].func) +#define glTexSubImage3DEXT ((PFNGLTEXSUBIMAGE3DEXTPROC)gl_addr[GLTEXSUBIMAGE3DEXT].func) +#define glTextureBarrierNV ((PFNGLTEXTUREBARRIERNVPROC)gl_addr[GLTEXTUREBARRIERNV].func) +#define glTextureBufferEXT ((PFNGLTEXTUREBUFFEREXTPROC)gl_addr[GLTEXTUREBUFFEREXT].func) +#define glTextureImage1DEXT ((PFNGLTEXTUREIMAGE1DEXTPROC)gl_addr[GLTEXTUREIMAGE1DEXT].func) +#define glTextureImage2DEXT ((PFNGLTEXTUREIMAGE2DEXTPROC)gl_addr[GLTEXTUREIMAGE2DEXT].func) +#define glTextureImage3DEXT ((PFNGLTEXTUREIMAGE3DEXTPROC)gl_addr[GLTEXTUREIMAGE3DEXT].func) +#define glTextureParameterfEXT ((PFNGLTEXTUREPARAMETERFEXTPROC)gl_addr[GLTEXTUREPARAMETERFEXT].func) +#define glTextureParameterfvEXT ((PFNGLTEXTUREPARAMETERFVEXTPROC)gl_addr[GLTEXTUREPARAMETERFVEXT].func) +#define glTextureParameteriEXT ((PFNGLTEXTUREPARAMETERIEXTPROC)gl_addr[GLTEXTUREPARAMETERIEXT].func) +#define glTextureParameterIivEXT ((PFNGLTEXTUREPARAMETERIIVEXTPROC)gl_addr[GLTEXTUREPARAMETERIIVEXT].func) +#define glTextureParameterIuivEXT ((PFNGLTEXTUREPARAMETERIUIVEXTPROC)gl_addr[GLTEXTUREPARAMETERIUIVEXT].func) +#define glTextureParameterivEXT ((PFNGLTEXTUREPARAMETERIVEXTPROC)gl_addr[GLTEXTUREPARAMETERIVEXT].func) +#define glTextureRenderbufferEXT ((PFNGLTEXTURERENDERBUFFEREXTPROC)gl_addr[GLTEXTURERENDERBUFFEREXT].func) +#define glTextureStorage2DEXT ((PFNGLTEXTURESTORAGE2DEXTPROC)gl_addr[GLTEXTURESTORAGE2DEXT].func) +#define glTextureSubImage1DEXT ((PFNGLTEXTURESUBIMAGE1DEXTPROC)gl_addr[GLTEXTURESUBIMAGE1DEXT].func) +#define glTextureSubImage2DEXT ((PFNGLTEXTURESUBIMAGE2DEXTPROC)gl_addr[GLTEXTURESUBIMAGE2DEXT].func) +#define glTextureSubImage3DEXT ((PFNGLTEXTURESUBIMAGE3DEXTPROC)gl_addr[GLTEXTURESUBIMAGE3DEXT].func) +#define glTrackMatrixNV ((PFNGLTRACKMATRIXNVPROC)gl_addr[GLTRACKMATRIXNV].func) +#define glTransformFeedbackAttribsNV ((PFNGLTRANSFORMFEEDBACKATTRIBSNVPROC)gl_addr[GLTRANSFORMFEEDBACKATTRIBSNV].func) +#define glTransformFeedbackVaryings ((PFNGLTRANSFORMFEEDBACKVARYINGSPROC)gl_addr[GLTRANSFORMFEEDBACKVARYINGS].func) +#define glTransformFeedbackVaryingsNV ((PFNGLTRANSFORMFEEDBACKVARYINGSNVPROC)gl_addr[GLTRANSFORMFEEDBACKVARYINGSNV].func) +#define glUniform1f ((PFNGLUNIFORM1FPROC)gl_addr[GLUNIFORM1F].func) +#define glUniform1fARB ((PFNGLUNIFORM1FARBPROC)gl_addr[GLUNIFORM1FARB].func) +#define glUniform1fv ((PFNGLUNIFORM1FVPROC)gl_addr[GLUNIFORM1FV].func) +#define glUniform1fvARB ((PFNGLUNIFORM1FVARBPROC)gl_addr[GLUNIFORM1FVARB].func) +#define glUniform1i ((PFNGLUNIFORM1IPROC)gl_addr[GLUNIFORM1I].func) +#define glUniform1iARB ((PFNGLUNIFORM1IARBPROC)gl_addr[GLUNIFORM1IARB].func) +#define glUniform1iv ((PFNGLUNIFORM1IVPROC)gl_addr[GLUNIFORM1IV].func) +#define glUniform1ivARB ((PFNGLUNIFORM1IVARBPROC)gl_addr[GLUNIFORM1IVARB].func) +#define glUniform1ui ((PFNGLUNIFORM1UIPROC)gl_addr[GLUNIFORM1UI].func) +#define glUniform1uiEXT ((PFNGLUNIFORM1UIEXTPROC)gl_addr[GLUNIFORM1UIEXT].func) +#define glUniform1uiv ((PFNGLUNIFORM1UIVPROC)gl_addr[GLUNIFORM1UIV].func) +#define glUniform1uivEXT ((PFNGLUNIFORM1UIVEXTPROC)gl_addr[GLUNIFORM1UIVEXT].func) +#define glUniform2f ((PFNGLUNIFORM2FPROC)gl_addr[GLUNIFORM2F].func) +#define glUniform2fARB ((PFNGLUNIFORM2FARBPROC)gl_addr[GLUNIFORM2FARB].func) +#define glUniform2fv ((PFNGLUNIFORM2FVPROC)gl_addr[GLUNIFORM2FV].func) +#define glUniform2fvARB ((PFNGLUNIFORM2FVARBPROC)gl_addr[GLUNIFORM2FVARB].func) +#define glUniform2i ((PFNGLUNIFORM2IPROC)gl_addr[GLUNIFORM2I].func) +#define glUniform2iARB ((PFNGLUNIFORM2IARBPROC)gl_addr[GLUNIFORM2IARB].func) +#define glUniform2iv ((PFNGLUNIFORM2IVPROC)gl_addr[GLUNIFORM2IV].func) +#define glUniform2ivARB ((PFNGLUNIFORM2IVARBPROC)gl_addr[GLUNIFORM2IVARB].func) +#define glUniform2ui ((PFNGLUNIFORM2UIPROC)gl_addr[GLUNIFORM2UI].func) +#define glUniform2uiEXT ((PFNGLUNIFORM2UIEXTPROC)gl_addr[GLUNIFORM2UIEXT].func) +#define glUniform2uiv ((PFNGLUNIFORM2UIVPROC)gl_addr[GLUNIFORM2UIV].func) +#define glUniform2uivEXT ((PFNGLUNIFORM2UIVEXTPROC)gl_addr[GLUNIFORM2UIVEXT].func) +#define glUniform3f ((PFNGLUNIFORM3FPROC)gl_addr[GLUNIFORM3F].func) +#define glUniform3fARB ((PFNGLUNIFORM3FARBPROC)gl_addr[GLUNIFORM3FARB].func) +#define glUniform3fv ((PFNGLUNIFORM3FVPROC)gl_addr[GLUNIFORM3FV].func) +#define glUniform3fvARB ((PFNGLUNIFORM3FVARBPROC)gl_addr[GLUNIFORM3FVARB].func) +#define glUniform3i ((PFNGLUNIFORM3IPROC)gl_addr[GLUNIFORM3I].func) +#define glUniform3iARB ((PFNGLUNIFORM3IARBPROC)gl_addr[GLUNIFORM3IARB].func) +#define glUniform3iv ((PFNGLUNIFORM3IVPROC)gl_addr[GLUNIFORM3IV].func) +#define glUniform3ivARB ((PFNGLUNIFORM3IVARBPROC)gl_addr[GLUNIFORM3IVARB].func) +#define glUniform3ui ((PFNGLUNIFORM3UIPROC)gl_addr[GLUNIFORM3UI].func) +#define glUniform3uiEXT ((PFNGLUNIFORM3UIEXTPROC)gl_addr[GLUNIFORM3UIEXT].func) +#define glUniform3uiv ((PFNGLUNIFORM3UIVPROC)gl_addr[GLUNIFORM3UIV].func) +#define glUniform3uivEXT ((PFNGLUNIFORM3UIVEXTPROC)gl_addr[GLUNIFORM3UIVEXT].func) +#define glUniform4f ((PFNGLUNIFORM4FPROC)gl_addr[GLUNIFORM4F].func) +#define glUniform4fARB ((PFNGLUNIFORM4FARBPROC)gl_addr[GLUNIFORM4FARB].func) +#define glUniform4fv ((PFNGLUNIFORM4FVPROC)gl_addr[GLUNIFORM4FV].func) +#define glUniform4fvARB ((PFNGLUNIFORM4FVARBPROC)gl_addr[GLUNIFORM4FVARB].func) +#define glUniform4i ((PFNGLUNIFORM4IPROC)gl_addr[GLUNIFORM4I].func) +#define glUniform4iARB ((PFNGLUNIFORM4IARBPROC)gl_addr[GLUNIFORM4IARB].func) +#define glUniform4iv ((PFNGLUNIFORM4IVPROC)gl_addr[GLUNIFORM4IV].func) +#define glUniform4ivARB ((PFNGLUNIFORM4IVARBPROC)gl_addr[GLUNIFORM4IVARB].func) +#define glUniform4ui ((PFNGLUNIFORM4UIPROC)gl_addr[GLUNIFORM4UI].func) +#define glUniform4uiEXT ((PFNGLUNIFORM4UIEXTPROC)gl_addr[GLUNIFORM4UIEXT].func) +#define glUniform4uiv ((PFNGLUNIFORM4UIVPROC)gl_addr[GLUNIFORM4UIV].func) +#define glUniform4uivEXT ((PFNGLUNIFORM4UIVEXTPROC)gl_addr[GLUNIFORM4UIVEXT].func) +#define glUniformBufferEXT ((PFNGLUNIFORMBUFFEREXTPROC)gl_addr[GLUNIFORMBUFFEREXT].func) +#define glUniformMatrix2fv ((PFNGLUNIFORMMATRIX2FVPROC)gl_addr[GLUNIFORMMATRIX2FV].func) +#define glUniformMatrix2fvARB ((PFNGLUNIFORMMATRIX2FVARBPROC)gl_addr[GLUNIFORMMATRIX2FVARB].func) +#define glUniformMatrix2x3fv ((PFNGLUNIFORMMATRIX2X3FVPROC)gl_addr[GLUNIFORMMATRIX2X3FV].func) +#define glUniformMatrix2x4fv ((PFNGLUNIFORMMATRIX2X4FVPROC)gl_addr[GLUNIFORMMATRIX2X4FV].func) +#define glUniformMatrix3fv ((PFNGLUNIFORMMATRIX3FVPROC)gl_addr[GLUNIFORMMATRIX3FV].func) +#define glUniformMatrix3fvARB ((PFNGLUNIFORMMATRIX3FVARBPROC)gl_addr[GLUNIFORMMATRIX3FVARB].func) +#define glUniformMatrix3x2fv ((PFNGLUNIFORMMATRIX3X2FVPROC)gl_addr[GLUNIFORMMATRIX3X2FV].func) +#define glUniformMatrix3x4fv ((PFNGLUNIFORMMATRIX3X4FVPROC)gl_addr[GLUNIFORMMATRIX3X4FV].func) +#define glUniformMatrix4fv ((PFNGLUNIFORMMATRIX4FVPROC)gl_addr[GLUNIFORMMATRIX4FV].func) +#define glUniformMatrix4fvARB ((PFNGLUNIFORMMATRIX4FVARBPROC)gl_addr[GLUNIFORMMATRIX4FVARB].func) +#define glUniformMatrix4x2fv ((PFNGLUNIFORMMATRIX4X2FVPROC)gl_addr[GLUNIFORMMATRIX4X2FV].func) +#define glUniformMatrix4x3fv ((PFNGLUNIFORMMATRIX4X3FVPROC)gl_addr[GLUNIFORMMATRIX4X3FV].func) +#define glUnlockArraysEXT ((PFNGLUNLOCKARRAYSEXTPROC)gl_addr[GLUNLOCKARRAYSEXT].func) +#define glUnmapBuffer ((PFNGLUNMAPBUFFERPROC)gl_addr[GLUNMAPBUFFER].func) +#define glUnmapBufferARB ((PFNGLUNMAPBUFFERARBPROC)gl_addr[GLUNMAPBUFFERARB].func) +#define glUseProgramObjectARB ((PFNGLUSEPROGRAMOBJECTARBPROC)gl_addr[GLUSEPROGRAMOBJECTARB].func) +#define glValidateProgram ((PFNGLVALIDATEPROGRAMPROC)gl_addr[GLVALIDATEPROGRAM].func) +#define glValidateProgramARB ((PFNGLVALIDATEPROGRAMARBPROC)gl_addr[GLVALIDATEPROGRAMARB].func) +#define glVertex2hNV ((PFNGLVERTEX2HNVPROC)gl_addr[GLVERTEX2HNV].func) +#define glVertex2hvNV ((PFNGLVERTEX2HVNVPROC)gl_addr[GLVERTEX2HVNV].func) +#define glVertex3hNV ((PFNGLVERTEX3HNVPROC)gl_addr[GLVERTEX3HNV].func) +#define glVertex3hvNV ((PFNGLVERTEX3HVNVPROC)gl_addr[GLVERTEX3HVNV].func) +#define glVertex4hNV ((PFNGLVERTEX4HNVPROC)gl_addr[GLVERTEX4HNV].func) +#define glVertex4hvNV ((PFNGLVERTEX4HVNVPROC)gl_addr[GLVERTEX4HVNV].func) +#define glVertexArrayRangeNV ((PFNGLVERTEXARRAYRANGENVPROC)gl_addr[GLVERTEXARRAYRANGENV].func) +#define glVertexAttrib1d ((PFNGLVERTEXATTRIB1DPROC)gl_addr[GLVERTEXATTRIB1D].func) +#define glVertexAttrib1dARB ((PFNGLVERTEXATTRIB1DARBPROC)gl_addr[GLVERTEXATTRIB1DARB].func) +#define glVertexAttrib1dNV ((PFNGLVERTEXATTRIB1DNVPROC)gl_addr[GLVERTEXATTRIB1DNV].func) +#define glVertexAttrib1dv ((PFNGLVERTEXATTRIB1DVPROC)gl_addr[GLVERTEXATTRIB1DV].func) +#define glVertexAttrib1dvARB ((PFNGLVERTEXATTRIB1DVARBPROC)gl_addr[GLVERTEXATTRIB1DVARB].func) +#define glVertexAttrib1dvNV ((PFNGLVERTEXATTRIB1DVNVPROC)gl_addr[GLVERTEXATTRIB1DVNV].func) +#define glVertexAttrib1f ((PFNGLVERTEXATTRIB1FPROC)gl_addr[GLVERTEXATTRIB1F].func) +#define glVertexAttrib1fARB ((PFNGLVERTEXATTRIB1FARBPROC)gl_addr[GLVERTEXATTRIB1FARB].func) +#define glVertexAttrib1fNV ((PFNGLVERTEXATTRIB1FNVPROC)gl_addr[GLVERTEXATTRIB1FNV].func) +#define glVertexAttrib1fv ((PFNGLVERTEXATTRIB1FVPROC)gl_addr[GLVERTEXATTRIB1FV].func) +#define glVertexAttrib1fvARB ((PFNGLVERTEXATTRIB1FVARBPROC)gl_addr[GLVERTEXATTRIB1FVARB].func) +#define glVertexAttrib1fvNV ((PFNGLVERTEXATTRIB1FVNVPROC)gl_addr[GLVERTEXATTRIB1FVNV].func) +#define glVertexAttrib1hNV ((PFNGLVERTEXATTRIB1HNVPROC)gl_addr[GLVERTEXATTRIB1HNV].func) +#define glVertexAttrib1hvNV ((PFNGLVERTEXATTRIB1HVNVPROC)gl_addr[GLVERTEXATTRIB1HVNV].func) +#define glVertexAttrib1s ((PFNGLVERTEXATTRIB1SPROC)gl_addr[GLVERTEXATTRIB1S].func) +#define glVertexAttrib1sARB ((PFNGLVERTEXATTRIB1SARBPROC)gl_addr[GLVERTEXATTRIB1SARB].func) +#define glVertexAttrib1sNV ((PFNGLVERTEXATTRIB1SNVPROC)gl_addr[GLVERTEXATTRIB1SNV].func) +#define glVertexAttrib1sv ((PFNGLVERTEXATTRIB1SVPROC)gl_addr[GLVERTEXATTRIB1SV].func) +#define glVertexAttrib1svARB ((PFNGLVERTEXATTRIB1SVARBPROC)gl_addr[GLVERTEXATTRIB1SVARB].func) +#define glVertexAttrib1svNV ((PFNGLVERTEXATTRIB1SVNVPROC)gl_addr[GLVERTEXATTRIB1SVNV].func) +#define glVertexAttrib2d ((PFNGLVERTEXATTRIB2DPROC)gl_addr[GLVERTEXATTRIB2D].func) +#define glVertexAttrib2dARB ((PFNGLVERTEXATTRIB2DARBPROC)gl_addr[GLVERTEXATTRIB2DARB].func) +#define glVertexAttrib2dNV ((PFNGLVERTEXATTRIB2DNVPROC)gl_addr[GLVERTEXATTRIB2DNV].func) +#define glVertexAttrib2dv ((PFNGLVERTEXATTRIB2DVPROC)gl_addr[GLVERTEXATTRIB2DV].func) +#define glVertexAttrib2dvARB ((PFNGLVERTEXATTRIB2DVARBPROC)gl_addr[GLVERTEXATTRIB2DVARB].func) +#define glVertexAttrib2dvNV ((PFNGLVERTEXATTRIB2DVNVPROC)gl_addr[GLVERTEXATTRIB2DVNV].func) +#define glVertexAttrib2f ((PFNGLVERTEXATTRIB2FPROC)gl_addr[GLVERTEXATTRIB2F].func) +#define glVertexAttrib2fARB ((PFNGLVERTEXATTRIB2FARBPROC)gl_addr[GLVERTEXATTRIB2FARB].func) +#define glVertexAttrib2fNV ((PFNGLVERTEXATTRIB2FNVPROC)gl_addr[GLVERTEXATTRIB2FNV].func) +#define glVertexAttrib2fv ((PFNGLVERTEXATTRIB2FVPROC)gl_addr[GLVERTEXATTRIB2FV].func) +#define glVertexAttrib2fvARB ((PFNGLVERTEXATTRIB2FVARBPROC)gl_addr[GLVERTEXATTRIB2FVARB].func) +#define glVertexAttrib2fvNV ((PFNGLVERTEXATTRIB2FVNVPROC)gl_addr[GLVERTEXATTRIB2FVNV].func) +#define glVertexAttrib2hNV ((PFNGLVERTEXATTRIB2HNVPROC)gl_addr[GLVERTEXATTRIB2HNV].func) +#define glVertexAttrib2hvNV ((PFNGLVERTEXATTRIB2HVNVPROC)gl_addr[GLVERTEXATTRIB2HVNV].func) +#define glVertexAttrib2s ((PFNGLVERTEXATTRIB2SPROC)gl_addr[GLVERTEXATTRIB2S].func) +#define glVertexAttrib2sARB ((PFNGLVERTEXATTRIB2SARBPROC)gl_addr[GLVERTEXATTRIB2SARB].func) +#define glVertexAttrib2sNV ((PFNGLVERTEXATTRIB2SNVPROC)gl_addr[GLVERTEXATTRIB2SNV].func) +#define glVertexAttrib2sv ((PFNGLVERTEXATTRIB2SVPROC)gl_addr[GLVERTEXATTRIB2SV].func) +#define glVertexAttrib2svARB ((PFNGLVERTEXATTRIB2SVARBPROC)gl_addr[GLVERTEXATTRIB2SVARB].func) +#define glVertexAttrib2svNV ((PFNGLVERTEXATTRIB2SVNVPROC)gl_addr[GLVERTEXATTRIB2SVNV].func) +#define glVertexAttrib3d ((PFNGLVERTEXATTRIB3DPROC)gl_addr[GLVERTEXATTRIB3D].func) +#define glVertexAttrib3dARB ((PFNGLVERTEXATTRIB3DARBPROC)gl_addr[GLVERTEXATTRIB3DARB].func) +#define glVertexAttrib3dNV ((PFNGLVERTEXATTRIB3DNVPROC)gl_addr[GLVERTEXATTRIB3DNV].func) +#define glVertexAttrib3dv ((PFNGLVERTEXATTRIB3DVPROC)gl_addr[GLVERTEXATTRIB3DV].func) +#define glVertexAttrib3dvARB ((PFNGLVERTEXATTRIB3DVARBPROC)gl_addr[GLVERTEXATTRIB3DVARB].func) +#define glVertexAttrib3dvNV ((PFNGLVERTEXATTRIB3DVNVPROC)gl_addr[GLVERTEXATTRIB3DVNV].func) +#define glVertexAttrib3f ((PFNGLVERTEXATTRIB3FPROC)gl_addr[GLVERTEXATTRIB3F].func) +#define glVertexAttrib3fARB ((PFNGLVERTEXATTRIB3FARBPROC)gl_addr[GLVERTEXATTRIB3FARB].func) +#define glVertexAttrib3fNV ((PFNGLVERTEXATTRIB3FNVPROC)gl_addr[GLVERTEXATTRIB3FNV].func) +#define glVertexAttrib3fv ((PFNGLVERTEXATTRIB3FVPROC)gl_addr[GLVERTEXATTRIB3FV].func) +#define glVertexAttrib3fvARB ((PFNGLVERTEXATTRIB3FVARBPROC)gl_addr[GLVERTEXATTRIB3FVARB].func) +#define glVertexAttrib3fvNV ((PFNGLVERTEXATTRIB3FVNVPROC)gl_addr[GLVERTEXATTRIB3FVNV].func) +#define glVertexAttrib3hNV ((PFNGLVERTEXATTRIB3HNVPROC)gl_addr[GLVERTEXATTRIB3HNV].func) +#define glVertexAttrib3hvNV ((PFNGLVERTEXATTRIB3HVNVPROC)gl_addr[GLVERTEXATTRIB3HVNV].func) +#define glVertexAttrib3s ((PFNGLVERTEXATTRIB3SPROC)gl_addr[GLVERTEXATTRIB3S].func) +#define glVertexAttrib3sARB ((PFNGLVERTEXATTRIB3SARBPROC)gl_addr[GLVERTEXATTRIB3SARB].func) +#define glVertexAttrib3sNV ((PFNGLVERTEXATTRIB3SNVPROC)gl_addr[GLVERTEXATTRIB3SNV].func) +#define glVertexAttrib3sv ((PFNGLVERTEXATTRIB3SVPROC)gl_addr[GLVERTEXATTRIB3SV].func) +#define glVertexAttrib3svARB ((PFNGLVERTEXATTRIB3SVARBPROC)gl_addr[GLVERTEXATTRIB3SVARB].func) +#define glVertexAttrib3svNV ((PFNGLVERTEXATTRIB3SVNVPROC)gl_addr[GLVERTEXATTRIB3SVNV].func) +#define glVertexAttrib4bv ((PFNGLVERTEXATTRIB4BVPROC)gl_addr[GLVERTEXATTRIB4BV].func) +#define glVertexAttrib4bvARB ((PFNGLVERTEXATTRIB4BVARBPROC)gl_addr[GLVERTEXATTRIB4BVARB].func) +#define glVertexAttrib4d ((PFNGLVERTEXATTRIB4DPROC)gl_addr[GLVERTEXATTRIB4D].func) +#define glVertexAttrib4dARB ((PFNGLVERTEXATTRIB4DARBPROC)gl_addr[GLVERTEXATTRIB4DARB].func) +#define glVertexAttrib4dNV ((PFNGLVERTEXATTRIB4DNVPROC)gl_addr[GLVERTEXATTRIB4DNV].func) +#define glVertexAttrib4dv ((PFNGLVERTEXATTRIB4DVPROC)gl_addr[GLVERTEXATTRIB4DV].func) +#define glVertexAttrib4dvARB ((PFNGLVERTEXATTRIB4DVARBPROC)gl_addr[GLVERTEXATTRIB4DVARB].func) +#define glVertexAttrib4dvNV ((PFNGLVERTEXATTRIB4DVNVPROC)gl_addr[GLVERTEXATTRIB4DVNV].func) +#define glVertexAttrib4f ((PFNGLVERTEXATTRIB4FPROC)gl_addr[GLVERTEXATTRIB4F].func) +#define glVertexAttrib4fARB ((PFNGLVERTEXATTRIB4FARBPROC)gl_addr[GLVERTEXATTRIB4FARB].func) +#define glVertexAttrib4fNV ((PFNGLVERTEXATTRIB4FNVPROC)gl_addr[GLVERTEXATTRIB4FNV].func) +#define glVertexAttrib4fv ((PFNGLVERTEXATTRIB4FVPROC)gl_addr[GLVERTEXATTRIB4FV].func) +#define glVertexAttrib4fvARB ((PFNGLVERTEXATTRIB4FVARBPROC)gl_addr[GLVERTEXATTRIB4FVARB].func) +#define glVertexAttrib4fvNV ((PFNGLVERTEXATTRIB4FVNVPROC)gl_addr[GLVERTEXATTRIB4FVNV].func) +#define glVertexAttrib4hNV ((PFNGLVERTEXATTRIB4HNVPROC)gl_addr[GLVERTEXATTRIB4HNV].func) +#define glVertexAttrib4hvNV ((PFNGLVERTEXATTRIB4HVNVPROC)gl_addr[GLVERTEXATTRIB4HVNV].func) +#define glVertexAttrib4iv ((PFNGLVERTEXATTRIB4IVPROC)gl_addr[GLVERTEXATTRIB4IV].func) +#define glVertexAttrib4ivARB ((PFNGLVERTEXATTRIB4IVARBPROC)gl_addr[GLVERTEXATTRIB4IVARB].func) +#define glVertexAttrib4Nbv ((PFNGLVERTEXATTRIB4NBVPROC)gl_addr[GLVERTEXATTRIB4NBV].func) +#define glVertexAttrib4NbvARB ((PFNGLVERTEXATTRIB4NBVARBPROC)gl_addr[GLVERTEXATTRIB4NBVARB].func) +#define glVertexAttrib4Niv ((PFNGLVERTEXATTRIB4NIVPROC)gl_addr[GLVERTEXATTRIB4NIV].func) +#define glVertexAttrib4NivARB ((PFNGLVERTEXATTRIB4NIVARBPROC)gl_addr[GLVERTEXATTRIB4NIVARB].func) +#define glVertexAttrib4Nsv ((PFNGLVERTEXATTRIB4NSVPROC)gl_addr[GLVERTEXATTRIB4NSV].func) +#define glVertexAttrib4NsvARB ((PFNGLVERTEXATTRIB4NSVARBPROC)gl_addr[GLVERTEXATTRIB4NSVARB].func) +#define glVertexAttrib4Nub ((PFNGLVERTEXATTRIB4NUBPROC)gl_addr[GLVERTEXATTRIB4NUB].func) +#define glVertexAttrib4NubARB ((PFNGLVERTEXATTRIB4NUBARBPROC)gl_addr[GLVERTEXATTRIB4NUBARB].func) +#define glVertexAttrib4Nubv ((PFNGLVERTEXATTRIB4NUBVPROC)gl_addr[GLVERTEXATTRIB4NUBV].func) +#define glVertexAttrib4NubvARB ((PFNGLVERTEXATTRIB4NUBVARBPROC)gl_addr[GLVERTEXATTRIB4NUBVARB].func) +#define glVertexAttrib4Nuiv ((PFNGLVERTEXATTRIB4NUIVPROC)gl_addr[GLVERTEXATTRIB4NUIV].func) +#define glVertexAttrib4NuivARB ((PFNGLVERTEXATTRIB4NUIVARBPROC)gl_addr[GLVERTEXATTRIB4NUIVARB].func) +#define glVertexAttrib4Nusv ((PFNGLVERTEXATTRIB4NUSVPROC)gl_addr[GLVERTEXATTRIB4NUSV].func) +#define glVertexAttrib4NusvARB ((PFNGLVERTEXATTRIB4NUSVARBPROC)gl_addr[GLVERTEXATTRIB4NUSVARB].func) +#define glVertexAttrib4s ((PFNGLVERTEXATTRIB4SPROC)gl_addr[GLVERTEXATTRIB4S].func) +#define glVertexAttrib4sARB ((PFNGLVERTEXATTRIB4SARBPROC)gl_addr[GLVERTEXATTRIB4SARB].func) +#define glVertexAttrib4sNV ((PFNGLVERTEXATTRIB4SNVPROC)gl_addr[GLVERTEXATTRIB4SNV].func) +#define glVertexAttrib4sv ((PFNGLVERTEXATTRIB4SVPROC)gl_addr[GLVERTEXATTRIB4SV].func) +#define glVertexAttrib4svARB ((PFNGLVERTEXATTRIB4SVARBPROC)gl_addr[GLVERTEXATTRIB4SVARB].func) +#define glVertexAttrib4svNV ((PFNGLVERTEXATTRIB4SVNVPROC)gl_addr[GLVERTEXATTRIB4SVNV].func) +#define glVertexAttrib4ubNV ((PFNGLVERTEXATTRIB4UBNVPROC)gl_addr[GLVERTEXATTRIB4UBNV].func) +#define glVertexAttrib4ubv ((PFNGLVERTEXATTRIB4UBVPROC)gl_addr[GLVERTEXATTRIB4UBV].func) +#define glVertexAttrib4ubvARB ((PFNGLVERTEXATTRIB4UBVARBPROC)gl_addr[GLVERTEXATTRIB4UBVARB].func) +#define glVertexAttrib4ubvNV ((PFNGLVERTEXATTRIB4UBVNVPROC)gl_addr[GLVERTEXATTRIB4UBVNV].func) +#define glVertexAttrib4uiv ((PFNGLVERTEXATTRIB4UIVPROC)gl_addr[GLVERTEXATTRIB4UIV].func) +#define glVertexAttrib4uivARB ((PFNGLVERTEXATTRIB4UIVARBPROC)gl_addr[GLVERTEXATTRIB4UIVARB].func) +#define glVertexAttrib4usv ((PFNGLVERTEXATTRIB4USVPROC)gl_addr[GLVERTEXATTRIB4USV].func) +#define glVertexAttrib4usvARB ((PFNGLVERTEXATTRIB4USVARBPROC)gl_addr[GLVERTEXATTRIB4USVARB].func) +#define glVertexAttribI1i ((PFNGLVERTEXATTRIBI1IPROC)gl_addr[GLVERTEXATTRIBI1I].func) +#define glVertexAttribI1iEXT ((PFNGLVERTEXATTRIBI1IEXTPROC)gl_addr[GLVERTEXATTRIBI1IEXT].func) +#define glVertexAttribI1iv ((PFNGLVERTEXATTRIBI1IVPROC)gl_addr[GLVERTEXATTRIBI1IV].func) +#define glVertexAttribI1ivEXT ((PFNGLVERTEXATTRIBI1IVEXTPROC)gl_addr[GLVERTEXATTRIBI1IVEXT].func) +#define glVertexAttribI1ui ((PFNGLVERTEXATTRIBI1UIPROC)gl_addr[GLVERTEXATTRIBI1UI].func) +#define glVertexAttribI1uiEXT ((PFNGLVERTEXATTRIBI1UIEXTPROC)gl_addr[GLVERTEXATTRIBI1UIEXT].func) +#define glVertexAttribI1uiv ((PFNGLVERTEXATTRIBI1UIVPROC)gl_addr[GLVERTEXATTRIBI1UIV].func) +#define glVertexAttribI1uivEXT ((PFNGLVERTEXATTRIBI1UIVEXTPROC)gl_addr[GLVERTEXATTRIBI1UIVEXT].func) +#define glVertexAttribI2i ((PFNGLVERTEXATTRIBI2IPROC)gl_addr[GLVERTEXATTRIBI2I].func) +#define glVertexAttribI2iEXT ((PFNGLVERTEXATTRIBI2IEXTPROC)gl_addr[GLVERTEXATTRIBI2IEXT].func) +#define glVertexAttribI2iv ((PFNGLVERTEXATTRIBI2IVPROC)gl_addr[GLVERTEXATTRIBI2IV].func) +#define glVertexAttribI2ivEXT ((PFNGLVERTEXATTRIBI2IVEXTPROC)gl_addr[GLVERTEXATTRIBI2IVEXT].func) +#define glVertexAttribI2ui ((PFNGLVERTEXATTRIBI2UIPROC)gl_addr[GLVERTEXATTRIBI2UI].func) +#define glVertexAttribI2uiEXT ((PFNGLVERTEXATTRIBI2UIEXTPROC)gl_addr[GLVERTEXATTRIBI2UIEXT].func) +#define glVertexAttribI2uiv ((PFNGLVERTEXATTRIBI2UIVPROC)gl_addr[GLVERTEXATTRIBI2UIV].func) +#define glVertexAttribI2uivEXT ((PFNGLVERTEXATTRIBI2UIVEXTPROC)gl_addr[GLVERTEXATTRIBI2UIVEXT].func) +#define glVertexAttribI3i ((PFNGLVERTEXATTRIBI3IPROC)gl_addr[GLVERTEXATTRIBI3I].func) +#define glVertexAttribI3iEXT ((PFNGLVERTEXATTRIBI3IEXTPROC)gl_addr[GLVERTEXATTRIBI3IEXT].func) +#define glVertexAttribI3iv ((PFNGLVERTEXATTRIBI3IVPROC)gl_addr[GLVERTEXATTRIBI3IV].func) +#define glVertexAttribI3ivEXT ((PFNGLVERTEXATTRIBI3IVEXTPROC)gl_addr[GLVERTEXATTRIBI3IVEXT].func) +#define glVertexAttribI3ui ((PFNGLVERTEXATTRIBI3UIPROC)gl_addr[GLVERTEXATTRIBI3UI].func) +#define glVertexAttribI3uiEXT ((PFNGLVERTEXATTRIBI3UIEXTPROC)gl_addr[GLVERTEXATTRIBI3UIEXT].func) +#define glVertexAttribI3uiv ((PFNGLVERTEXATTRIBI3UIVPROC)gl_addr[GLVERTEXATTRIBI3UIV].func) +#define glVertexAttribI3uivEXT ((PFNGLVERTEXATTRIBI3UIVEXTPROC)gl_addr[GLVERTEXATTRIBI3UIVEXT].func) +#define glVertexAttribI4bv ((PFNGLVERTEXATTRIBI4BVPROC)gl_addr[GLVERTEXATTRIBI4BV].func) +#define glVertexAttribI4bvEXT ((PFNGLVERTEXATTRIBI4BVEXTPROC)gl_addr[GLVERTEXATTRIBI4BVEXT].func) +#define glVertexAttribI4i ((PFNGLVERTEXATTRIBI4IPROC)gl_addr[GLVERTEXATTRIBI4I].func) +#define glVertexAttribI4iEXT ((PFNGLVERTEXATTRIBI4IEXTPROC)gl_addr[GLVERTEXATTRIBI4IEXT].func) +#define glVertexAttribI4iv ((PFNGLVERTEXATTRIBI4IVPROC)gl_addr[GLVERTEXATTRIBI4IV].func) +#define glVertexAttribI4ivEXT ((PFNGLVERTEXATTRIBI4IVEXTPROC)gl_addr[GLVERTEXATTRIBI4IVEXT].func) +#define glVertexAttribI4sv ((PFNGLVERTEXATTRIBI4SVPROC)gl_addr[GLVERTEXATTRIBI4SV].func) +#define glVertexAttribI4svEXT ((PFNGLVERTEXATTRIBI4SVEXTPROC)gl_addr[GLVERTEXATTRIBI4SVEXT].func) +#define glVertexAttribI4ubv ((PFNGLVERTEXATTRIBI4UBVPROC)gl_addr[GLVERTEXATTRIBI4UBV].func) +#define glVertexAttribI4ubvEXT ((PFNGLVERTEXATTRIBI4UBVEXTPROC)gl_addr[GLVERTEXATTRIBI4UBVEXT].func) +#define glVertexAttribI4ui ((PFNGLVERTEXATTRIBI4UIPROC)gl_addr[GLVERTEXATTRIBI4UI].func) +#define glVertexAttribI4uiEXT ((PFNGLVERTEXATTRIBI4UIEXTPROC)gl_addr[GLVERTEXATTRIBI4UIEXT].func) +#define glVertexAttribI4uiv ((PFNGLVERTEXATTRIBI4UIVPROC)gl_addr[GLVERTEXATTRIBI4UIV].func) +#define glVertexAttribI4uivEXT ((PFNGLVERTEXATTRIBI4UIVEXTPROC)gl_addr[GLVERTEXATTRIBI4UIVEXT].func) +#define glVertexAttribI4usv ((PFNGLVERTEXATTRIBI4USVPROC)gl_addr[GLVERTEXATTRIBI4USV].func) +#define glVertexAttribI4usvEXT ((PFNGLVERTEXATTRIBI4USVEXTPROC)gl_addr[GLVERTEXATTRIBI4USVEXT].func) +#define glVertexAttribIPointer ((PFNGLVERTEXATTRIBIPOINTERPROC)gl_addr[GLVERTEXATTRIBIPOINTER].func) +#define glVertexAttribIPointerEXT ((PFNGLVERTEXATTRIBIPOINTEREXTPROC)gl_addr[GLVERTEXATTRIBIPOINTEREXT].func) +#define glVertexAttribPointer ((PFNGLVERTEXATTRIBPOINTERPROC)gl_addr[GLVERTEXATTRIBPOINTER].func) +#define glVertexAttribPointerNV ((PFNGLVERTEXATTRIBPOINTERNVPROC)gl_addr[GLVERTEXATTRIBPOINTERNV].func) +#define glVertexAttribs1dvNV ((PFNGLVERTEXATTRIBS1DVNVPROC)gl_addr[GLVERTEXATTRIBS1DVNV].func) +#define glVertexAttribs1fvNV ((PFNGLVERTEXATTRIBS1FVNVPROC)gl_addr[GLVERTEXATTRIBS1FVNV].func) +#define glVertexAttribs1hvNV ((PFNGLVERTEXATTRIBS1HVNVPROC)gl_addr[GLVERTEXATTRIBS1HVNV].func) +#define glVertexAttribs1svNV ((PFNGLVERTEXATTRIBS1SVNVPROC)gl_addr[GLVERTEXATTRIBS1SVNV].func) +#define glVertexAttribs2dvNV ((PFNGLVERTEXATTRIBS2DVNVPROC)gl_addr[GLVERTEXATTRIBS2DVNV].func) +#define glVertexAttribs2fvNV ((PFNGLVERTEXATTRIBS2FVNVPROC)gl_addr[GLVERTEXATTRIBS2FVNV].func) +#define glVertexAttribs2hvNV ((PFNGLVERTEXATTRIBS2HVNVPROC)gl_addr[GLVERTEXATTRIBS2HVNV].func) +#define glVertexAttribs2svNV ((PFNGLVERTEXATTRIBS2SVNVPROC)gl_addr[GLVERTEXATTRIBS2SVNV].func) +#define glVertexAttribs3dvNV ((PFNGLVERTEXATTRIBS3DVNVPROC)gl_addr[GLVERTEXATTRIBS3DVNV].func) +#define glVertexAttribs3fvNV ((PFNGLVERTEXATTRIBS3FVNVPROC)gl_addr[GLVERTEXATTRIBS3FVNV].func) +#define glVertexAttribs3hvNV ((PFNGLVERTEXATTRIBS3HVNVPROC)gl_addr[GLVERTEXATTRIBS3HVNV].func) +#define glVertexAttribs3svNV ((PFNGLVERTEXATTRIBS3SVNVPROC)gl_addr[GLVERTEXATTRIBS3SVNV].func) +#define glVertexAttribs4dvNV ((PFNGLVERTEXATTRIBS4DVNVPROC)gl_addr[GLVERTEXATTRIBS4DVNV].func) +#define glVertexAttribs4fvNV ((PFNGLVERTEXATTRIBS4FVNVPROC)gl_addr[GLVERTEXATTRIBS4FVNV].func) +#define glVertexAttribs4hvNV ((PFNGLVERTEXATTRIBS4HVNVPROC)gl_addr[GLVERTEXATTRIBS4HVNV].func) +#define glVertexAttribs4svNV ((PFNGLVERTEXATTRIBS4SVNVPROC)gl_addr[GLVERTEXATTRIBS4SVNV].func) +#define glVertexAttribs4ubvNV ((PFNGLVERTEXATTRIBS4UBVNVPROC)gl_addr[GLVERTEXATTRIBS4UBVNV].func) +#define glVertexPointerEXT ((PFNGLVERTEXPOINTEREXTPROC)gl_addr[GLVERTEXPOINTEREXT].func) +#define glWindowPos2d ((PFNGLWINDOWPOS2DPROC)gl_addr[GLWINDOWPOS2D].func) +#define glWindowPos2dARB ((PFNGLWINDOWPOS2DARBPROC)gl_addr[GLWINDOWPOS2DARB].func) +#define glWindowPos2dv ((PFNGLWINDOWPOS2DVPROC)gl_addr[GLWINDOWPOS2DV].func) +#define glWindowPos2dvARB ((PFNGLWINDOWPOS2DVARBPROC)gl_addr[GLWINDOWPOS2DVARB].func) +#define glWindowPos2f ((PFNGLWINDOWPOS2FPROC)gl_addr[GLWINDOWPOS2F].func) +#define glWindowPos2fARB ((PFNGLWINDOWPOS2FARBPROC)gl_addr[GLWINDOWPOS2FARB].func) +#define glWindowPos2fv ((PFNGLWINDOWPOS2FVPROC)gl_addr[GLWINDOWPOS2FV].func) +#define glWindowPos2fvARB ((PFNGLWINDOWPOS2FVARBPROC)gl_addr[GLWINDOWPOS2FVARB].func) +#define glWindowPos2i ((PFNGLWINDOWPOS2IPROC)gl_addr[GLWINDOWPOS2I].func) +#define glWindowPos2iARB ((PFNGLWINDOWPOS2IARBPROC)gl_addr[GLWINDOWPOS2IARB].func) +#define glWindowPos2iv ((PFNGLWINDOWPOS2IVPROC)gl_addr[GLWINDOWPOS2IV].func) +#define glWindowPos2ivARB ((PFNGLWINDOWPOS2IVARBPROC)gl_addr[GLWINDOWPOS2IVARB].func) +#define glWindowPos2s ((PFNGLWINDOWPOS2SPROC)gl_addr[GLWINDOWPOS2S].func) +#define glWindowPos2sARB ((PFNGLWINDOWPOS2SARBPROC)gl_addr[GLWINDOWPOS2SARB].func) +#define glWindowPos2sv ((PFNGLWINDOWPOS2SVPROC)gl_addr[GLWINDOWPOS2SV].func) +#define glWindowPos2svARB ((PFNGLWINDOWPOS2SVARBPROC)gl_addr[GLWINDOWPOS2SVARB].func) +#define glWindowPos3d ((PFNGLWINDOWPOS3DPROC)gl_addr[GLWINDOWPOS3D].func) +#define glWindowPos3dARB ((PFNGLWINDOWPOS3DARBPROC)gl_addr[GLWINDOWPOS3DARB].func) +#define glWindowPos3dv ((PFNGLWINDOWPOS3DVPROC)gl_addr[GLWINDOWPOS3DV].func) +#define glWindowPos3dvARB ((PFNGLWINDOWPOS3DVARBPROC)gl_addr[GLWINDOWPOS3DVARB].func) +#define glWindowPos3f ((PFNGLWINDOWPOS3FPROC)gl_addr[GLWINDOWPOS3F].func) +#define glWindowPos3fARB ((PFNGLWINDOWPOS3FARBPROC)gl_addr[GLWINDOWPOS3FARB].func) +#define glWindowPos3fv ((PFNGLWINDOWPOS3FVPROC)gl_addr[GLWINDOWPOS3FV].func) +#define glWindowPos3fvARB ((PFNGLWINDOWPOS3FVARBPROC)gl_addr[GLWINDOWPOS3FVARB].func) +#define glWindowPos3i ((PFNGLWINDOWPOS3IPROC)gl_addr[GLWINDOWPOS3I].func) +#define glWindowPos3iARB ((PFNGLWINDOWPOS3IARBPROC)gl_addr[GLWINDOWPOS3IARB].func) +#define glWindowPos3iv ((PFNGLWINDOWPOS3IVPROC)gl_addr[GLWINDOWPOS3IV].func) +#define glWindowPos3ivARB ((PFNGLWINDOWPOS3IVARBPROC)gl_addr[GLWINDOWPOS3IVARB].func) +#define glWindowPos3s ((PFNGLWINDOWPOS3SPROC)gl_addr[GLWINDOWPOS3S].func) +#define glWindowPos3sARB ((PFNGLWINDOWPOS3SARBPROC)gl_addr[GLWINDOWPOS3SARB].func) +#define glWindowPos3sv ((PFNGLWINDOWPOS3SVPROC)gl_addr[GLWINDOWPOS3SV].func) +#define glWindowPos3svARB ((PFNGLWINDOWPOS3SVARBPROC)gl_addr[GLWINDOWPOS3SVARB].func) +#define wglAllocateMemoryNV ((PFNWGLALLOCATEMEMORYNVPROC)gl_addr[WGLALLOCATEMEMORYNV].func) +#define wglBindSwapBarrierNV ((PFNWGLBINDSWAPBARRIERNVPROC)gl_addr[WGLBINDSWAPBARRIERNV].func) +#define wglBindTexImageARB ((PFNWGLBINDTEXIMAGEARBPROC)gl_addr[WGLBINDTEXIMAGEARB].func) +#define wglBindVideoImageNV ((PFNWGLBINDVIDEOIMAGENVPROC)gl_addr[WGLBINDVIDEOIMAGENV].func) +#define wglChoosePixelFormatARB ((PFNWGLCHOOSEPIXELFORMATARBPROC)gl_addr[WGLCHOOSEPIXELFORMATARB].func) +#define wglCreateBufferRegionARB ((PFNWGLCREATEBUFFERREGIONARBPROC)gl_addr[WGLCREATEBUFFERREGIONARB].func) +#define wglCreateContextAttribsARB ((PFNWGLCREATECONTEXTATTRIBSARBPROC)gl_addr[WGLCREATECONTEXTATTRIBSARB].func) +#define wglCreatePbufferARB ((PFNWGLCREATEPBUFFERARBPROC)gl_addr[WGLCREATEPBUFFERARB].func) +#define wglDeleteBufferRegionARB ((PFNWGLDELETEBUFFERREGIONARBPROC)gl_addr[WGLDELETEBUFFERREGIONARB].func) +#define wglDestroyPbufferARB ((PFNWGLDESTROYPBUFFERARBPROC)gl_addr[WGLDESTROYPBUFFERARB].func) +#define wglDXCloseDeviceNV ((PFNWGLDXCLOSEDEVICENVPROC)gl_addr[WGLDXCLOSEDEVICENV].func) +#define wglDXLockObjectsNV ((PFNWGLDXLOCKOBJECTSNVPROC)gl_addr[WGLDXLOCKOBJECTSNV].func) +#define wglDXOpenDeviceNV ((PFNWGLDXOPENDEVICENVPROC)gl_addr[WGLDXOPENDEVICENV].func) +#define wglDXRegisterObjectNV ((PFNWGLDXREGISTEROBJECTNVPROC)gl_addr[WGLDXREGISTEROBJECTNV].func) +#define wglDXSetResourceShareHandleNV ((PFNWGLDXSETRESOURCESHAREHANDLENVPROC)gl_addr[WGLDXSETRESOURCESHAREHANDLENV].func) +#define wglDXUnlockObjectsNV ((PFNWGLDXUNLOCKOBJECTSNVPROC)gl_addr[WGLDXUNLOCKOBJECTSNV].func) +#define wglDXUnregisterObjectNV ((PFNWGLDXUNREGISTEROBJECTNVPROC)gl_addr[WGLDXUNREGISTEROBJECTNV].func) +#define wglFreeMemoryNV ((PFNWGLFREEMEMORYNVPROC)gl_addr[WGLFREEMEMORYNV].func) +#define wglGetCurrentContext ((PFNWGLGETCURRENTCONTEXTPROC)gl_addr[WGLGETCURRENTCONTEXT].func) +#define wglGetCurrentReadDCARB ((PFNWGLGETCURRENTREADDCARBPROC)gl_addr[WGLGETCURRENTREADDCARB].func) +#define wglGetExtensionsStringARB ((PFNWGLGETEXTENSIONSSTRINGARBPROC)gl_addr[WGLGETEXTENSIONSSTRINGARB].func) +#define wglGetExtensionsStringEXT ((PFNWGLGETEXTENSIONSSTRINGEXTPROC)gl_addr[WGLGETEXTENSIONSSTRINGEXT].func) +#define wglGetPbufferDCARB ((PFNWGLGETPBUFFERDCARBPROC)gl_addr[WGLGETPBUFFERDCARB].func) +#define wglGetPixelFormatAttribfvARB ((PFNWGLGETPIXELFORMATATTRIBFVARBPROC)gl_addr[WGLGETPIXELFORMATATTRIBFVARB].func) +#define wglGetPixelFormatAttribivARB ((PFNWGLGETPIXELFORMATATTRIBIVARBPROC)gl_addr[WGLGETPIXELFORMATATTRIBIVARB].func) +#define wglGetProcAddress ((PFNWGLGETPROCADDRESSPROC)gl_addr[WGLGETPROCADDRESS].func) +#define wglGetSwapIntervalEXT ((PFNWGLGETSWAPINTERVALEXTPROC)gl_addr[WGLGETSWAPINTERVALEXT].func) +#define wglGetVideoDeviceNV ((PFNWGLGETVIDEODEVICENVPROC)gl_addr[WGLGETVIDEODEVICENV].func) +#define wglGetVideoInfoNV ((PFNWGLGETVIDEOINFONVPROC)gl_addr[WGLGETVIDEOINFONV].func) +#define wglJoinSwapGroupNV ((PFNWGLJOINSWAPGROUPNVPROC)gl_addr[WGLJOINSWAPGROUPNV].func) +#define wglMakeContextCurrentARB ((PFNWGLMAKECONTEXTCURRENTARBPROC)gl_addr[WGLMAKECONTEXTCURRENTARB].func) +#define wglQueryFrameCountNV ((PFNWGLQUERYFRAMECOUNTNVPROC)gl_addr[WGLQUERYFRAMECOUNTNV].func) +#define wglQueryMaxSwapGroupsNV ((PFNWGLQUERYMAXSWAPGROUPSNVPROC)gl_addr[WGLQUERYMAXSWAPGROUPSNV].func) +#define wglQueryPbufferARB ((PFNWGLQUERYPBUFFERARBPROC)gl_addr[WGLQUERYPBUFFERARB].func) +#define wglQuerySwapGroupNV ((PFNWGLQUERYSWAPGROUPNVPROC)gl_addr[WGLQUERYSWAPGROUPNV].func) +#define wglReleasePbufferDCARB ((PFNWGLRELEASEPBUFFERDCARBPROC)gl_addr[WGLRELEASEPBUFFERDCARB].func) +#define wglReleaseTexImageARB ((PFNWGLRELEASETEXIMAGEARBPROC)gl_addr[WGLRELEASETEXIMAGEARB].func) +#define wglReleaseVideoDeviceNV ((PFNWGLRELEASEVIDEODEVICENVPROC)gl_addr[WGLRELEASEVIDEODEVICENV].func) +#define wglReleaseVideoImageNV ((PFNWGLRELEASEVIDEOIMAGENVPROC)gl_addr[WGLRELEASEVIDEOIMAGENV].func) +#define wglResetFrameCountNV ((PFNWGLRESETFRAMECOUNTNVPROC)gl_addr[WGLRESETFRAMECOUNTNV].func) +#define wglRestoreBufferRegionARB ((PFNWGLRESTOREBUFFERREGIONARBPROC)gl_addr[WGLRESTOREBUFFERREGIONARB].func) +#define wglSaveBufferRegionARB ((PFNWGLSAVEBUFFERREGIONARBPROC)gl_addr[WGLSAVEBUFFERREGIONARB].func) +#define wglSendPbufferToVideoNV ((PFNWGLSENDPBUFFERTOVIDEONVPROC)gl_addr[WGLSENDPBUFFERTOVIDEONV].func) +#define wglSetPbufferAttribARB ((PFNWGLSETPBUFFERATTRIBARBPROC)gl_addr[WGLSETPBUFFERATTRIBARB].func) +#define wglSwapIntervalEXT ((PFNWGLSWAPINTERVALEXTPROC)gl_addr[WGLSWAPINTERVALEXT].func) + +#define glFinishGLUT ((PFNGLFINISHGLUTPROC)gl_addr_glut[GLFINISHGLUT].func) +#define glViewportGLUT ((PFNGLVIEWPORTGLUTPROC)gl_addr_glut[GLVIEWPORTGLUT].func) +#define wglDeleteContextGLUT ((PFNWGLDELETECONTEXTGLUTPROC)gl_addr_glut[WGLDELETECONTEXTGLUT].func) +#define wglGetCurrentContextGLUT ((PFNWGLGETCURRENTCONTEXTGLUTPROC)gl_addr_glut[WGLGETCURRENTCONTEXTGLUT].func) +#define wglGetCurrentDCGLUT ((PFNWGLGETCURRENTDCGLUTPROC)gl_addr_glut[WGLGETCURRENTDCGLUT].func) +#define wglGetProcAddressGLUT ((PFNWGLGETPROCADDRESSGLUTPROC)gl_addr_glut[WGLGETPROCADDRESSGLUT].func) +#define wglMakeCurrentGLUT ((PFNWGLMAKECURRENTGLUTPROC)gl_addr_glut[WGLMAKECURRENTGLUT].func) + +extern bool GL_VERSION_3_3; +extern bool GL_VERSION_4_0; +extern bool GL_VERSION_4_1; +extern bool GL_VERSION_4_2; +extern bool GL_VERSION_4_3; +extern bool GL_VERSION_4_4; +extern bool GL_VERSION_4_5; +extern bool GL_VERSION_4_6; + +extern void wrap_patch(); + +extern void GLAPIENTRY glAlphaFuncDLL(GLenum func, GLfloat ref); +extern void GLAPIENTRY glBeginDLL(GLenum mode); +extern void GLAPIENTRY glBindTextureDLL(GLenum target, GLuint texture); +extern void GLAPIENTRY glClearDLL(GLbitfield mask); +extern void GLAPIENTRY glClearColorDLL(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +extern void GLAPIENTRY glClearDepthDLL(GLdouble depth); +extern void GLAPIENTRY glClearStencilDLL(GLint s); +extern void GLAPIENTRY glColor3fDLL(GLfloat red, GLfloat green, GLfloat blue); +extern void GLAPIENTRY glColor4fDLL(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +extern void GLAPIENTRY glColor4ubDLL(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha); +extern void GLAPIENTRY glColor4ubvDLL(GLubyte const * v); +extern void GLAPIENTRY glColorPointerDLL(GLint size, GLenum type, GLsizei stride, const void * pointer); +extern void GLAPIENTRY glCopyTexImage2DDLL(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); +extern void GLAPIENTRY glCopyTexSubImage2DDLL(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); +extern void GLAPIENTRY glCullFaceDLL(GLenum mode); +extern void GLAPIENTRY glDepthFuncDLL(GLenum func); +extern void GLAPIENTRY glDisableDLL(GLenum cap); +extern void GLAPIENTRY glDisableClientStateDLL(GLenum array); +extern void GLAPIENTRY glDrawArraysDLL(GLenum mode, GLint first, GLsizei count); +extern void GLAPIENTRY glDrawBufferDLL(GLenum buf); +extern void GLAPIENTRY glDrawElementsDLL(GLenum mode, GLsizei count, GLenum type, const void * indices); +extern void GLAPIENTRY glEnableDLL(GLenum cap); +extern void GLAPIENTRY glEnableClientStateDLL(GLenum array); +extern void GLAPIENTRY glEndDLL(); +extern void GLAPIENTRY glFogfDLL(GLenum pname, GLfloat param); +extern void GLAPIENTRY glFogfvDLL(GLenum pname, GLfloat const * params); +extern void GLAPIENTRY glFogiDLL(GLenum pname, GLint param); +extern void GLAPIENTRY glFrontFaceDLL(GLenum mode); +extern void GLAPIENTRY glFrustumDLL(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); +extern void GLAPIENTRY glGetBooleanvDLL(GLenum pname, GLboolean * data); +extern GLenum GLAPIENTRY glGetErrorDLL(); +extern void GLAPIENTRY glGetFloatvDLL(GLenum pname, GLfloat * data); +extern void GLAPIENTRY glGetIntegervDLL(GLenum pname, GLint * data); +extern void GLAPIENTRY glGetMaterialfvDLL(GLenum face, GLenum pname, GLfloat * params); +extern void GLAPIENTRY glGetTexImageDLL(GLenum target, GLint level, GLenum format, GLenum type, void * pixels); +extern void GLAPIENTRY glGetTexLevelParameterivDLL(GLenum target, GLint level, GLenum pname, GLint * params); +extern void GLAPIENTRY glGetTexParameterivDLL(GLenum target, GLenum pname, GLint * params); +extern GLboolean GLAPIENTRY glIsEnabledDLL(GLenum cap); +extern void GLAPIENTRY glLightfvDLL(GLenum light, GLenum pname, GLfloat const * params); +extern void GLAPIENTRY glLightModelfvDLL(GLenum pname, GLfloat const * params); +extern void GLAPIENTRY glLineWidthDLL(GLfloat width); +extern void GLAPIENTRY glLoadIdentityDLL(); +extern void GLAPIENTRY glLoadMatrixfDLL(GLfloat const * m); +extern void GLAPIENTRY glMaterialfDLL(GLenum face, GLenum pname, GLfloat param); +extern void GLAPIENTRY glMaterialfvDLL(GLenum face, GLenum pname, GLfloat const * params); +extern void GLAPIENTRY glMatrixModeDLL(GLenum mode); +extern void GLAPIENTRY glMultMatrixdDLL(GLdouble const * m); +extern void GLAPIENTRY glNormal3fDLL(GLfloat nx, GLfloat ny, GLfloat nz); +extern void GLAPIENTRY glNormalPointerDLL(GLenum type, GLsizei stride, const void * pointer); +extern void GLAPIENTRY glOrthoDLL(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); +extern void GLAPIENTRY glPixelStoreiDLL(GLenum pname, GLint param); +extern void GLAPIENTRY glPointSizeDLL(GLfloat size); +extern void GLAPIENTRY glPolygonModeDLL(GLenum face, GLenum mode); +extern void GLAPIENTRY glPopAttribDLL(); +extern void GLAPIENTRY glPopClientAttribDLL(); +extern void GLAPIENTRY glPopMatrixDLL(); +extern void GLAPIENTRY glPushAttribDLL(GLbitfield mask); +extern void GLAPIENTRY glPushClientAttribDLL(GLbitfield mask); +extern void GLAPIENTRY glPushMatrixDLL(); +extern void GLAPIENTRY glReadBufferDLL(GLenum src); +extern void GLAPIENTRY glReadPixelsDLL(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void * pixels); +extern void GLAPIENTRY glRotatefDLL(GLfloat angle, GLfloat x, GLfloat y, GLfloat z); +extern void GLAPIENTRY glScalefDLL(GLfloat x, GLfloat y, GLfloat z); +extern void GLAPIENTRY glShadeModelDLL(GLenum mode); +extern void GLAPIENTRY glTexCoord2fDLL(GLfloat s, GLfloat t); +extern void GLAPIENTRY glTexCoordPointerDLL(GLint size, GLenum type, GLsizei stride, const void * pointer); +extern void GLAPIENTRY glTexEnvfDLL(GLenum target, GLenum pname, GLfloat param); +extern void GLAPIENTRY glTexEnviDLL(GLenum target, GLenum pname, GLint param); +extern void GLAPIENTRY glTexImage1DDLL(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void * pixels); +extern void GLAPIENTRY glTexImage2DDLL(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void * pixels); +extern void GLAPIENTRY glTexParameterfDLL(GLenum target, GLenum pname, GLfloat param); +extern void GLAPIENTRY glTexParameterfvDLL(GLenum target, GLenum pname, GLfloat const * params); +extern void GLAPIENTRY glTexParameteriDLL(GLenum target, GLenum pname, GLint param); +extern void GLAPIENTRY glTexSubImage2DDLL(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void * pixels); +extern void GLAPIENTRY glTranslatefDLL(GLfloat x, GLfloat y, GLfloat z); +extern void GLAPIENTRY glVertex3fDLL(GLfloat x, GLfloat y, GLfloat z); +extern void GLAPIENTRY glVertex3fvDLL(GLfloat const * v); +extern void GLAPIENTRY glVertexPointerDLL(GLint size, GLenum type, GLsizei stride, const void * pointer); +extern void GLAPIENTRY glActiveTexture(GLenum texture); +extern void GLAPIENTRY glBindBufferARB(GLenum target, GLuint buffer); +extern void GLAPIENTRY glBindBufferBaseNV(GLenum target, GLuint index, GLuint buffer); +extern void GLAPIENTRY glBindFramebufferEXT(GLenum target, GLuint framebuffer); +extern void GLAPIENTRY glBindMultiTextureEXT(GLenum texunit, GLenum target, GLuint texture); +extern void GLAPIENTRY glBindRenderbufferEXT(GLenum target, GLuint renderbuffer); +extern void GLAPIENTRY glBufferDataARB(GLenum target, GLsizeiptrARB size, const void * data, GLenum usage); +extern void GLAPIENTRY glClampColorARB(GLenum target, GLenum clamp); +extern void GLAPIENTRY glClientActiveTexture(GLenum texture); +extern void GLAPIENTRY glCopyMultiTexSubImage2DEXT(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); +extern void GLAPIENTRY glDeleteBuffersARB(GLsizei n, GLuint const * buffers); +extern void GLAPIENTRY glDeleteFramebuffersEXT(GLsizei n, GLuint const * framebuffers); +extern void GLAPIENTRY glDeleteRenderbuffersEXT(GLsizei n, GLuint const * renderbuffers); +extern void GLAPIENTRY glDeleteTextures(GLsizei n, GLuint const * textures); +extern void GLAPIENTRY glDisableVertexAttribArrayARB(GLuint index); +extern void GLAPIENTRY glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void * indices); +extern void GLAPIENTRY glEnableVertexAttribArray(GLuint index); +extern void GLAPIENTRY glEnableVertexAttribArrayARB(GLuint index); +extern void GLAPIENTRY glFramebufferRenderbufferEXT(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer); +extern void GLAPIENTRY glFramebufferTexture2DEXT(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +extern void GLAPIENTRY glGenFramebuffersEXT(GLsizei n, GLuint * framebuffers); +extern void GLAPIENTRY glGenRenderbuffersEXT(GLsizei n, GLuint * renderbuffers); +extern void GLAPIENTRY glGenTextures(GLsizei n, GLuint * textures); +extern void GLAPIENTRY glGetProgramEnvParameterfvARB(GLenum target, GLuint index, GLfloat * params); +extern void GLAPIENTRY glGetProgramivARB(GLenum target, GLenum pname, GLint * params); +extern void GLAPIENTRY glGetTextureImageEXT(GLuint texture, GLenum target, GLint level, GLenum format, GLenum type, void * pixels); +extern GLboolean GLAPIENTRY glIsBufferARB(GLuint buffer); +extern void GLAPIENTRY glLoadTransposeMatrixf(GLfloat const * m); +extern void * GLAPIENTRY glMapNamedBufferEXT(GLuint buffer, GLenum access); +extern void GLAPIENTRY glMultiTexCoord2f(GLenum target, GLfloat s, GLfloat t); +extern void GLAPIENTRY glMultiTexCoord2fv(GLenum target, GLfloat const * v); +extern void GLAPIENTRY glMultTransposeMatrixf(GLfloat const * m); +extern void GLAPIENTRY glNamedBufferDataEXT(GLuint buffer, GLsizeiptr size, const void * data, GLenum usage); +extern void GLAPIENTRY glNamedBufferSubDataEXT(GLuint buffer, GLintptr offset, GLsizeiptr size, const void * data); +extern void GLAPIENTRY glPointParameterf(GLenum pname, GLfloat param); +extern void GLAPIENTRY glPointParameterfv(GLenum pname, GLfloat const * params); +extern void GLAPIENTRY glPointParameteri(GLenum pname, GLint param); +extern void GLAPIENTRY glPrimitiveRestartIndexNV(GLuint index); +extern void GLAPIENTRY glProgramBufferParametersfvNV(GLenum target, GLuint bindingIndex, GLuint wordIndex, GLsizei count, GLfloat const * params); +extern void GLAPIENTRY glProgramEnvParameter4fARB(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +extern void GLAPIENTRY glProgramEnvParameter4fvARB(GLenum target, GLuint index, GLfloat const * params); +extern void GLAPIENTRY glProgramEnvParameters4fvEXT(GLenum target, GLuint index, GLsizei count, GLfloat const * params); +extern void GLAPIENTRY glProgramLocalParameter4fARB(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +extern void GLAPIENTRY glProgramLocalParameter4fvARB(GLenum target, GLuint index, GLfloat const * params); +extern void GLAPIENTRY glProgramLocalParameters4fvEXT(GLenum target, GLuint index, GLsizei count, GLfloat const * params); +extern void GLAPIENTRY glRenderbufferStorageEXT(GLenum target, GLenum internalformat, GLsizei width, GLsizei height); +extern void GLAPIENTRY glRenderbufferStorageMultisampleCoverageNV(GLenum target, GLsizei coverageSamples, GLsizei colorSamples, GLenum internalformat, GLsizei width, GLsizei height); +extern GLboolean GLAPIENTRY glUnmapNamedBufferEXT(GLuint buffer); +extern void GLAPIENTRY glUseProgram(GLuint program); +extern void GLAPIENTRY glVertexAttribPointerARB(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void * pointer); +extern void GLAPIENTRY glBeginGLUT(GLenum mode); +extern void GLAPIENTRY glBitmapGLUT(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, GLubyte const * bitmap); +extern void GLAPIENTRY glDrawBufferGLUT(GLenum buf); +extern void GLAPIENTRY glEnableGLUT(GLenum cap); +extern void GLAPIENTRY glEndGLUT(); +extern void GLAPIENTRY glEvalMesh2GLUT(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2); +extern GLenum GLAPIENTRY glGetErrorGLUT(); +extern void GLAPIENTRY glGetIntegervGLUT(GLenum pname, GLint * data); +extern GLubyte const * GLAPIENTRY glGetStringGLUT(GLenum name); +extern void GLAPIENTRY glMap2fGLUT(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, GLfloat const * points); +extern void GLAPIENTRY glMapGrid2fGLUT(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2); +extern void GLAPIENTRY glNormal3fGLUT(GLfloat nx, GLfloat ny, GLfloat nz); +extern void GLAPIENTRY glNormal3fvGLUT(GLfloat const * v); +extern void GLAPIENTRY glPixelStoreiGLUT(GLenum pname, GLint param); +extern void GLAPIENTRY glPolygonModeGLUT(GLenum face, GLenum mode); +extern void GLAPIENTRY glPopAttribGLUT(); +extern void GLAPIENTRY glPopMatrixGLUT(); +extern void GLAPIENTRY glPushAttribGLUT(GLbitfield mask); +extern void GLAPIENTRY glPushMatrixGLUT(); +extern void GLAPIENTRY glReadBufferGLUT(GLenum src); +extern void GLAPIENTRY glRotatefGLUT(GLfloat angle, GLfloat x, GLfloat y, GLfloat z); +extern void GLAPIENTRY glScalefGLUT(GLfloat x, GLfloat y, GLfloat z); +extern void GLAPIENTRY glTranslatefGLUT(GLfloat x, GLfloat y, GLfloat z); +extern void GLAPIENTRY glVertex2fGLUT(GLfloat x, GLfloat y); +extern void GLAPIENTRY glVertex3fGLUT(GLfloat x, GLfloat y, GLfloat z); +extern void GLAPIENTRY glVertex3fvGLUT(GLfloat const * v); +extern HGLRC GLAPIENTRY wglCreateContextGLUT(HDC hDc); + +extern void GLAPIENTRY glTexParameteriv(GLenum target, GLenum pname, const GLint* params); +extern void GLAPIENTRY glStencilMask(GLuint mask); +extern void GLAPIENTRY glPrimitiveRestartIndex(GLuint index); +extern void GLAPIENTRY glClearDepthf(GLfloat d); +extern void GLAPIENTRY glGetProgramBinary(GLuint program, GLsizei bufSize, GLsizei* length, GLenum* binaryFormat, void* binary); +extern void GLAPIENTRY glProgramBinary(GLuint program, GLenum binaryFormat, const void* binary, GLsizei length); +extern void GLAPIENTRY glBufferStorage(GLenum target, GLsizeiptr size, const void* data, GLbitfield flags); +extern void GLAPIENTRY glCreateBuffers(GLsizei n, GLuint* buffers); +extern void GLAPIENTRY glNamedBufferStorage(GLuint buffer, GLsizeiptr size, const void* data, GLbitfield flags); +extern void GLAPIENTRY glNamedBufferSubData(GLuint buffer, GLintptr offset, GLsizeiptr size, const void* data); +extern void* GLAPIENTRY glMapNamedBuffer(GLuint buffer, GLenum access); +extern GLboolean GLAPIENTRY glUnmapNamedBuffer(GLuint buffer); +extern void GLAPIENTRY glTextureSubImage2D(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* pixels); + +#if DEBUG +extern constexpr void GLAPIENTRY glPushDebugGroup(GLenum source, GLuint id, GLsizei length, const GLchar* message); +extern constexpr void GLAPIENTRY glPopDebugGroup(); +#endif diff --git a/thirdparty.txt b/thirdparty.txt new file mode 100644 index 0000000..e7eb4cb --- /dev/null +++ b/thirdparty.txt @@ -0,0 +1,52 @@ +SigScan.hpp combined from DivaModLoader's Source/DivaModLoader/SigScan.h and Source/DivaModLoader/SigScan.cpp +Dependencies/Helpers.h from DivaModLoader + +# MIT License + +Copyright (c) 2022 Skyth + +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. + +------------------------------------------------------------------------------- + +Detours + +# Copyright (c) Microsoft Corporation + +All rights reserved. + +# MIT License + +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.