diff --git a/lib/KHR/khrplatform.h b/lib/KHR/khrplatform.h new file mode 100644 index 000000000..01646449c --- /dev/null +++ b/lib/KHR/khrplatform.h @@ -0,0 +1,311 @@ +#ifndef __khrplatform_h_ +#define __khrplatform_h_ + +/* +** Copyright (c) 2008-2018 The Khronos Group Inc. +** +** Permission is hereby granted, free of charge, to any person obtaining a +** copy of this software and/or associated documentation files (the +** "Materials"), to deal in the Materials without restriction, including +** without limitation the rights to use, copy, modify, merge, publish, +** distribute, sublicense, and/or sell copies of the Materials, and to +** permit persons to whom the Materials are furnished to do so, subject to +** the following conditions: +** +** The above copyright notice and this permission notice shall be included +** in all copies or substantial portions of the Materials. +** +** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS. +*/ + +/* Khronos platform-specific types and definitions. + * + * The master copy of khrplatform.h is maintained in the Khronos EGL + * Registry repository at https://github.com/KhronosGroup/EGL-Registry + * The last semantic modification to khrplatform.h was at commit ID: + * 67a3e0864c2d75ea5287b9f3d2eb74a745936692 + * + * Adopters may modify this file to suit their platform. Adopters are + * encouraged to submit platform specific modifications to the Khronos + * group so that they can be included in future versions of this file. + * Please submit changes by filing pull requests or issues on + * the EGL Registry repository linked above. + * + * + * See the Implementer's Guidelines for information about where this file + * should be located on your system and for more details of its use: + * http://www.khronos.org/registry/implementers_guide.pdf + * + * This file should be included as + * #include + * by Khronos client API header files that use its types and defines. + * + * The types in khrplatform.h should only be used to define API-specific types. + * + * Types defined in khrplatform.h: + * khronos_int8_t signed 8 bit + * khronos_uint8_t unsigned 8 bit + * khronos_int16_t signed 16 bit + * khronos_uint16_t unsigned 16 bit + * khronos_int32_t signed 32 bit + * khronos_uint32_t unsigned 32 bit + * khronos_int64_t signed 64 bit + * khronos_uint64_t unsigned 64 bit + * khronos_intptr_t signed same number of bits as a pointer + * khronos_uintptr_t unsigned same number of bits as a pointer + * khronos_ssize_t signed size + * khronos_usize_t unsigned size + * khronos_float_t signed 32 bit floating point + * khronos_time_ns_t unsigned 64 bit time in nanoseconds + * khronos_utime_nanoseconds_t unsigned time interval or absolute time in + * nanoseconds + * khronos_stime_nanoseconds_t signed time interval in nanoseconds + * khronos_boolean_enum_t enumerated boolean type. This should + * only be used as a base type when a client API's boolean type is + * an enum. Client APIs which use an integer or other type for + * booleans cannot use this as the base type for their boolean. + * + * Tokens defined in khrplatform.h: + * + * KHRONOS_FALSE, KHRONOS_TRUE Enumerated boolean false/true values. + * + * KHRONOS_SUPPORT_INT64 is 1 if 64 bit integers are supported; otherwise 0. + * KHRONOS_SUPPORT_FLOAT is 1 if floats are supported; otherwise 0. + * + * Calling convention macros defined in this file: + * KHRONOS_APICALL + * KHRONOS_APIENTRY + * KHRONOS_APIATTRIBUTES + * + * These may be used in function prototypes as: + * + * KHRONOS_APICALL void KHRONOS_APIENTRY funcname( + * int arg1, + * int arg2) KHRONOS_APIATTRIBUTES; + */ + +#if defined(__SCITECH_SNAP__) && !defined(KHRONOS_STATIC) +# define KHRONOS_STATIC 1 +#endif + +/*------------------------------------------------------------------------- + * Definition of KHRONOS_APICALL + *------------------------------------------------------------------------- + * This precedes the return type of the function in the function prototype. + */ +#if defined(KHRONOS_STATIC) + /* If the preprocessor constant KHRONOS_STATIC is defined, make the + * header compatible with static linking. */ +# define KHRONOS_APICALL +#elif defined(_WIN32) +# define KHRONOS_APICALL __declspec(dllimport) +#elif defined (__SYMBIAN32__) +# define KHRONOS_APICALL IMPORT_C +#elif defined(__ANDROID__) +# define KHRONOS_APICALL __attribute__((visibility("default"))) +#else +# define KHRONOS_APICALL +#endif + +/*------------------------------------------------------------------------- + * Definition of KHRONOS_APIENTRY + *------------------------------------------------------------------------- + * This follows the return type of the function and precedes the function + * name in the function prototype. + */ +#if defined(_WIN32) && !defined(_WIN32_WCE) && !defined(__SCITECH_SNAP__) + /* Win32 but not WinCE */ +# define KHRONOS_APIENTRY __stdcall +#else +# define KHRONOS_APIENTRY +#endif + +/*------------------------------------------------------------------------- + * Definition of KHRONOS_APIATTRIBUTES + *------------------------------------------------------------------------- + * This follows the closing parenthesis of the function prototype arguments. + */ +#if defined (__ARMCC_2__) +#define KHRONOS_APIATTRIBUTES __softfp +#else +#define KHRONOS_APIATTRIBUTES +#endif + +/*------------------------------------------------------------------------- + * basic type definitions + *-----------------------------------------------------------------------*/ +#if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) || defined(__GNUC__) || defined(__SCO__) || defined(__USLC__) + + +/* + * Using + */ +#include +typedef int32_t khronos_int32_t; +typedef uint32_t khronos_uint32_t; +typedef int64_t khronos_int64_t; +typedef uint64_t khronos_uint64_t; +#define KHRONOS_SUPPORT_INT64 1 +#define KHRONOS_SUPPORT_FLOAT 1 +/* + * To support platform where unsigned long cannot be used interchangeably with + * inptr_t (e.g. CHERI-extended ISAs), we can use the stdint.h intptr_t. + * Ideally, we could just use (u)intptr_t everywhere, but this could result in + * ABI breakage if khronos_uintptr_t is changed from unsigned long to + * unsigned long long or similar (this results in different C++ name mangling). + * To avoid changes for existing platforms, we restrict usage of intptr_t to + * platforms where the size of a pointer is larger than the size of long. + */ +#if defined(__SIZEOF_LONG__) && defined(__SIZEOF_POINTER__) +#if __SIZEOF_POINTER__ > __SIZEOF_LONG__ +#define KHRONOS_USE_INTPTR_T +#endif +#endif + +#elif defined(__VMS ) || defined(__sgi) + +/* + * Using + */ +#include +typedef int32_t khronos_int32_t; +typedef uint32_t khronos_uint32_t; +typedef int64_t khronos_int64_t; +typedef uint64_t khronos_uint64_t; +#define KHRONOS_SUPPORT_INT64 1 +#define KHRONOS_SUPPORT_FLOAT 1 + +#elif defined(_WIN32) && !defined(__SCITECH_SNAP__) + +/* + * Win32 + */ +typedef __int32 khronos_int32_t; +typedef unsigned __int32 khronos_uint32_t; +typedef __int64 khronos_int64_t; +typedef unsigned __int64 khronos_uint64_t; +#define KHRONOS_SUPPORT_INT64 1 +#define KHRONOS_SUPPORT_FLOAT 1 + +#elif defined(__sun__) || defined(__digital__) + +/* + * Sun or Digital + */ +typedef int khronos_int32_t; +typedef unsigned int khronos_uint32_t; +#if defined(__arch64__) || defined(_LP64) +typedef long int khronos_int64_t; +typedef unsigned long int khronos_uint64_t; +#else +typedef long long int khronos_int64_t; +typedef unsigned long long int khronos_uint64_t; +#endif /* __arch64__ */ +#define KHRONOS_SUPPORT_INT64 1 +#define KHRONOS_SUPPORT_FLOAT 1 + +#elif 0 + +/* + * Hypothetical platform with no float or int64 support + */ +typedef int khronos_int32_t; +typedef unsigned int khronos_uint32_t; +#define KHRONOS_SUPPORT_INT64 0 +#define KHRONOS_SUPPORT_FLOAT 0 + +#else + +/* + * Generic fallback + */ +#include +typedef int32_t khronos_int32_t; +typedef uint32_t khronos_uint32_t; +typedef int64_t khronos_int64_t; +typedef uint64_t khronos_uint64_t; +#define KHRONOS_SUPPORT_INT64 1 +#define KHRONOS_SUPPORT_FLOAT 1 + +#endif + + +/* + * Types that are (so far) the same on all platforms + */ +typedef signed char khronos_int8_t; +typedef unsigned char khronos_uint8_t; +typedef signed short int khronos_int16_t; +typedef unsigned short int khronos_uint16_t; + +/* + * Types that differ between LLP64 and LP64 architectures - in LLP64, + * pointers are 64 bits, but 'long' is still 32 bits. Win64 appears + * to be the only LLP64 architecture in current use. + */ +#ifdef KHRONOS_USE_INTPTR_T +typedef intptr_t khronos_intptr_t; +typedef uintptr_t khronos_uintptr_t; +#elif defined(_WIN64) +typedef signed long long int khronos_intptr_t; +typedef unsigned long long int khronos_uintptr_t; +#else +typedef signed long int khronos_intptr_t; +typedef unsigned long int khronos_uintptr_t; +#endif + +#if defined(_WIN64) +typedef signed long long int khronos_ssize_t; +typedef unsigned long long int khronos_usize_t; +#else +typedef signed long int khronos_ssize_t; +typedef unsigned long int khronos_usize_t; +#endif + +#if KHRONOS_SUPPORT_FLOAT +/* + * Float type + */ +typedef float khronos_float_t; +#endif + +#if KHRONOS_SUPPORT_INT64 +/* Time types + * + * These types can be used to represent a time interval in nanoseconds or + * an absolute Unadjusted System Time. Unadjusted System Time is the number + * of nanoseconds since some arbitrary system event (e.g. since the last + * time the system booted). The Unadjusted System Time is an unsigned + * 64 bit value that wraps back to 0 every 584 years. Time intervals + * may be either signed or unsigned. + */ +typedef khronos_uint64_t khronos_utime_nanoseconds_t; +typedef khronos_int64_t khronos_stime_nanoseconds_t; +#endif + +/* + * Dummy value used to pad enum types to 32 bits. + */ +#ifndef KHRONOS_MAX_ENUM +#define KHRONOS_MAX_ENUM 0x7FFFFFFF +#endif + +/* + * Enumerated boolean type + * + * Values other than zero should be considered to be true. Therefore + * comparisons should not be made against KHRONOS_TRUE. + */ +typedef enum { + KHRONOS_FALSE = 0, + KHRONOS_TRUE = 1, + KHRONOS_BOOLEAN_ENUM_FORCE_SIZE = KHRONOS_MAX_ENUM +} khronos_boolean_enum_t; + +#endif /* __khrplatform_h_ */ diff --git a/lib/application.h b/lib/application.h index 7dcc45ad1..d0ddfcef6 100644 --- a/lib/application.h +++ b/lib/application.h @@ -98,6 +98,10 @@ class oeApplication { virtual void delay(float secs) = 0; // set a function to run when deferring to OS. virtual void set_defer_handler(void (*func)(bool)) = 0; + // changes the flags and applies changes to the window. + virtual void set_flags(int newflags) = 0; + // moves the window + virtual void set_sizepos(int x, int y, int w, int h) = 0; public: // checks if the application is active diff --git a/lib/glad/gl.h b/lib/glad/gl.h new file mode 100644 index 000000000..72cc6c929 --- /dev/null +++ b/lib/glad/gl.h @@ -0,0 +1,2210 @@ +/** + * Loader generated by glad 2.0.6 on Fri May 24 04:53:45 2024 + * + * SPDX-License-Identifier: (WTFPL OR CC0-1.0) AND Apache-2.0 + * + * Generator: C/C++ + * Specification: gl + * Extensions: 1 + * + * APIs: + * - gl:core=3.3 + * + * Options: + * - ALIAS = False + * - DEBUG = False + * - HEADER_ONLY = False + * - LOADER = False + * - MX = False + * - ON_DEMAND = False + * + * Commandline: + * --api='gl:core=3.3' --extensions='GL_KHR_debug' c + * + * Online: + * http://glad.sh/#api=gl%3Acore%3D3.3&extensions=GL_KHR_debug&generator=c&options= + * + */ + +#ifndef GLAD_GL_H_ +#define GLAD_GL_H_ + +#ifdef __clang__ +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wreserved-id-macro" +#endif +#ifdef __gl_h_ + #error OpenGL (gl.h) header already included (API: gl), remove previous include! +#endif +#define __gl_h_ 1 +#ifdef __gl3_h_ + #error OpenGL (gl3.h) header already included (API: gl), remove previous include! +#endif +#define __gl3_h_ 1 +#ifdef __glext_h_ + #error OpenGL (glext.h) header already included (API: gl), remove previous include! +#endif +#define __glext_h_ 1 +#ifdef __gl3ext_h_ + #error OpenGL (gl3ext.h) header already included (API: gl), remove previous include! +#endif +#define __gl3ext_h_ 1 +#ifdef __clang__ +#pragma clang diagnostic pop +#endif + +#define GLAD_GL + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef GLAD_PLATFORM_H_ +#define GLAD_PLATFORM_H_ + +#ifndef GLAD_PLATFORM_WIN32 + #if defined(_WIN32) || defined(__WIN32__) || defined(WIN32) || defined(__MINGW32__) + #define GLAD_PLATFORM_WIN32 1 + #else + #define GLAD_PLATFORM_WIN32 0 + #endif +#endif + +#ifndef GLAD_PLATFORM_APPLE + #ifdef __APPLE__ + #define GLAD_PLATFORM_APPLE 1 + #else + #define GLAD_PLATFORM_APPLE 0 + #endif +#endif + +#ifndef GLAD_PLATFORM_EMSCRIPTEN + #ifdef __EMSCRIPTEN__ + #define GLAD_PLATFORM_EMSCRIPTEN 1 + #else + #define GLAD_PLATFORM_EMSCRIPTEN 0 + #endif +#endif + +#ifndef GLAD_PLATFORM_UWP + #if defined(_MSC_VER) && !defined(GLAD_INTERNAL_HAVE_WINAPIFAMILY) + #ifdef __has_include + #if __has_include() + #define GLAD_INTERNAL_HAVE_WINAPIFAMILY 1 + #endif + #elif _MSC_VER >= 1700 && !_USING_V110_SDK71_ + #define GLAD_INTERNAL_HAVE_WINAPIFAMILY 1 + #endif + #endif + + #ifdef GLAD_INTERNAL_HAVE_WINAPIFAMILY + #include + #if !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) && WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) + #define GLAD_PLATFORM_UWP 1 + #endif + #endif + + #ifndef GLAD_PLATFORM_UWP + #define GLAD_PLATFORM_UWP 0 + #endif +#endif + +#ifdef __GNUC__ + #define GLAD_GNUC_EXTENSION __extension__ +#else + #define GLAD_GNUC_EXTENSION +#endif + +#define GLAD_UNUSED(x) (void)(x) + +#ifndef GLAD_API_CALL + #if defined(GLAD_API_CALL_EXPORT) + #if GLAD_PLATFORM_WIN32 || defined(__CYGWIN__) + #if defined(GLAD_API_CALL_EXPORT_BUILD) + #if defined(__GNUC__) + #define GLAD_API_CALL __attribute__ ((dllexport)) extern + #else + #define GLAD_API_CALL __declspec(dllexport) extern + #endif + #else + #if defined(__GNUC__) + #define GLAD_API_CALL __attribute__ ((dllimport)) extern + #else + #define GLAD_API_CALL __declspec(dllimport) extern + #endif + #endif + #elif defined(__GNUC__) && defined(GLAD_API_CALL_EXPORT_BUILD) + #define GLAD_API_CALL __attribute__ ((visibility ("default"))) extern + #else + #define GLAD_API_CALL extern + #endif + #else + #define GLAD_API_CALL extern + #endif +#endif + +#ifdef APIENTRY + #define GLAD_API_PTR APIENTRY +#elif GLAD_PLATFORM_WIN32 + #define GLAD_API_PTR __stdcall +#else + #define GLAD_API_PTR +#endif + +#ifndef GLAPI +#define GLAPI GLAD_API_CALL +#endif + +#ifndef GLAPIENTRY +#define GLAPIENTRY GLAD_API_PTR +#endif + +#define GLAD_MAKE_VERSION(major, minor) (major * 10000 + minor) +#define GLAD_VERSION_MAJOR(version) (version / 10000) +#define GLAD_VERSION_MINOR(version) (version % 10000) + +#define GLAD_GENERATOR_VERSION "2.0.6" + +typedef void (*GLADapiproc)(void); + +typedef GLADapiproc (*GLADloadfunc)(const char *name); +typedef GLADapiproc (*GLADuserptrloadfunc)(void *userptr, const char *name); + +typedef void (*GLADprecallback)(const char *name, GLADapiproc apiproc, int len_args, ...); +typedef void (*GLADpostcallback)(void *ret, const char *name, GLADapiproc apiproc, int len_args, ...); + +#endif /* GLAD_PLATFORM_H_ */ + +#define GL_ACTIVE_ATTRIBUTES 0x8B89 +#define GL_ACTIVE_ATTRIBUTE_MAX_LENGTH 0x8B8A +#define GL_ACTIVE_TEXTURE 0x84E0 +#define GL_ACTIVE_UNIFORMS 0x8B86 +#define GL_ACTIVE_UNIFORM_BLOCKS 0x8A36 +#define GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH 0x8A35 +#define GL_ACTIVE_UNIFORM_MAX_LENGTH 0x8B87 +#define GL_ALIASED_LINE_WIDTH_RANGE 0x846E +#define GL_ALPHA 0x1906 +#define GL_ALREADY_SIGNALED 0x911A +#define GL_ALWAYS 0x0207 +#define GL_AND 0x1501 +#define GL_AND_INVERTED 0x1504 +#define GL_AND_REVERSE 0x1502 +#define GL_ANY_SAMPLES_PASSED 0x8C2F +#define GL_ARRAY_BUFFER 0x8892 +#define GL_ARRAY_BUFFER_BINDING 0x8894 +#define GL_ATTACHED_SHADERS 0x8B85 +#define GL_BACK 0x0405 +#define GL_BACK_LEFT 0x0402 +#define GL_BACK_RIGHT 0x0403 +#define GL_BGR 0x80E0 +#define GL_BGRA 0x80E1 +#define GL_BGRA_INTEGER 0x8D9B +#define GL_BGR_INTEGER 0x8D9A +#define GL_BLEND 0x0BE2 +#define GL_BLEND_COLOR 0x8005 +#define GL_BLEND_DST 0x0BE0 +#define GL_BLEND_DST_ALPHA 0x80CA +#define GL_BLEND_DST_RGB 0x80C8 +#define GL_BLEND_EQUATION 0x8009 +#define GL_BLEND_EQUATION_ALPHA 0x883D +#define GL_BLEND_EQUATION_RGB 0x8009 +#define GL_BLEND_SRC 0x0BE1 +#define GL_BLEND_SRC_ALPHA 0x80CB +#define GL_BLEND_SRC_RGB 0x80C9 +#define GL_BLUE 0x1905 +#define GL_BLUE_INTEGER 0x8D96 +#define GL_BOOL 0x8B56 +#define GL_BOOL_VEC2 0x8B57 +#define GL_BOOL_VEC3 0x8B58 +#define GL_BOOL_VEC4 0x8B59 +#define GL_BUFFER 0x82E0 +#define GL_BUFFER_ACCESS 0x88BB +#define GL_BUFFER_ACCESS_FLAGS 0x911F +#define GL_BUFFER_MAPPED 0x88BC +#define GL_BUFFER_MAP_LENGTH 0x9120 +#define GL_BUFFER_MAP_OFFSET 0x9121 +#define GL_BUFFER_MAP_POINTER 0x88BD +#define GL_BUFFER_SIZE 0x8764 +#define GL_BUFFER_USAGE 0x8765 +#define GL_BYTE 0x1400 +#define GL_CCW 0x0901 +#define GL_CLAMP_READ_COLOR 0x891C +#define GL_CLAMP_TO_BORDER 0x812D +#define GL_CLAMP_TO_EDGE 0x812F +#define GL_CLEAR 0x1500 +#define GL_CLIP_DISTANCE0 0x3000 +#define GL_CLIP_DISTANCE1 0x3001 +#define GL_CLIP_DISTANCE2 0x3002 +#define GL_CLIP_DISTANCE3 0x3003 +#define GL_CLIP_DISTANCE4 0x3004 +#define GL_CLIP_DISTANCE5 0x3005 +#define GL_CLIP_DISTANCE6 0x3006 +#define GL_CLIP_DISTANCE7 0x3007 +#define GL_COLOR 0x1800 +#define GL_COLOR_ATTACHMENT0 0x8CE0 +#define GL_COLOR_ATTACHMENT1 0x8CE1 +#define GL_COLOR_ATTACHMENT10 0x8CEA +#define GL_COLOR_ATTACHMENT11 0x8CEB +#define GL_COLOR_ATTACHMENT12 0x8CEC +#define GL_COLOR_ATTACHMENT13 0x8CED +#define GL_COLOR_ATTACHMENT14 0x8CEE +#define GL_COLOR_ATTACHMENT15 0x8CEF +#define GL_COLOR_ATTACHMENT16 0x8CF0 +#define GL_COLOR_ATTACHMENT17 0x8CF1 +#define GL_COLOR_ATTACHMENT18 0x8CF2 +#define GL_COLOR_ATTACHMENT19 0x8CF3 +#define GL_COLOR_ATTACHMENT2 0x8CE2 +#define GL_COLOR_ATTACHMENT20 0x8CF4 +#define GL_COLOR_ATTACHMENT21 0x8CF5 +#define GL_COLOR_ATTACHMENT22 0x8CF6 +#define GL_COLOR_ATTACHMENT23 0x8CF7 +#define GL_COLOR_ATTACHMENT24 0x8CF8 +#define GL_COLOR_ATTACHMENT25 0x8CF9 +#define GL_COLOR_ATTACHMENT26 0x8CFA +#define GL_COLOR_ATTACHMENT27 0x8CFB +#define GL_COLOR_ATTACHMENT28 0x8CFC +#define GL_COLOR_ATTACHMENT29 0x8CFD +#define GL_COLOR_ATTACHMENT3 0x8CE3 +#define GL_COLOR_ATTACHMENT30 0x8CFE +#define GL_COLOR_ATTACHMENT31 0x8CFF +#define GL_COLOR_ATTACHMENT4 0x8CE4 +#define GL_COLOR_ATTACHMENT5 0x8CE5 +#define GL_COLOR_ATTACHMENT6 0x8CE6 +#define GL_COLOR_ATTACHMENT7 0x8CE7 +#define GL_COLOR_ATTACHMENT8 0x8CE8 +#define GL_COLOR_ATTACHMENT9 0x8CE9 +#define GL_COLOR_BUFFER_BIT 0x00004000 +#define GL_COLOR_CLEAR_VALUE 0x0C22 +#define GL_COLOR_LOGIC_OP 0x0BF2 +#define GL_COLOR_WRITEMASK 0x0C23 +#define GL_COMPARE_REF_TO_TEXTURE 0x884E +#define GL_COMPILE_STATUS 0x8B81 +#define GL_COMPRESSED_RED 0x8225 +#define GL_COMPRESSED_RED_RGTC1 0x8DBB +#define GL_COMPRESSED_RG 0x8226 +#define GL_COMPRESSED_RGB 0x84ED +#define GL_COMPRESSED_RGBA 0x84EE +#define GL_COMPRESSED_RG_RGTC2 0x8DBD +#define GL_COMPRESSED_SIGNED_RED_RGTC1 0x8DBC +#define GL_COMPRESSED_SIGNED_RG_RGTC2 0x8DBE +#define GL_COMPRESSED_SRGB 0x8C48 +#define GL_COMPRESSED_SRGB_ALPHA 0x8C49 +#define GL_COMPRESSED_TEXTURE_FORMATS 0x86A3 +#define GL_CONDITION_SATISFIED 0x911C +#define GL_CONSTANT_ALPHA 0x8003 +#define GL_CONSTANT_COLOR 0x8001 +#define GL_CONTEXT_COMPATIBILITY_PROFILE_BIT 0x00000002 +#define GL_CONTEXT_CORE_PROFILE_BIT 0x00000001 +#define GL_CONTEXT_FLAGS 0x821E +#define GL_CONTEXT_FLAG_DEBUG_BIT 0x00000002 +#define GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT 0x00000001 +#define GL_CONTEXT_PROFILE_MASK 0x9126 +#define GL_COPY 0x1503 +#define GL_COPY_INVERTED 0x150C +#define GL_COPY_READ_BUFFER 0x8F36 +#define GL_COPY_WRITE_BUFFER 0x8F37 +#define GL_CULL_FACE 0x0B44 +#define GL_CULL_FACE_MODE 0x0B45 +#define GL_CURRENT_PROGRAM 0x8B8D +#define GL_CURRENT_QUERY 0x8865 +#define GL_CURRENT_VERTEX_ATTRIB 0x8626 +#define GL_CW 0x0900 +#define GL_DEBUG_CALLBACK_FUNCTION 0x8244 +#define GL_DEBUG_CALLBACK_USER_PARAM 0x8245 +#define GL_DEBUG_GROUP_STACK_DEPTH 0x826D +#define GL_DEBUG_LOGGED_MESSAGES 0x9145 +#define GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH 0x8243 +#define GL_DEBUG_OUTPUT 0x92E0 +#define GL_DEBUG_OUTPUT_SYNCHRONOUS 0x8242 +#define GL_DEBUG_SEVERITY_HIGH 0x9146 +#define GL_DEBUG_SEVERITY_LOW 0x9148 +#define GL_DEBUG_SEVERITY_MEDIUM 0x9147 +#define GL_DEBUG_SEVERITY_NOTIFICATION 0x826B +#define GL_DEBUG_SOURCE_API 0x8246 +#define GL_DEBUG_SOURCE_APPLICATION 0x824A +#define GL_DEBUG_SOURCE_OTHER 0x824B +#define GL_DEBUG_SOURCE_SHADER_COMPILER 0x8248 +#define GL_DEBUG_SOURCE_THIRD_PARTY 0x8249 +#define GL_DEBUG_SOURCE_WINDOW_SYSTEM 0x8247 +#define GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR 0x824D +#define GL_DEBUG_TYPE_ERROR 0x824C +#define GL_DEBUG_TYPE_MARKER 0x8268 +#define GL_DEBUG_TYPE_OTHER 0x8251 +#define GL_DEBUG_TYPE_PERFORMANCE 0x8250 +#define GL_DEBUG_TYPE_POP_GROUP 0x826A +#define GL_DEBUG_TYPE_PORTABILITY 0x824F +#define GL_DEBUG_TYPE_PUSH_GROUP 0x8269 +#define GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR 0x824E +#define GL_DECR 0x1E03 +#define GL_DECR_WRAP 0x8508 +#define GL_DELETE_STATUS 0x8B80 +#define GL_DEPTH 0x1801 +#define GL_DEPTH24_STENCIL8 0x88F0 +#define GL_DEPTH32F_STENCIL8 0x8CAD +#define GL_DEPTH_ATTACHMENT 0x8D00 +#define GL_DEPTH_BUFFER_BIT 0x00000100 +#define GL_DEPTH_CLAMP 0x864F +#define GL_DEPTH_CLEAR_VALUE 0x0B73 +#define GL_DEPTH_COMPONENT 0x1902 +#define GL_DEPTH_COMPONENT16 0x81A5 +#define GL_DEPTH_COMPONENT24 0x81A6 +#define GL_DEPTH_COMPONENT32 0x81A7 +#define GL_DEPTH_COMPONENT32F 0x8CAC +#define GL_DEPTH_FUNC 0x0B74 +#define GL_DEPTH_RANGE 0x0B70 +#define GL_DEPTH_STENCIL 0x84F9 +#define GL_DEPTH_STENCIL_ATTACHMENT 0x821A +#define GL_DEPTH_TEST 0x0B71 +#define GL_DEPTH_WRITEMASK 0x0B72 +#define GL_DITHER 0x0BD0 +#define GL_DONT_CARE 0x1100 +#define GL_DOUBLE 0x140A +#define GL_DOUBLEBUFFER 0x0C32 +#define GL_DRAW_BUFFER 0x0C01 +#define GL_DRAW_BUFFER0 0x8825 +#define GL_DRAW_BUFFER1 0x8826 +#define GL_DRAW_BUFFER10 0x882F +#define GL_DRAW_BUFFER11 0x8830 +#define GL_DRAW_BUFFER12 0x8831 +#define GL_DRAW_BUFFER13 0x8832 +#define GL_DRAW_BUFFER14 0x8833 +#define GL_DRAW_BUFFER15 0x8834 +#define GL_DRAW_BUFFER2 0x8827 +#define GL_DRAW_BUFFER3 0x8828 +#define GL_DRAW_BUFFER4 0x8829 +#define GL_DRAW_BUFFER5 0x882A +#define GL_DRAW_BUFFER6 0x882B +#define GL_DRAW_BUFFER7 0x882C +#define GL_DRAW_BUFFER8 0x882D +#define GL_DRAW_BUFFER9 0x882E +#define GL_DRAW_FRAMEBUFFER 0x8CA9 +#define GL_DRAW_FRAMEBUFFER_BINDING 0x8CA6 +#define GL_DST_ALPHA 0x0304 +#define GL_DST_COLOR 0x0306 +#define GL_DYNAMIC_COPY 0x88EA +#define GL_DYNAMIC_DRAW 0x88E8 +#define GL_DYNAMIC_READ 0x88E9 +#define GL_ELEMENT_ARRAY_BUFFER 0x8893 +#define GL_ELEMENT_ARRAY_BUFFER_BINDING 0x8895 +#define GL_EQUAL 0x0202 +#define GL_EQUIV 0x1509 +#define GL_EXTENSIONS 0x1F03 +#define GL_FALSE 0 +#define GL_FASTEST 0x1101 +#define GL_FILL 0x1B02 +#define GL_FIRST_VERTEX_CONVENTION 0x8E4D +#define GL_FIXED_ONLY 0x891D +#define GL_FLOAT 0x1406 +#define GL_FLOAT_32_UNSIGNED_INT_24_8_REV 0x8DAD +#define GL_FLOAT_MAT2 0x8B5A +#define GL_FLOAT_MAT2x3 0x8B65 +#define GL_FLOAT_MAT2x4 0x8B66 +#define GL_FLOAT_MAT3 0x8B5B +#define GL_FLOAT_MAT3x2 0x8B67 +#define GL_FLOAT_MAT3x4 0x8B68 +#define GL_FLOAT_MAT4 0x8B5C +#define GL_FLOAT_MAT4x2 0x8B69 +#define GL_FLOAT_MAT4x3 0x8B6A +#define GL_FLOAT_VEC2 0x8B50 +#define GL_FLOAT_VEC3 0x8B51 +#define GL_FLOAT_VEC4 0x8B52 +#define GL_FRAGMENT_SHADER 0x8B30 +#define GL_FRAGMENT_SHADER_DERIVATIVE_HINT 0x8B8B +#define GL_FRAMEBUFFER 0x8D40 +#define GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE 0x8215 +#define GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE 0x8214 +#define GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING 0x8210 +#define GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE 0x8211 +#define GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE 0x8216 +#define GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE 0x8213 +#define GL_FRAMEBUFFER_ATTACHMENT_LAYERED 0x8DA7 +#define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME 0x8CD1 +#define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE 0x8CD0 +#define GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE 0x8212 +#define GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE 0x8217 +#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE 0x8CD3 +#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER 0x8CD4 +#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL 0x8CD2 +#define GL_FRAMEBUFFER_BINDING 0x8CA6 +#define GL_FRAMEBUFFER_COMPLETE 0x8CD5 +#define GL_FRAMEBUFFER_DEFAULT 0x8218 +#define GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT 0x8CD6 +#define GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER 0x8CDB +#define GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS 0x8DA8 +#define GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT 0x8CD7 +#define GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE 0x8D56 +#define GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER 0x8CDC +#define GL_FRAMEBUFFER_SRGB 0x8DB9 +#define GL_FRAMEBUFFER_UNDEFINED 0x8219 +#define GL_FRAMEBUFFER_UNSUPPORTED 0x8CDD +#define GL_FRONT 0x0404 +#define GL_FRONT_AND_BACK 0x0408 +#define GL_FRONT_FACE 0x0B46 +#define GL_FRONT_LEFT 0x0400 +#define GL_FRONT_RIGHT 0x0401 +#define GL_FUNC_ADD 0x8006 +#define GL_FUNC_REVERSE_SUBTRACT 0x800B +#define GL_FUNC_SUBTRACT 0x800A +#define GL_GEOMETRY_INPUT_TYPE 0x8917 +#define GL_GEOMETRY_OUTPUT_TYPE 0x8918 +#define GL_GEOMETRY_SHADER 0x8DD9 +#define GL_GEOMETRY_VERTICES_OUT 0x8916 +#define GL_GEQUAL 0x0206 +#define GL_GREATER 0x0204 +#define GL_GREEN 0x1904 +#define GL_GREEN_INTEGER 0x8D95 +#define GL_HALF_FLOAT 0x140B +#define GL_INCR 0x1E02 +#define GL_INCR_WRAP 0x8507 +#define GL_INFO_LOG_LENGTH 0x8B84 +#define GL_INT 0x1404 +#define GL_INTERLEAVED_ATTRIBS 0x8C8C +#define GL_INT_2_10_10_10_REV 0x8D9F +#define GL_INT_SAMPLER_1D 0x8DC9 +#define GL_INT_SAMPLER_1D_ARRAY 0x8DCE +#define GL_INT_SAMPLER_2D 0x8DCA +#define GL_INT_SAMPLER_2D_ARRAY 0x8DCF +#define GL_INT_SAMPLER_2D_MULTISAMPLE 0x9109 +#define GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY 0x910C +#define GL_INT_SAMPLER_2D_RECT 0x8DCD +#define GL_INT_SAMPLER_3D 0x8DCB +#define GL_INT_SAMPLER_BUFFER 0x8DD0 +#define GL_INT_SAMPLER_CUBE 0x8DCC +#define GL_INT_VEC2 0x8B53 +#define GL_INT_VEC3 0x8B54 +#define GL_INT_VEC4 0x8B55 +#define GL_INVALID_ENUM 0x0500 +#define GL_INVALID_FRAMEBUFFER_OPERATION 0x0506 +#define GL_INVALID_INDEX 0xFFFFFFFF +#define GL_INVALID_OPERATION 0x0502 +#define GL_INVALID_VALUE 0x0501 +#define GL_INVERT 0x150A +#define GL_KEEP 0x1E00 +#define GL_LAST_VERTEX_CONVENTION 0x8E4E +#define GL_LEFT 0x0406 +#define GL_LEQUAL 0x0203 +#define GL_LESS 0x0201 +#define GL_LINE 0x1B01 +#define GL_LINEAR 0x2601 +#define GL_LINEAR_MIPMAP_LINEAR 0x2703 +#define GL_LINEAR_MIPMAP_NEAREST 0x2701 +#define GL_LINES 0x0001 +#define GL_LINES_ADJACENCY 0x000A +#define GL_LINE_LOOP 0x0002 +#define GL_LINE_SMOOTH 0x0B20 +#define GL_LINE_SMOOTH_HINT 0x0C52 +#define GL_LINE_STRIP 0x0003 +#define GL_LINE_STRIP_ADJACENCY 0x000B +#define GL_LINE_WIDTH 0x0B21 +#define GL_LINE_WIDTH_GRANULARITY 0x0B23 +#define GL_LINE_WIDTH_RANGE 0x0B22 +#define GL_LINK_STATUS 0x8B82 +#define GL_LOGIC_OP_MODE 0x0BF0 +#define GL_LOWER_LEFT 0x8CA1 +#define GL_MAJOR_VERSION 0x821B +#define GL_MAP_FLUSH_EXPLICIT_BIT 0x0010 +#define GL_MAP_INVALIDATE_BUFFER_BIT 0x0008 +#define GL_MAP_INVALIDATE_RANGE_BIT 0x0004 +#define GL_MAP_READ_BIT 0x0001 +#define GL_MAP_UNSYNCHRONIZED_BIT 0x0020 +#define GL_MAP_WRITE_BIT 0x0002 +#define GL_MAX 0x8008 +#define GL_MAX_3D_TEXTURE_SIZE 0x8073 +#define GL_MAX_ARRAY_TEXTURE_LAYERS 0x88FF +#define GL_MAX_CLIP_DISTANCES 0x0D32 +#define GL_MAX_COLOR_ATTACHMENTS 0x8CDF +#define GL_MAX_COLOR_TEXTURE_SAMPLES 0x910E +#define GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS 0x8A33 +#define GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS 0x8A32 +#define GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS 0x8B4D +#define GL_MAX_COMBINED_UNIFORM_BLOCKS 0x8A2E +#define GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS 0x8A31 +#define GL_MAX_CUBE_MAP_TEXTURE_SIZE 0x851C +#define GL_MAX_DEBUG_GROUP_STACK_DEPTH 0x826C +#define GL_MAX_DEBUG_LOGGED_MESSAGES 0x9144 +#define GL_MAX_DEBUG_MESSAGE_LENGTH 0x9143 +#define GL_MAX_DEPTH_TEXTURE_SAMPLES 0x910F +#define GL_MAX_DRAW_BUFFERS 0x8824 +#define GL_MAX_DUAL_SOURCE_DRAW_BUFFERS 0x88FC +#define GL_MAX_ELEMENTS_INDICES 0x80E9 +#define GL_MAX_ELEMENTS_VERTICES 0x80E8 +#define GL_MAX_FRAGMENT_INPUT_COMPONENTS 0x9125 +#define GL_MAX_FRAGMENT_UNIFORM_BLOCKS 0x8A2D +#define GL_MAX_FRAGMENT_UNIFORM_COMPONENTS 0x8B49 +#define GL_MAX_GEOMETRY_INPUT_COMPONENTS 0x9123 +#define GL_MAX_GEOMETRY_OUTPUT_COMPONENTS 0x9124 +#define GL_MAX_GEOMETRY_OUTPUT_VERTICES 0x8DE0 +#define GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS 0x8C29 +#define GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS 0x8DE1 +#define GL_MAX_GEOMETRY_UNIFORM_BLOCKS 0x8A2C +#define GL_MAX_GEOMETRY_UNIFORM_COMPONENTS 0x8DDF +#define GL_MAX_INTEGER_SAMPLES 0x9110 +#define GL_MAX_LABEL_LENGTH 0x82E8 +#define GL_MAX_PROGRAM_TEXEL_OFFSET 0x8905 +#define GL_MAX_RECTANGLE_TEXTURE_SIZE 0x84F8 +#define GL_MAX_RENDERBUFFER_SIZE 0x84E8 +#define GL_MAX_SAMPLES 0x8D57 +#define GL_MAX_SAMPLE_MASK_WORDS 0x8E59 +#define GL_MAX_SERVER_WAIT_TIMEOUT 0x9111 +#define GL_MAX_TEXTURE_BUFFER_SIZE 0x8C2B +#define GL_MAX_TEXTURE_IMAGE_UNITS 0x8872 +#define GL_MAX_TEXTURE_LOD_BIAS 0x84FD +#define GL_MAX_TEXTURE_SIZE 0x0D33 +#define GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS 0x8C8A +#define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS 0x8C8B +#define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS 0x8C80 +#define GL_MAX_UNIFORM_BLOCK_SIZE 0x8A30 +#define GL_MAX_UNIFORM_BUFFER_BINDINGS 0x8A2F +#define GL_MAX_VARYING_COMPONENTS 0x8B4B +#define GL_MAX_VARYING_FLOATS 0x8B4B +#define GL_MAX_VERTEX_ATTRIBS 0x8869 +#define GL_MAX_VERTEX_OUTPUT_COMPONENTS 0x9122 +#define GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS 0x8B4C +#define GL_MAX_VERTEX_UNIFORM_BLOCKS 0x8A2B +#define GL_MAX_VERTEX_UNIFORM_COMPONENTS 0x8B4A +#define GL_MAX_VIEWPORT_DIMS 0x0D3A +#define GL_MIN 0x8007 +#define GL_MINOR_VERSION 0x821C +#define GL_MIN_PROGRAM_TEXEL_OFFSET 0x8904 +#define GL_MIRRORED_REPEAT 0x8370 +#define GL_MULTISAMPLE 0x809D +#define GL_NAND 0x150E +#define GL_NEAREST 0x2600 +#define GL_NEAREST_MIPMAP_LINEAR 0x2702 +#define GL_NEAREST_MIPMAP_NEAREST 0x2700 +#define GL_NEVER 0x0200 +#define GL_NICEST 0x1102 +#define GL_NONE 0 +#define GL_NOOP 0x1505 +#define GL_NOR 0x1508 +#define GL_NOTEQUAL 0x0205 +#define GL_NO_ERROR 0 +#define GL_NUM_COMPRESSED_TEXTURE_FORMATS 0x86A2 +#define GL_NUM_EXTENSIONS 0x821D +#define GL_OBJECT_TYPE 0x9112 +#define GL_ONE 1 +#define GL_ONE_MINUS_CONSTANT_ALPHA 0x8004 +#define GL_ONE_MINUS_CONSTANT_COLOR 0x8002 +#define GL_ONE_MINUS_DST_ALPHA 0x0305 +#define GL_ONE_MINUS_DST_COLOR 0x0307 +#define GL_ONE_MINUS_SRC1_ALPHA 0x88FB +#define GL_ONE_MINUS_SRC1_COLOR 0x88FA +#define GL_ONE_MINUS_SRC_ALPHA 0x0303 +#define GL_ONE_MINUS_SRC_COLOR 0x0301 +#define GL_OR 0x1507 +#define GL_OR_INVERTED 0x150D +#define GL_OR_REVERSE 0x150B +#define GL_OUT_OF_MEMORY 0x0505 +#define GL_PACK_ALIGNMENT 0x0D05 +#define GL_PACK_IMAGE_HEIGHT 0x806C +#define GL_PACK_LSB_FIRST 0x0D01 +#define GL_PACK_ROW_LENGTH 0x0D02 +#define GL_PACK_SKIP_IMAGES 0x806B +#define GL_PACK_SKIP_PIXELS 0x0D04 +#define GL_PACK_SKIP_ROWS 0x0D03 +#define GL_PACK_SWAP_BYTES 0x0D00 +#define GL_PIXEL_PACK_BUFFER 0x88EB +#define GL_PIXEL_PACK_BUFFER_BINDING 0x88ED +#define GL_PIXEL_UNPACK_BUFFER 0x88EC +#define GL_PIXEL_UNPACK_BUFFER_BINDING 0x88EF +#define GL_POINT 0x1B00 +#define GL_POINTS 0x0000 +#define GL_POINT_FADE_THRESHOLD_SIZE 0x8128 +#define GL_POINT_SIZE 0x0B11 +#define GL_POINT_SIZE_GRANULARITY 0x0B13 +#define GL_POINT_SIZE_RANGE 0x0B12 +#define GL_POINT_SPRITE_COORD_ORIGIN 0x8CA0 +#define GL_POLYGON_MODE 0x0B40 +#define GL_POLYGON_OFFSET_FACTOR 0x8038 +#define GL_POLYGON_OFFSET_FILL 0x8037 +#define GL_POLYGON_OFFSET_LINE 0x2A02 +#define GL_POLYGON_OFFSET_POINT 0x2A01 +#define GL_POLYGON_OFFSET_UNITS 0x2A00 +#define GL_POLYGON_SMOOTH 0x0B41 +#define GL_POLYGON_SMOOTH_HINT 0x0C53 +#define GL_PRIMITIVES_GENERATED 0x8C87 +#define GL_PRIMITIVE_RESTART 0x8F9D +#define GL_PRIMITIVE_RESTART_INDEX 0x8F9E +#define GL_PROGRAM 0x82E2 +#define GL_PROGRAM_PIPELINE 0x82E4 +#define GL_PROGRAM_POINT_SIZE 0x8642 +#define GL_PROVOKING_VERTEX 0x8E4F +#define GL_PROXY_TEXTURE_1D 0x8063 +#define GL_PROXY_TEXTURE_1D_ARRAY 0x8C19 +#define GL_PROXY_TEXTURE_2D 0x8064 +#define GL_PROXY_TEXTURE_2D_ARRAY 0x8C1B +#define GL_PROXY_TEXTURE_2D_MULTISAMPLE 0x9101 +#define GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY 0x9103 +#define GL_PROXY_TEXTURE_3D 0x8070 +#define GL_PROXY_TEXTURE_CUBE_MAP 0x851B +#define GL_PROXY_TEXTURE_RECTANGLE 0x84F7 +#define GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION 0x8E4C +#define GL_QUERY 0x82E3 +#define GL_QUERY_BY_REGION_NO_WAIT 0x8E16 +#define GL_QUERY_BY_REGION_WAIT 0x8E15 +#define GL_QUERY_COUNTER_BITS 0x8864 +#define GL_QUERY_NO_WAIT 0x8E14 +#define GL_QUERY_RESULT 0x8866 +#define GL_QUERY_RESULT_AVAILABLE 0x8867 +#define GL_QUERY_WAIT 0x8E13 +#define GL_R11F_G11F_B10F 0x8C3A +#define GL_R16 0x822A +#define GL_R16F 0x822D +#define GL_R16I 0x8233 +#define GL_R16UI 0x8234 +#define GL_R16_SNORM 0x8F98 +#define GL_R32F 0x822E +#define GL_R32I 0x8235 +#define GL_R32UI 0x8236 +#define GL_R3_G3_B2 0x2A10 +#define GL_R8 0x8229 +#define GL_R8I 0x8231 +#define GL_R8UI 0x8232 +#define GL_R8_SNORM 0x8F94 +#define GL_RASTERIZER_DISCARD 0x8C89 +#define GL_READ_BUFFER 0x0C02 +#define GL_READ_FRAMEBUFFER 0x8CA8 +#define GL_READ_FRAMEBUFFER_BINDING 0x8CAA +#define GL_READ_ONLY 0x88B8 +#define GL_READ_WRITE 0x88BA +#define GL_RED 0x1903 +#define GL_RED_INTEGER 0x8D94 +#define GL_RENDERBUFFER 0x8D41 +#define GL_RENDERBUFFER_ALPHA_SIZE 0x8D53 +#define GL_RENDERBUFFER_BINDING 0x8CA7 +#define GL_RENDERBUFFER_BLUE_SIZE 0x8D52 +#define GL_RENDERBUFFER_DEPTH_SIZE 0x8D54 +#define GL_RENDERBUFFER_GREEN_SIZE 0x8D51 +#define GL_RENDERBUFFER_HEIGHT 0x8D43 +#define GL_RENDERBUFFER_INTERNAL_FORMAT 0x8D44 +#define GL_RENDERBUFFER_RED_SIZE 0x8D50 +#define GL_RENDERBUFFER_SAMPLES 0x8CAB +#define GL_RENDERBUFFER_STENCIL_SIZE 0x8D55 +#define GL_RENDERBUFFER_WIDTH 0x8D42 +#define GL_RENDERER 0x1F01 +#define GL_REPEAT 0x2901 +#define GL_REPLACE 0x1E01 +#define GL_RG 0x8227 +#define GL_RG16 0x822C +#define GL_RG16F 0x822F +#define GL_RG16I 0x8239 +#define GL_RG16UI 0x823A +#define GL_RG16_SNORM 0x8F99 +#define GL_RG32F 0x8230 +#define GL_RG32I 0x823B +#define GL_RG32UI 0x823C +#define GL_RG8 0x822B +#define GL_RG8I 0x8237 +#define GL_RG8UI 0x8238 +#define GL_RG8_SNORM 0x8F95 +#define GL_RGB 0x1907 +#define GL_RGB10 0x8052 +#define GL_RGB10_A2 0x8059 +#define GL_RGB10_A2UI 0x906F +#define GL_RGB12 0x8053 +#define GL_RGB16 0x8054 +#define GL_RGB16F 0x881B +#define GL_RGB16I 0x8D89 +#define GL_RGB16UI 0x8D77 +#define GL_RGB16_SNORM 0x8F9A +#define GL_RGB32F 0x8815 +#define GL_RGB32I 0x8D83 +#define GL_RGB32UI 0x8D71 +#define GL_RGB4 0x804F +#define GL_RGB5 0x8050 +#define GL_RGB5_A1 0x8057 +#define GL_RGB8 0x8051 +#define GL_RGB8I 0x8D8F +#define GL_RGB8UI 0x8D7D +#define GL_RGB8_SNORM 0x8F96 +#define GL_RGB9_E5 0x8C3D +#define GL_RGBA 0x1908 +#define GL_RGBA12 0x805A +#define GL_RGBA16 0x805B +#define GL_RGBA16F 0x881A +#define GL_RGBA16I 0x8D88 +#define GL_RGBA16UI 0x8D76 +#define GL_RGBA16_SNORM 0x8F9B +#define GL_RGBA2 0x8055 +#define GL_RGBA32F 0x8814 +#define GL_RGBA32I 0x8D82 +#define GL_RGBA32UI 0x8D70 +#define GL_RGBA4 0x8056 +#define GL_RGBA8 0x8058 +#define GL_RGBA8I 0x8D8E +#define GL_RGBA8UI 0x8D7C +#define GL_RGBA8_SNORM 0x8F97 +#define GL_RGBA_INTEGER 0x8D99 +#define GL_RGB_INTEGER 0x8D98 +#define GL_RG_INTEGER 0x8228 +#define GL_RIGHT 0x0407 +#define GL_SAMPLER 0x82E6 +#define GL_SAMPLER_1D 0x8B5D +#define GL_SAMPLER_1D_ARRAY 0x8DC0 +#define GL_SAMPLER_1D_ARRAY_SHADOW 0x8DC3 +#define GL_SAMPLER_1D_SHADOW 0x8B61 +#define GL_SAMPLER_2D 0x8B5E +#define GL_SAMPLER_2D_ARRAY 0x8DC1 +#define GL_SAMPLER_2D_ARRAY_SHADOW 0x8DC4 +#define GL_SAMPLER_2D_MULTISAMPLE 0x9108 +#define GL_SAMPLER_2D_MULTISAMPLE_ARRAY 0x910B +#define GL_SAMPLER_2D_RECT 0x8B63 +#define GL_SAMPLER_2D_RECT_SHADOW 0x8B64 +#define GL_SAMPLER_2D_SHADOW 0x8B62 +#define GL_SAMPLER_3D 0x8B5F +#define GL_SAMPLER_BINDING 0x8919 +#define GL_SAMPLER_BUFFER 0x8DC2 +#define GL_SAMPLER_CUBE 0x8B60 +#define GL_SAMPLER_CUBE_SHADOW 0x8DC5 +#define GL_SAMPLES 0x80A9 +#define GL_SAMPLES_PASSED 0x8914 +#define GL_SAMPLE_ALPHA_TO_COVERAGE 0x809E +#define GL_SAMPLE_ALPHA_TO_ONE 0x809F +#define GL_SAMPLE_BUFFERS 0x80A8 +#define GL_SAMPLE_COVERAGE 0x80A0 +#define GL_SAMPLE_COVERAGE_INVERT 0x80AB +#define GL_SAMPLE_COVERAGE_VALUE 0x80AA +#define GL_SAMPLE_MASK 0x8E51 +#define GL_SAMPLE_MASK_VALUE 0x8E52 +#define GL_SAMPLE_POSITION 0x8E50 +#define GL_SCISSOR_BOX 0x0C10 +#define GL_SCISSOR_TEST 0x0C11 +#define GL_SEPARATE_ATTRIBS 0x8C8D +#define GL_SET 0x150F +#define GL_SHADER 0x82E1 +#define GL_SHADER_SOURCE_LENGTH 0x8B88 +#define GL_SHADER_TYPE 0x8B4F +#define GL_SHADING_LANGUAGE_VERSION 0x8B8C +#define GL_SHORT 0x1402 +#define GL_SIGNALED 0x9119 +#define GL_SIGNED_NORMALIZED 0x8F9C +#define GL_SMOOTH_LINE_WIDTH_GRANULARITY 0x0B23 +#define GL_SMOOTH_LINE_WIDTH_RANGE 0x0B22 +#define GL_SMOOTH_POINT_SIZE_GRANULARITY 0x0B13 +#define GL_SMOOTH_POINT_SIZE_RANGE 0x0B12 +#define GL_SRC1_ALPHA 0x8589 +#define GL_SRC1_COLOR 0x88F9 +#define GL_SRC_ALPHA 0x0302 +#define GL_SRC_ALPHA_SATURATE 0x0308 +#define GL_SRC_COLOR 0x0300 +#define GL_SRGB 0x8C40 +#define GL_SRGB8 0x8C41 +#define GL_SRGB8_ALPHA8 0x8C43 +#define GL_SRGB_ALPHA 0x8C42 +#define GL_STACK_OVERFLOW 0x0503 +#define GL_STACK_UNDERFLOW 0x0504 +#define GL_STATIC_COPY 0x88E6 +#define GL_STATIC_DRAW 0x88E4 +#define GL_STATIC_READ 0x88E5 +#define GL_STENCIL 0x1802 +#define GL_STENCIL_ATTACHMENT 0x8D20 +#define GL_STENCIL_BACK_FAIL 0x8801 +#define GL_STENCIL_BACK_FUNC 0x8800 +#define GL_STENCIL_BACK_PASS_DEPTH_FAIL 0x8802 +#define GL_STENCIL_BACK_PASS_DEPTH_PASS 0x8803 +#define GL_STENCIL_BACK_REF 0x8CA3 +#define GL_STENCIL_BACK_VALUE_MASK 0x8CA4 +#define GL_STENCIL_BACK_WRITEMASK 0x8CA5 +#define GL_STENCIL_BUFFER_BIT 0x00000400 +#define GL_STENCIL_CLEAR_VALUE 0x0B91 +#define GL_STENCIL_FAIL 0x0B94 +#define GL_STENCIL_FUNC 0x0B92 +#define GL_STENCIL_INDEX 0x1901 +#define GL_STENCIL_INDEX1 0x8D46 +#define GL_STENCIL_INDEX16 0x8D49 +#define GL_STENCIL_INDEX4 0x8D47 +#define GL_STENCIL_INDEX8 0x8D48 +#define GL_STENCIL_PASS_DEPTH_FAIL 0x0B95 +#define GL_STENCIL_PASS_DEPTH_PASS 0x0B96 +#define GL_STENCIL_REF 0x0B97 +#define GL_STENCIL_TEST 0x0B90 +#define GL_STENCIL_VALUE_MASK 0x0B93 +#define GL_STENCIL_WRITEMASK 0x0B98 +#define GL_STEREO 0x0C33 +#define GL_STREAM_COPY 0x88E2 +#define GL_STREAM_DRAW 0x88E0 +#define GL_STREAM_READ 0x88E1 +#define GL_SUBPIXEL_BITS 0x0D50 +#define GL_SYNC_CONDITION 0x9113 +#define GL_SYNC_FENCE 0x9116 +#define GL_SYNC_FLAGS 0x9115 +#define GL_SYNC_FLUSH_COMMANDS_BIT 0x00000001 +#define GL_SYNC_GPU_COMMANDS_COMPLETE 0x9117 +#define GL_SYNC_STATUS 0x9114 +#define GL_TEXTURE 0x1702 +#define GL_TEXTURE0 0x84C0 +#define GL_TEXTURE1 0x84C1 +#define GL_TEXTURE10 0x84CA +#define GL_TEXTURE11 0x84CB +#define GL_TEXTURE12 0x84CC +#define GL_TEXTURE13 0x84CD +#define GL_TEXTURE14 0x84CE +#define GL_TEXTURE15 0x84CF +#define GL_TEXTURE16 0x84D0 +#define GL_TEXTURE17 0x84D1 +#define GL_TEXTURE18 0x84D2 +#define GL_TEXTURE19 0x84D3 +#define GL_TEXTURE2 0x84C2 +#define GL_TEXTURE20 0x84D4 +#define GL_TEXTURE21 0x84D5 +#define GL_TEXTURE22 0x84D6 +#define GL_TEXTURE23 0x84D7 +#define GL_TEXTURE24 0x84D8 +#define GL_TEXTURE25 0x84D9 +#define GL_TEXTURE26 0x84DA +#define GL_TEXTURE27 0x84DB +#define GL_TEXTURE28 0x84DC +#define GL_TEXTURE29 0x84DD +#define GL_TEXTURE3 0x84C3 +#define GL_TEXTURE30 0x84DE +#define GL_TEXTURE31 0x84DF +#define GL_TEXTURE4 0x84C4 +#define GL_TEXTURE5 0x84C5 +#define GL_TEXTURE6 0x84C6 +#define GL_TEXTURE7 0x84C7 +#define GL_TEXTURE8 0x84C8 +#define GL_TEXTURE9 0x84C9 +#define GL_TEXTURE_1D 0x0DE0 +#define GL_TEXTURE_1D_ARRAY 0x8C18 +#define GL_TEXTURE_2D 0x0DE1 +#define GL_TEXTURE_2D_ARRAY 0x8C1A +#define GL_TEXTURE_2D_MULTISAMPLE 0x9100 +#define GL_TEXTURE_2D_MULTISAMPLE_ARRAY 0x9102 +#define GL_TEXTURE_3D 0x806F +#define GL_TEXTURE_ALPHA_SIZE 0x805F +#define GL_TEXTURE_ALPHA_TYPE 0x8C13 +#define GL_TEXTURE_BASE_LEVEL 0x813C +#define GL_TEXTURE_BINDING_1D 0x8068 +#define GL_TEXTURE_BINDING_1D_ARRAY 0x8C1C +#define GL_TEXTURE_BINDING_2D 0x8069 +#define GL_TEXTURE_BINDING_2D_ARRAY 0x8C1D +#define GL_TEXTURE_BINDING_2D_MULTISAMPLE 0x9104 +#define GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY 0x9105 +#define GL_TEXTURE_BINDING_3D 0x806A +#define GL_TEXTURE_BINDING_BUFFER 0x8C2C +#define GL_TEXTURE_BINDING_CUBE_MAP 0x8514 +#define GL_TEXTURE_BINDING_RECTANGLE 0x84F6 +#define GL_TEXTURE_BLUE_SIZE 0x805E +#define GL_TEXTURE_BLUE_TYPE 0x8C12 +#define GL_TEXTURE_BORDER_COLOR 0x1004 +#define GL_TEXTURE_BUFFER 0x8C2A +#define GL_TEXTURE_BUFFER_DATA_STORE_BINDING 0x8C2D +#define GL_TEXTURE_COMPARE_FUNC 0x884D +#define GL_TEXTURE_COMPARE_MODE 0x884C +#define GL_TEXTURE_COMPRESSED 0x86A1 +#define GL_TEXTURE_COMPRESSED_IMAGE_SIZE 0x86A0 +#define GL_TEXTURE_COMPRESSION_HINT 0x84EF +#define GL_TEXTURE_CUBE_MAP 0x8513 +#define GL_TEXTURE_CUBE_MAP_NEGATIVE_X 0x8516 +#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Y 0x8518 +#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Z 0x851A +#define GL_TEXTURE_CUBE_MAP_POSITIVE_X 0x8515 +#define GL_TEXTURE_CUBE_MAP_POSITIVE_Y 0x8517 +#define GL_TEXTURE_CUBE_MAP_POSITIVE_Z 0x8519 +#define GL_TEXTURE_CUBE_MAP_SEAMLESS 0x884F +#define GL_TEXTURE_DEPTH 0x8071 +#define GL_TEXTURE_DEPTH_SIZE 0x884A +#define GL_TEXTURE_DEPTH_TYPE 0x8C16 +#define GL_TEXTURE_FIXED_SAMPLE_LOCATIONS 0x9107 +#define GL_TEXTURE_GREEN_SIZE 0x805D +#define GL_TEXTURE_GREEN_TYPE 0x8C11 +#define GL_TEXTURE_HEIGHT 0x1001 +#define GL_TEXTURE_INTERNAL_FORMAT 0x1003 +#define GL_TEXTURE_LOD_BIAS 0x8501 +#define GL_TEXTURE_MAG_FILTER 0x2800 +#define GL_TEXTURE_MAX_LEVEL 0x813D +#define GL_TEXTURE_MAX_LOD 0x813B +#define GL_TEXTURE_MIN_FILTER 0x2801 +#define GL_TEXTURE_MIN_LOD 0x813A +#define GL_TEXTURE_RECTANGLE 0x84F5 +#define GL_TEXTURE_RED_SIZE 0x805C +#define GL_TEXTURE_RED_TYPE 0x8C10 +#define GL_TEXTURE_SAMPLES 0x9106 +#define GL_TEXTURE_SHARED_SIZE 0x8C3F +#define GL_TEXTURE_STENCIL_SIZE 0x88F1 +#define GL_TEXTURE_SWIZZLE_A 0x8E45 +#define GL_TEXTURE_SWIZZLE_B 0x8E44 +#define GL_TEXTURE_SWIZZLE_G 0x8E43 +#define GL_TEXTURE_SWIZZLE_R 0x8E42 +#define GL_TEXTURE_SWIZZLE_RGBA 0x8E46 +#define GL_TEXTURE_WIDTH 0x1000 +#define GL_TEXTURE_WRAP_R 0x8072 +#define GL_TEXTURE_WRAP_S 0x2802 +#define GL_TEXTURE_WRAP_T 0x2803 +#define GL_TIMEOUT_EXPIRED 0x911B +#define GL_TIMEOUT_IGNORED 0xFFFFFFFFFFFFFFFF +#define GL_TIMESTAMP 0x8E28 +#define GL_TIME_ELAPSED 0x88BF +#define GL_TRANSFORM_FEEDBACK_BUFFER 0x8C8E +#define GL_TRANSFORM_FEEDBACK_BUFFER_BINDING 0x8C8F +#define GL_TRANSFORM_FEEDBACK_BUFFER_MODE 0x8C7F +#define GL_TRANSFORM_FEEDBACK_BUFFER_SIZE 0x8C85 +#define GL_TRANSFORM_FEEDBACK_BUFFER_START 0x8C84 +#define GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN 0x8C88 +#define GL_TRANSFORM_FEEDBACK_VARYINGS 0x8C83 +#define GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH 0x8C76 +#define GL_TRIANGLES 0x0004 +#define GL_TRIANGLES_ADJACENCY 0x000C +#define GL_TRIANGLE_FAN 0x0006 +#define GL_TRIANGLE_STRIP 0x0005 +#define GL_TRIANGLE_STRIP_ADJACENCY 0x000D +#define GL_TRUE 1 +#define GL_UNIFORM_ARRAY_STRIDE 0x8A3C +#define GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS 0x8A42 +#define GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES 0x8A43 +#define GL_UNIFORM_BLOCK_BINDING 0x8A3F +#define GL_UNIFORM_BLOCK_DATA_SIZE 0x8A40 +#define GL_UNIFORM_BLOCK_INDEX 0x8A3A +#define GL_UNIFORM_BLOCK_NAME_LENGTH 0x8A41 +#define GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER 0x8A46 +#define GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER 0x8A45 +#define GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER 0x8A44 +#define GL_UNIFORM_BUFFER 0x8A11 +#define GL_UNIFORM_BUFFER_BINDING 0x8A28 +#define GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT 0x8A34 +#define GL_UNIFORM_BUFFER_SIZE 0x8A2A +#define GL_UNIFORM_BUFFER_START 0x8A29 +#define GL_UNIFORM_IS_ROW_MAJOR 0x8A3E +#define GL_UNIFORM_MATRIX_STRIDE 0x8A3D +#define GL_UNIFORM_NAME_LENGTH 0x8A39 +#define GL_UNIFORM_OFFSET 0x8A3B +#define GL_UNIFORM_SIZE 0x8A38 +#define GL_UNIFORM_TYPE 0x8A37 +#define GL_UNPACK_ALIGNMENT 0x0CF5 +#define GL_UNPACK_IMAGE_HEIGHT 0x806E +#define GL_UNPACK_LSB_FIRST 0x0CF1 +#define GL_UNPACK_ROW_LENGTH 0x0CF2 +#define GL_UNPACK_SKIP_IMAGES 0x806D +#define GL_UNPACK_SKIP_PIXELS 0x0CF4 +#define GL_UNPACK_SKIP_ROWS 0x0CF3 +#define GL_UNPACK_SWAP_BYTES 0x0CF0 +#define GL_UNSIGNALED 0x9118 +#define GL_UNSIGNED_BYTE 0x1401 +#define GL_UNSIGNED_BYTE_2_3_3_REV 0x8362 +#define GL_UNSIGNED_BYTE_3_3_2 0x8032 +#define GL_UNSIGNED_INT 0x1405 +#define GL_UNSIGNED_INT_10F_11F_11F_REV 0x8C3B +#define GL_UNSIGNED_INT_10_10_10_2 0x8036 +#define GL_UNSIGNED_INT_24_8 0x84FA +#define GL_UNSIGNED_INT_2_10_10_10_REV 0x8368 +#define GL_UNSIGNED_INT_5_9_9_9_REV 0x8C3E +#define GL_UNSIGNED_INT_8_8_8_8 0x8035 +#define GL_UNSIGNED_INT_8_8_8_8_REV 0x8367 +#define GL_UNSIGNED_INT_SAMPLER_1D 0x8DD1 +#define GL_UNSIGNED_INT_SAMPLER_1D_ARRAY 0x8DD6 +#define GL_UNSIGNED_INT_SAMPLER_2D 0x8DD2 +#define GL_UNSIGNED_INT_SAMPLER_2D_ARRAY 0x8DD7 +#define GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE 0x910A +#define GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY 0x910D +#define GL_UNSIGNED_INT_SAMPLER_2D_RECT 0x8DD5 +#define GL_UNSIGNED_INT_SAMPLER_3D 0x8DD3 +#define GL_UNSIGNED_INT_SAMPLER_BUFFER 0x8DD8 +#define GL_UNSIGNED_INT_SAMPLER_CUBE 0x8DD4 +#define GL_UNSIGNED_INT_VEC2 0x8DC6 +#define GL_UNSIGNED_INT_VEC3 0x8DC7 +#define GL_UNSIGNED_INT_VEC4 0x8DC8 +#define GL_UNSIGNED_NORMALIZED 0x8C17 +#define GL_UNSIGNED_SHORT 0x1403 +#define GL_UNSIGNED_SHORT_1_5_5_5_REV 0x8366 +#define GL_UNSIGNED_SHORT_4_4_4_4 0x8033 +#define GL_UNSIGNED_SHORT_4_4_4_4_REV 0x8365 +#define GL_UNSIGNED_SHORT_5_5_5_1 0x8034 +#define GL_UNSIGNED_SHORT_5_6_5 0x8363 +#define GL_UNSIGNED_SHORT_5_6_5_REV 0x8364 +#define GL_UPPER_LEFT 0x8CA2 +#define GL_VALIDATE_STATUS 0x8B83 +#define GL_VENDOR 0x1F00 +#define GL_VERSION 0x1F02 +#define GL_VERTEX_ARRAY 0x8074 +#define GL_VERTEX_ARRAY_BINDING 0x85B5 +#define GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING 0x889F +#define GL_VERTEX_ATTRIB_ARRAY_DIVISOR 0x88FE +#define GL_VERTEX_ATTRIB_ARRAY_ENABLED 0x8622 +#define GL_VERTEX_ATTRIB_ARRAY_INTEGER 0x88FD +#define GL_VERTEX_ATTRIB_ARRAY_NORMALIZED 0x886A +#define GL_VERTEX_ATTRIB_ARRAY_POINTER 0x8645 +#define GL_VERTEX_ATTRIB_ARRAY_SIZE 0x8623 +#define GL_VERTEX_ATTRIB_ARRAY_STRIDE 0x8624 +#define GL_VERTEX_ATTRIB_ARRAY_TYPE 0x8625 +#define GL_VERTEX_PROGRAM_POINT_SIZE 0x8642 +#define GL_VERTEX_SHADER 0x8B31 +#define GL_VIEWPORT 0x0BA2 +#define GL_WAIT_FAILED 0x911D +#define GL_WRITE_ONLY 0x88B9 +#define GL_XOR 0x1506 +#define GL_ZERO 0 + + +#include +typedef unsigned int GLenum; +typedef unsigned char GLboolean; +typedef unsigned int GLbitfield; +typedef void GLvoid; +typedef khronos_int8_t GLbyte; +typedef khronos_uint8_t GLubyte; +typedef khronos_int16_t GLshort; +typedef khronos_uint16_t GLushort; +typedef int GLint; +typedef unsigned int GLuint; +typedef khronos_int32_t GLclampx; +typedef int GLsizei; +typedef khronos_float_t GLfloat; +typedef khronos_float_t GLclampf; +typedef double GLdouble; +typedef double GLclampd; +typedef void *GLeglClientBufferEXT; +typedef void *GLeglImageOES; +typedef char GLchar; +typedef char GLcharARB; +#ifdef __APPLE__ +typedef void *GLhandleARB; +#else +typedef unsigned int GLhandleARB; +#endif +typedef khronos_uint16_t GLhalf; +typedef khronos_uint16_t GLhalfARB; +typedef khronos_int32_t GLfixed; +#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && (__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ > 1060) +typedef khronos_intptr_t GLintptr; +#else +typedef khronos_intptr_t GLintptr; +#endif +#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && (__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ > 1060) +typedef khronos_intptr_t GLintptrARB; +#else +typedef khronos_intptr_t GLintptrARB; +#endif +#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && (__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ > 1060) +typedef khronos_ssize_t GLsizeiptr; +#else +typedef khronos_ssize_t GLsizeiptr; +#endif +#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && (__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ > 1060) +typedef khronos_ssize_t GLsizeiptrARB; +#else +typedef khronos_ssize_t GLsizeiptrARB; +#endif +typedef khronos_int64_t GLint64; +typedef khronos_int64_t GLint64EXT; +typedef khronos_uint64_t GLuint64; +typedef khronos_uint64_t GLuint64EXT; +typedef struct __GLsync *GLsync; +struct _cl_context; +struct _cl_event; +typedef void (GLAD_API_PTR *GLDEBUGPROC)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam); +typedef void (GLAD_API_PTR *GLDEBUGPROCARB)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam); +typedef void (GLAD_API_PTR *GLDEBUGPROCKHR)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam); +typedef void (GLAD_API_PTR *GLDEBUGPROCAMD)(GLuint id,GLenum category,GLenum severity,GLsizei length,const GLchar *message,void *userParam); +typedef unsigned short GLhalfNV; +typedef GLintptr GLvdpauSurfaceNV; +typedef void (GLAD_API_PTR *GLVULKANPROCNV)(void); + + +#define GL_VERSION_1_0 1 +GLAD_API_CALL int GLAD_GL_VERSION_1_0; +#define GL_VERSION_1_1 1 +GLAD_API_CALL int GLAD_GL_VERSION_1_1; +#define GL_VERSION_1_2 1 +GLAD_API_CALL int GLAD_GL_VERSION_1_2; +#define GL_VERSION_1_3 1 +GLAD_API_CALL int GLAD_GL_VERSION_1_3; +#define GL_VERSION_1_4 1 +GLAD_API_CALL int GLAD_GL_VERSION_1_4; +#define GL_VERSION_1_5 1 +GLAD_API_CALL int GLAD_GL_VERSION_1_5; +#define GL_VERSION_2_0 1 +GLAD_API_CALL int GLAD_GL_VERSION_2_0; +#define GL_VERSION_2_1 1 +GLAD_API_CALL int GLAD_GL_VERSION_2_1; +#define GL_VERSION_3_0 1 +GLAD_API_CALL int GLAD_GL_VERSION_3_0; +#define GL_VERSION_3_1 1 +GLAD_API_CALL int GLAD_GL_VERSION_3_1; +#define GL_VERSION_3_2 1 +GLAD_API_CALL int GLAD_GL_VERSION_3_2; +#define GL_VERSION_3_3 1 +GLAD_API_CALL int GLAD_GL_VERSION_3_3; +#define GL_KHR_debug 1 +GLAD_API_CALL int GLAD_GL_KHR_debug; + + +typedef void (GLAD_API_PTR *PFNGLACTIVETEXTUREPROC)(GLenum texture); +typedef void (GLAD_API_PTR *PFNGLATTACHSHADERPROC)(GLuint program, GLuint shader); +typedef void (GLAD_API_PTR *PFNGLBEGINCONDITIONALRENDERPROC)(GLuint id, GLenum mode); +typedef void (GLAD_API_PTR *PFNGLBEGINQUERYPROC)(GLenum target, GLuint id); +typedef void (GLAD_API_PTR *PFNGLBEGINTRANSFORMFEEDBACKPROC)(GLenum primitiveMode); +typedef void (GLAD_API_PTR *PFNGLBINDATTRIBLOCATIONPROC)(GLuint program, GLuint index, const GLchar * name); +typedef void (GLAD_API_PTR *PFNGLBINDBUFFERPROC)(GLenum target, GLuint buffer); +typedef void (GLAD_API_PTR *PFNGLBINDBUFFERBASEPROC)(GLenum target, GLuint index, GLuint buffer); +typedef void (GLAD_API_PTR *PFNGLBINDBUFFERRANGEPROC)(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size); +typedef void (GLAD_API_PTR *PFNGLBINDFRAGDATALOCATIONPROC)(GLuint program, GLuint color, const GLchar * name); +typedef void (GLAD_API_PTR *PFNGLBINDFRAGDATALOCATIONINDEXEDPROC)(GLuint program, GLuint colorNumber, GLuint index, const GLchar * name); +typedef void (GLAD_API_PTR *PFNGLBINDFRAMEBUFFERPROC)(GLenum target, GLuint framebuffer); +typedef void (GLAD_API_PTR *PFNGLBINDRENDERBUFFERPROC)(GLenum target, GLuint renderbuffer); +typedef void (GLAD_API_PTR *PFNGLBINDSAMPLERPROC)(GLuint unit, GLuint sampler); +typedef void (GLAD_API_PTR *PFNGLBINDTEXTUREPROC)(GLenum target, GLuint texture); +typedef void (GLAD_API_PTR *PFNGLBINDVERTEXARRAYPROC)(GLuint array); +typedef void (GLAD_API_PTR *PFNGLBLENDCOLORPROC)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +typedef void (GLAD_API_PTR *PFNGLBLENDEQUATIONPROC)(GLenum mode); +typedef void (GLAD_API_PTR *PFNGLBLENDEQUATIONSEPARATEPROC)(GLenum modeRGB, GLenum modeAlpha); +typedef void (GLAD_API_PTR *PFNGLBLENDFUNCPROC)(GLenum sfactor, GLenum dfactor); +typedef void (GLAD_API_PTR *PFNGLBLENDFUNCSEPARATEPROC)(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha); +typedef void (GLAD_API_PTR *PFNGLBLITFRAMEBUFFERPROC)(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter); +typedef void (GLAD_API_PTR *PFNGLBUFFERDATAPROC)(GLenum target, GLsizeiptr size, const void * data, GLenum usage); +typedef void (GLAD_API_PTR *PFNGLBUFFERSUBDATAPROC)(GLenum target, GLintptr offset, GLsizeiptr size, const void * data); +typedef GLenum (GLAD_API_PTR *PFNGLCHECKFRAMEBUFFERSTATUSPROC)(GLenum target); +typedef void (GLAD_API_PTR *PFNGLCLAMPCOLORPROC)(GLenum target, GLenum clamp); +typedef void (GLAD_API_PTR *PFNGLCLEARPROC)(GLbitfield mask); +typedef void (GLAD_API_PTR *PFNGLCLEARBUFFERFIPROC)(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil); +typedef void (GLAD_API_PTR *PFNGLCLEARBUFFERFVPROC)(GLenum buffer, GLint drawbuffer, const GLfloat * value); +typedef void (GLAD_API_PTR *PFNGLCLEARBUFFERIVPROC)(GLenum buffer, GLint drawbuffer, const GLint * value); +typedef void (GLAD_API_PTR *PFNGLCLEARBUFFERUIVPROC)(GLenum buffer, GLint drawbuffer, const GLuint * value); +typedef void (GLAD_API_PTR *PFNGLCLEARCOLORPROC)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +typedef void (GLAD_API_PTR *PFNGLCLEARDEPTHPROC)(GLdouble depth); +typedef void (GLAD_API_PTR *PFNGLCLEARSTENCILPROC)(GLint s); +typedef GLenum (GLAD_API_PTR *PFNGLCLIENTWAITSYNCPROC)(GLsync sync, GLbitfield flags, GLuint64 timeout); +typedef void (GLAD_API_PTR *PFNGLCOLORMASKPROC)(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha); +typedef void (GLAD_API_PTR *PFNGLCOLORMASKIPROC)(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a); +typedef void (GLAD_API_PTR *PFNGLCOMPILESHADERPROC)(GLuint shader); +typedef void (GLAD_API_PTR *PFNGLCOMPRESSEDTEXIMAGE1DPROC)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void * data); +typedef void (GLAD_API_PTR *PFNGLCOMPRESSEDTEXIMAGE2DPROC)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void * data); +typedef void (GLAD_API_PTR *PFNGLCOMPRESSEDTEXIMAGE3DPROC)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void * data); +typedef void (GLAD_API_PTR *PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void * data); +typedef void (GLAD_API_PTR *PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void * data); +typedef void (GLAD_API_PTR *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 (GLAD_API_PTR *PFNGLCOPYBUFFERSUBDATAPROC)(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size); +typedef void (GLAD_API_PTR *PFNGLCOPYTEXIMAGE1DPROC)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border); +typedef void (GLAD_API_PTR *PFNGLCOPYTEXIMAGE2DPROC)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); +typedef void (GLAD_API_PTR *PFNGLCOPYTEXSUBIMAGE1DPROC)(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width); +typedef void (GLAD_API_PTR *PFNGLCOPYTEXSUBIMAGE2DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); +typedef void (GLAD_API_PTR *PFNGLCOPYTEXSUBIMAGE3DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); +typedef GLuint (GLAD_API_PTR *PFNGLCREATEPROGRAMPROC)(void); +typedef GLuint (GLAD_API_PTR *PFNGLCREATESHADERPROC)(GLenum type); +typedef void (GLAD_API_PTR *PFNGLCULLFACEPROC)(GLenum mode); +typedef void (GLAD_API_PTR *PFNGLDEBUGMESSAGECALLBACKPROC)(GLDEBUGPROC callback, const void * userParam); +typedef void (GLAD_API_PTR *PFNGLDEBUGMESSAGECONTROLPROC)(GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint * ids, GLboolean enabled); +typedef void (GLAD_API_PTR *PFNGLDEBUGMESSAGEINSERTPROC)(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar * buf); +typedef void (GLAD_API_PTR *PFNGLDELETEBUFFERSPROC)(GLsizei n, const GLuint * buffers); +typedef void (GLAD_API_PTR *PFNGLDELETEFRAMEBUFFERSPROC)(GLsizei n, const GLuint * framebuffers); +typedef void (GLAD_API_PTR *PFNGLDELETEPROGRAMPROC)(GLuint program); +typedef void (GLAD_API_PTR *PFNGLDELETEQUERIESPROC)(GLsizei n, const GLuint * ids); +typedef void (GLAD_API_PTR *PFNGLDELETERENDERBUFFERSPROC)(GLsizei n, const GLuint * renderbuffers); +typedef void (GLAD_API_PTR *PFNGLDELETESAMPLERSPROC)(GLsizei count, const GLuint * samplers); +typedef void (GLAD_API_PTR *PFNGLDELETESHADERPROC)(GLuint shader); +typedef void (GLAD_API_PTR *PFNGLDELETESYNCPROC)(GLsync sync); +typedef void (GLAD_API_PTR *PFNGLDELETETEXTURESPROC)(GLsizei n, const GLuint * textures); +typedef void (GLAD_API_PTR *PFNGLDELETEVERTEXARRAYSPROC)(GLsizei n, const GLuint * arrays); +typedef void (GLAD_API_PTR *PFNGLDEPTHFUNCPROC)(GLenum func); +typedef void (GLAD_API_PTR *PFNGLDEPTHMASKPROC)(GLboolean flag); +typedef void (GLAD_API_PTR *PFNGLDEPTHRANGEPROC)(GLdouble n, GLdouble f); +typedef void (GLAD_API_PTR *PFNGLDETACHSHADERPROC)(GLuint program, GLuint shader); +typedef void (GLAD_API_PTR *PFNGLDISABLEPROC)(GLenum cap); +typedef void (GLAD_API_PTR *PFNGLDISABLEVERTEXATTRIBARRAYPROC)(GLuint index); +typedef void (GLAD_API_PTR *PFNGLDISABLEIPROC)(GLenum target, GLuint index); +typedef void (GLAD_API_PTR *PFNGLDRAWARRAYSPROC)(GLenum mode, GLint first, GLsizei count); +typedef void (GLAD_API_PTR *PFNGLDRAWARRAYSINSTANCEDPROC)(GLenum mode, GLint first, GLsizei count, GLsizei instancecount); +typedef void (GLAD_API_PTR *PFNGLDRAWBUFFERPROC)(GLenum buf); +typedef void (GLAD_API_PTR *PFNGLDRAWBUFFERSPROC)(GLsizei n, const GLenum * bufs); +typedef void (GLAD_API_PTR *PFNGLDRAWELEMENTSPROC)(GLenum mode, GLsizei count, GLenum type, const void * indices); +typedef void (GLAD_API_PTR *PFNGLDRAWELEMENTSBASEVERTEXPROC)(GLenum mode, GLsizei count, GLenum type, const void * indices, GLint basevertex); +typedef void (GLAD_API_PTR *PFNGLDRAWELEMENTSINSTANCEDPROC)(GLenum mode, GLsizei count, GLenum type, const void * indices, GLsizei instancecount); +typedef void (GLAD_API_PTR *PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC)(GLenum mode, GLsizei count, GLenum type, const void * indices, GLsizei instancecount, GLint basevertex); +typedef void (GLAD_API_PTR *PFNGLDRAWRANGEELEMENTSPROC)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void * indices); +typedef void (GLAD_API_PTR *PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void * indices, GLint basevertex); +typedef void (GLAD_API_PTR *PFNGLENABLEPROC)(GLenum cap); +typedef void (GLAD_API_PTR *PFNGLENABLEVERTEXATTRIBARRAYPROC)(GLuint index); +typedef void (GLAD_API_PTR *PFNGLENABLEIPROC)(GLenum target, GLuint index); +typedef void (GLAD_API_PTR *PFNGLENDCONDITIONALRENDERPROC)(void); +typedef void (GLAD_API_PTR *PFNGLENDQUERYPROC)(GLenum target); +typedef void (GLAD_API_PTR *PFNGLENDTRANSFORMFEEDBACKPROC)(void); +typedef GLsync (GLAD_API_PTR *PFNGLFENCESYNCPROC)(GLenum condition, GLbitfield flags); +typedef void (GLAD_API_PTR *PFNGLFINISHPROC)(void); +typedef void (GLAD_API_PTR *PFNGLFLUSHPROC)(void); +typedef void (GLAD_API_PTR *PFNGLFLUSHMAPPEDBUFFERRANGEPROC)(GLenum target, GLintptr offset, GLsizeiptr length); +typedef void (GLAD_API_PTR *PFNGLFRAMEBUFFERRENDERBUFFERPROC)(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer); +typedef void (GLAD_API_PTR *PFNGLFRAMEBUFFERTEXTUREPROC)(GLenum target, GLenum attachment, GLuint texture, GLint level); +typedef void (GLAD_API_PTR *PFNGLFRAMEBUFFERTEXTURE1DPROC)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +typedef void (GLAD_API_PTR *PFNGLFRAMEBUFFERTEXTURE2DPROC)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +typedef void (GLAD_API_PTR *PFNGLFRAMEBUFFERTEXTURE3DPROC)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset); +typedef void (GLAD_API_PTR *PFNGLFRAMEBUFFERTEXTURELAYERPROC)(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer); +typedef void (GLAD_API_PTR *PFNGLFRONTFACEPROC)(GLenum mode); +typedef void (GLAD_API_PTR *PFNGLGENBUFFERSPROC)(GLsizei n, GLuint * buffers); +typedef void (GLAD_API_PTR *PFNGLGENFRAMEBUFFERSPROC)(GLsizei n, GLuint * framebuffers); +typedef void (GLAD_API_PTR *PFNGLGENQUERIESPROC)(GLsizei n, GLuint * ids); +typedef void (GLAD_API_PTR *PFNGLGENRENDERBUFFERSPROC)(GLsizei n, GLuint * renderbuffers); +typedef void (GLAD_API_PTR *PFNGLGENSAMPLERSPROC)(GLsizei count, GLuint * samplers); +typedef void (GLAD_API_PTR *PFNGLGENTEXTURESPROC)(GLsizei n, GLuint * textures); +typedef void (GLAD_API_PTR *PFNGLGENVERTEXARRAYSPROC)(GLsizei n, GLuint * arrays); +typedef void (GLAD_API_PTR *PFNGLGENERATEMIPMAPPROC)(GLenum target); +typedef void (GLAD_API_PTR *PFNGLGETACTIVEATTRIBPROC)(GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLint * size, GLenum * type, GLchar * name); +typedef void (GLAD_API_PTR *PFNGLGETACTIVEUNIFORMPROC)(GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLint * size, GLenum * type, GLchar * name); +typedef void (GLAD_API_PTR *PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC)(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei * length, GLchar * uniformBlockName); +typedef void (GLAD_API_PTR *PFNGLGETACTIVEUNIFORMBLOCKIVPROC)(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint * params); +typedef void (GLAD_API_PTR *PFNGLGETACTIVEUNIFORMNAMEPROC)(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei * length, GLchar * uniformName); +typedef void (GLAD_API_PTR *PFNGLGETACTIVEUNIFORMSIVPROC)(GLuint program, GLsizei uniformCount, const GLuint * uniformIndices, GLenum pname, GLint * params); +typedef void (GLAD_API_PTR *PFNGLGETATTACHEDSHADERSPROC)(GLuint program, GLsizei maxCount, GLsizei * count, GLuint * shaders); +typedef GLint (GLAD_API_PTR *PFNGLGETATTRIBLOCATIONPROC)(GLuint program, const GLchar * name); +typedef void (GLAD_API_PTR *PFNGLGETBOOLEANI_VPROC)(GLenum target, GLuint index, GLboolean * data); +typedef void (GLAD_API_PTR *PFNGLGETBOOLEANVPROC)(GLenum pname, GLboolean * data); +typedef void (GLAD_API_PTR *PFNGLGETBUFFERPARAMETERI64VPROC)(GLenum target, GLenum pname, GLint64 * params); +typedef void (GLAD_API_PTR *PFNGLGETBUFFERPARAMETERIVPROC)(GLenum target, GLenum pname, GLint * params); +typedef void (GLAD_API_PTR *PFNGLGETBUFFERPOINTERVPROC)(GLenum target, GLenum pname, void ** params); +typedef void (GLAD_API_PTR *PFNGLGETBUFFERSUBDATAPROC)(GLenum target, GLintptr offset, GLsizeiptr size, void * data); +typedef void (GLAD_API_PTR *PFNGLGETCOMPRESSEDTEXIMAGEPROC)(GLenum target, GLint level, void * img); +typedef GLuint (GLAD_API_PTR *PFNGLGETDEBUGMESSAGELOGPROC)(GLuint count, GLsizei bufSize, GLenum * sources, GLenum * types, GLuint * ids, GLenum * severities, GLsizei * lengths, GLchar * messageLog); +typedef void (GLAD_API_PTR *PFNGLGETDOUBLEVPROC)(GLenum pname, GLdouble * data); +typedef GLenum (GLAD_API_PTR *PFNGLGETERRORPROC)(void); +typedef void (GLAD_API_PTR *PFNGLGETFLOATVPROC)(GLenum pname, GLfloat * data); +typedef GLint (GLAD_API_PTR *PFNGLGETFRAGDATAINDEXPROC)(GLuint program, const GLchar * name); +typedef GLint (GLAD_API_PTR *PFNGLGETFRAGDATALOCATIONPROC)(GLuint program, const GLchar * name); +typedef void (GLAD_API_PTR *PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC)(GLenum target, GLenum attachment, GLenum pname, GLint * params); +typedef void (GLAD_API_PTR *PFNGLGETINTEGER64I_VPROC)(GLenum target, GLuint index, GLint64 * data); +typedef void (GLAD_API_PTR *PFNGLGETINTEGER64VPROC)(GLenum pname, GLint64 * data); +typedef void (GLAD_API_PTR *PFNGLGETINTEGERI_VPROC)(GLenum target, GLuint index, GLint * data); +typedef void (GLAD_API_PTR *PFNGLGETINTEGERVPROC)(GLenum pname, GLint * data); +typedef void (GLAD_API_PTR *PFNGLGETMULTISAMPLEFVPROC)(GLenum pname, GLuint index, GLfloat * val); +typedef void (GLAD_API_PTR *PFNGLGETOBJECTLABELPROC)(GLenum identifier, GLuint name, GLsizei bufSize, GLsizei * length, GLchar * label); +typedef void (GLAD_API_PTR *PFNGLGETOBJECTPTRLABELPROC)(const void * ptr, GLsizei bufSize, GLsizei * length, GLchar * label); +typedef void (GLAD_API_PTR *PFNGLGETPOINTERVPROC)(GLenum pname, void ** params); +typedef void (GLAD_API_PTR *PFNGLGETPROGRAMINFOLOGPROC)(GLuint program, GLsizei bufSize, GLsizei * length, GLchar * infoLog); +typedef void (GLAD_API_PTR *PFNGLGETPROGRAMIVPROC)(GLuint program, GLenum pname, GLint * params); +typedef void (GLAD_API_PTR *PFNGLGETQUERYOBJECTI64VPROC)(GLuint id, GLenum pname, GLint64 * params); +typedef void (GLAD_API_PTR *PFNGLGETQUERYOBJECTIVPROC)(GLuint id, GLenum pname, GLint * params); +typedef void (GLAD_API_PTR *PFNGLGETQUERYOBJECTUI64VPROC)(GLuint id, GLenum pname, GLuint64 * params); +typedef void (GLAD_API_PTR *PFNGLGETQUERYOBJECTUIVPROC)(GLuint id, GLenum pname, GLuint * params); +typedef void (GLAD_API_PTR *PFNGLGETQUERYIVPROC)(GLenum target, GLenum pname, GLint * params); +typedef void (GLAD_API_PTR *PFNGLGETRENDERBUFFERPARAMETERIVPROC)(GLenum target, GLenum pname, GLint * params); +typedef void (GLAD_API_PTR *PFNGLGETSAMPLERPARAMETERIIVPROC)(GLuint sampler, GLenum pname, GLint * params); +typedef void (GLAD_API_PTR *PFNGLGETSAMPLERPARAMETERIUIVPROC)(GLuint sampler, GLenum pname, GLuint * params); +typedef void (GLAD_API_PTR *PFNGLGETSAMPLERPARAMETERFVPROC)(GLuint sampler, GLenum pname, GLfloat * params); +typedef void (GLAD_API_PTR *PFNGLGETSAMPLERPARAMETERIVPROC)(GLuint sampler, GLenum pname, GLint * params); +typedef void (GLAD_API_PTR *PFNGLGETSHADERINFOLOGPROC)(GLuint shader, GLsizei bufSize, GLsizei * length, GLchar * infoLog); +typedef void (GLAD_API_PTR *PFNGLGETSHADERSOURCEPROC)(GLuint shader, GLsizei bufSize, GLsizei * length, GLchar * source); +typedef void (GLAD_API_PTR *PFNGLGETSHADERIVPROC)(GLuint shader, GLenum pname, GLint * params); +typedef const GLubyte * (GLAD_API_PTR *PFNGLGETSTRINGPROC)(GLenum name); +typedef const GLubyte * (GLAD_API_PTR *PFNGLGETSTRINGIPROC)(GLenum name, GLuint index); +typedef void (GLAD_API_PTR *PFNGLGETSYNCIVPROC)(GLsync sync, GLenum pname, GLsizei count, GLsizei * length, GLint * values); +typedef void (GLAD_API_PTR *PFNGLGETTEXIMAGEPROC)(GLenum target, GLint level, GLenum format, GLenum type, void * pixels); +typedef void (GLAD_API_PTR *PFNGLGETTEXLEVELPARAMETERFVPROC)(GLenum target, GLint level, GLenum pname, GLfloat * params); +typedef void (GLAD_API_PTR *PFNGLGETTEXLEVELPARAMETERIVPROC)(GLenum target, GLint level, GLenum pname, GLint * params); +typedef void (GLAD_API_PTR *PFNGLGETTEXPARAMETERIIVPROC)(GLenum target, GLenum pname, GLint * params); +typedef void (GLAD_API_PTR *PFNGLGETTEXPARAMETERIUIVPROC)(GLenum target, GLenum pname, GLuint * params); +typedef void (GLAD_API_PTR *PFNGLGETTEXPARAMETERFVPROC)(GLenum target, GLenum pname, GLfloat * params); +typedef void (GLAD_API_PTR *PFNGLGETTEXPARAMETERIVPROC)(GLenum target, GLenum pname, GLint * params); +typedef void (GLAD_API_PTR *PFNGLGETTRANSFORMFEEDBACKVARYINGPROC)(GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLsizei * size, GLenum * type, GLchar * name); +typedef GLuint (GLAD_API_PTR *PFNGLGETUNIFORMBLOCKINDEXPROC)(GLuint program, const GLchar * uniformBlockName); +typedef void (GLAD_API_PTR *PFNGLGETUNIFORMINDICESPROC)(GLuint program, GLsizei uniformCount, const GLchar *const* uniformNames, GLuint * uniformIndices); +typedef GLint (GLAD_API_PTR *PFNGLGETUNIFORMLOCATIONPROC)(GLuint program, const GLchar * name); +typedef void (GLAD_API_PTR *PFNGLGETUNIFORMFVPROC)(GLuint program, GLint location, GLfloat * params); +typedef void (GLAD_API_PTR *PFNGLGETUNIFORMIVPROC)(GLuint program, GLint location, GLint * params); +typedef void (GLAD_API_PTR *PFNGLGETUNIFORMUIVPROC)(GLuint program, GLint location, GLuint * params); +typedef void (GLAD_API_PTR *PFNGLGETVERTEXATTRIBIIVPROC)(GLuint index, GLenum pname, GLint * params); +typedef void (GLAD_API_PTR *PFNGLGETVERTEXATTRIBIUIVPROC)(GLuint index, GLenum pname, GLuint * params); +typedef void (GLAD_API_PTR *PFNGLGETVERTEXATTRIBPOINTERVPROC)(GLuint index, GLenum pname, void ** pointer); +typedef void (GLAD_API_PTR *PFNGLGETVERTEXATTRIBDVPROC)(GLuint index, GLenum pname, GLdouble * params); +typedef void (GLAD_API_PTR *PFNGLGETVERTEXATTRIBFVPROC)(GLuint index, GLenum pname, GLfloat * params); +typedef void (GLAD_API_PTR *PFNGLGETVERTEXATTRIBIVPROC)(GLuint index, GLenum pname, GLint * params); +typedef void (GLAD_API_PTR *PFNGLHINTPROC)(GLenum target, GLenum mode); +typedef GLboolean (GLAD_API_PTR *PFNGLISBUFFERPROC)(GLuint buffer); +typedef GLboolean (GLAD_API_PTR *PFNGLISENABLEDPROC)(GLenum cap); +typedef GLboolean (GLAD_API_PTR *PFNGLISENABLEDIPROC)(GLenum target, GLuint index); +typedef GLboolean (GLAD_API_PTR *PFNGLISFRAMEBUFFERPROC)(GLuint framebuffer); +typedef GLboolean (GLAD_API_PTR *PFNGLISPROGRAMPROC)(GLuint program); +typedef GLboolean (GLAD_API_PTR *PFNGLISQUERYPROC)(GLuint id); +typedef GLboolean (GLAD_API_PTR *PFNGLISRENDERBUFFERPROC)(GLuint renderbuffer); +typedef GLboolean (GLAD_API_PTR *PFNGLISSAMPLERPROC)(GLuint sampler); +typedef GLboolean (GLAD_API_PTR *PFNGLISSHADERPROC)(GLuint shader); +typedef GLboolean (GLAD_API_PTR *PFNGLISSYNCPROC)(GLsync sync); +typedef GLboolean (GLAD_API_PTR *PFNGLISTEXTUREPROC)(GLuint texture); +typedef GLboolean (GLAD_API_PTR *PFNGLISVERTEXARRAYPROC)(GLuint array); +typedef void (GLAD_API_PTR *PFNGLLINEWIDTHPROC)(GLfloat width); +typedef void (GLAD_API_PTR *PFNGLLINKPROGRAMPROC)(GLuint program); +typedef void (GLAD_API_PTR *PFNGLLOGICOPPROC)(GLenum opcode); +typedef void * (GLAD_API_PTR *PFNGLMAPBUFFERPROC)(GLenum target, GLenum access); +typedef void * (GLAD_API_PTR *PFNGLMAPBUFFERRANGEPROC)(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access); +typedef void (GLAD_API_PTR *PFNGLMULTIDRAWARRAYSPROC)(GLenum mode, const GLint * first, const GLsizei * count, GLsizei drawcount); +typedef void (GLAD_API_PTR *PFNGLMULTIDRAWELEMENTSPROC)(GLenum mode, const GLsizei * count, GLenum type, const void *const* indices, GLsizei drawcount); +typedef void (GLAD_API_PTR *PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC)(GLenum mode, const GLsizei * count, GLenum type, const void *const* indices, GLsizei drawcount, const GLint * basevertex); +typedef void (GLAD_API_PTR *PFNGLOBJECTLABELPROC)(GLenum identifier, GLuint name, GLsizei length, const GLchar * label); +typedef void (GLAD_API_PTR *PFNGLOBJECTPTRLABELPROC)(const void * ptr, GLsizei length, const GLchar * label); +typedef void (GLAD_API_PTR *PFNGLPIXELSTOREFPROC)(GLenum pname, GLfloat param); +typedef void (GLAD_API_PTR *PFNGLPIXELSTOREIPROC)(GLenum pname, GLint param); +typedef void (GLAD_API_PTR *PFNGLPOINTPARAMETERFPROC)(GLenum pname, GLfloat param); +typedef void (GLAD_API_PTR *PFNGLPOINTPARAMETERFVPROC)(GLenum pname, const GLfloat * params); +typedef void (GLAD_API_PTR *PFNGLPOINTPARAMETERIPROC)(GLenum pname, GLint param); +typedef void (GLAD_API_PTR *PFNGLPOINTPARAMETERIVPROC)(GLenum pname, const GLint * params); +typedef void (GLAD_API_PTR *PFNGLPOINTSIZEPROC)(GLfloat size); +typedef void (GLAD_API_PTR *PFNGLPOLYGONMODEPROC)(GLenum face, GLenum mode); +typedef void (GLAD_API_PTR *PFNGLPOLYGONOFFSETPROC)(GLfloat factor, GLfloat units); +typedef void (GLAD_API_PTR *PFNGLPOPDEBUGGROUPPROC)(void); +typedef void (GLAD_API_PTR *PFNGLPRIMITIVERESTARTINDEXPROC)(GLuint index); +typedef void (GLAD_API_PTR *PFNGLPROVOKINGVERTEXPROC)(GLenum mode); +typedef void (GLAD_API_PTR *PFNGLPUSHDEBUGGROUPPROC)(GLenum source, GLuint id, GLsizei length, const GLchar * message); +typedef void (GLAD_API_PTR *PFNGLQUERYCOUNTERPROC)(GLuint id, GLenum target); +typedef void (GLAD_API_PTR *PFNGLREADBUFFERPROC)(GLenum src); +typedef void (GLAD_API_PTR *PFNGLREADPIXELSPROC)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void * pixels); +typedef void (GLAD_API_PTR *PFNGLRENDERBUFFERSTORAGEPROC)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height); +typedef void (GLAD_API_PTR *PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height); +typedef void (GLAD_API_PTR *PFNGLSAMPLECOVERAGEPROC)(GLfloat value, GLboolean invert); +typedef void (GLAD_API_PTR *PFNGLSAMPLEMASKIPROC)(GLuint maskNumber, GLbitfield mask); +typedef void (GLAD_API_PTR *PFNGLSAMPLERPARAMETERIIVPROC)(GLuint sampler, GLenum pname, const GLint * param); +typedef void (GLAD_API_PTR *PFNGLSAMPLERPARAMETERIUIVPROC)(GLuint sampler, GLenum pname, const GLuint * param); +typedef void (GLAD_API_PTR *PFNGLSAMPLERPARAMETERFPROC)(GLuint sampler, GLenum pname, GLfloat param); +typedef void (GLAD_API_PTR *PFNGLSAMPLERPARAMETERFVPROC)(GLuint sampler, GLenum pname, const GLfloat * param); +typedef void (GLAD_API_PTR *PFNGLSAMPLERPARAMETERIPROC)(GLuint sampler, GLenum pname, GLint param); +typedef void (GLAD_API_PTR *PFNGLSAMPLERPARAMETERIVPROC)(GLuint sampler, GLenum pname, const GLint * param); +typedef void (GLAD_API_PTR *PFNGLSCISSORPROC)(GLint x, GLint y, GLsizei width, GLsizei height); +typedef void (GLAD_API_PTR *PFNGLSHADERSOURCEPROC)(GLuint shader, GLsizei count, const GLchar *const* string, const GLint * length); +typedef void (GLAD_API_PTR *PFNGLSTENCILFUNCPROC)(GLenum func, GLint ref, GLuint mask); +typedef void (GLAD_API_PTR *PFNGLSTENCILFUNCSEPARATEPROC)(GLenum face, GLenum func, GLint ref, GLuint mask); +typedef void (GLAD_API_PTR *PFNGLSTENCILMASKPROC)(GLuint mask); +typedef void (GLAD_API_PTR *PFNGLSTENCILMASKSEPARATEPROC)(GLenum face, GLuint mask); +typedef void (GLAD_API_PTR *PFNGLSTENCILOPPROC)(GLenum fail, GLenum zfail, GLenum zpass); +typedef void (GLAD_API_PTR *PFNGLSTENCILOPSEPARATEPROC)(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass); +typedef void (GLAD_API_PTR *PFNGLTEXBUFFERPROC)(GLenum target, GLenum internalformat, GLuint buffer); +typedef void (GLAD_API_PTR *PFNGLTEXIMAGE1DPROC)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void * pixels); +typedef void (GLAD_API_PTR *PFNGLTEXIMAGE2DPROC)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void * pixels); +typedef void (GLAD_API_PTR *PFNGLTEXIMAGE2DMULTISAMPLEPROC)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations); +typedef void (GLAD_API_PTR *PFNGLTEXIMAGE3DPROC)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void * pixels); +typedef void (GLAD_API_PTR *PFNGLTEXIMAGE3DMULTISAMPLEPROC)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations); +typedef void (GLAD_API_PTR *PFNGLTEXPARAMETERIIVPROC)(GLenum target, GLenum pname, const GLint * params); +typedef void (GLAD_API_PTR *PFNGLTEXPARAMETERIUIVPROC)(GLenum target, GLenum pname, const GLuint * params); +typedef void (GLAD_API_PTR *PFNGLTEXPARAMETERFPROC)(GLenum target, GLenum pname, GLfloat param); +typedef void (GLAD_API_PTR *PFNGLTEXPARAMETERFVPROC)(GLenum target, GLenum pname, const GLfloat * params); +typedef void (GLAD_API_PTR *PFNGLTEXPARAMETERIPROC)(GLenum target, GLenum pname, GLint param); +typedef void (GLAD_API_PTR *PFNGLTEXPARAMETERIVPROC)(GLenum target, GLenum pname, const GLint * params); +typedef void (GLAD_API_PTR *PFNGLTEXSUBIMAGE1DPROC)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void * pixels); +typedef void (GLAD_API_PTR *PFNGLTEXSUBIMAGE2DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void * pixels); +typedef void (GLAD_API_PTR *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 (GLAD_API_PTR *PFNGLTRANSFORMFEEDBACKVARYINGSPROC)(GLuint program, GLsizei count, const GLchar *const* varyings, GLenum bufferMode); +typedef void (GLAD_API_PTR *PFNGLUNIFORM1FPROC)(GLint location, GLfloat v0); +typedef void (GLAD_API_PTR *PFNGLUNIFORM1FVPROC)(GLint location, GLsizei count, const GLfloat * value); +typedef void (GLAD_API_PTR *PFNGLUNIFORM1IPROC)(GLint location, GLint v0); +typedef void (GLAD_API_PTR *PFNGLUNIFORM1IVPROC)(GLint location, GLsizei count, const GLint * value); +typedef void (GLAD_API_PTR *PFNGLUNIFORM1UIPROC)(GLint location, GLuint v0); +typedef void (GLAD_API_PTR *PFNGLUNIFORM1UIVPROC)(GLint location, GLsizei count, const GLuint * value); +typedef void (GLAD_API_PTR *PFNGLUNIFORM2FPROC)(GLint location, GLfloat v0, GLfloat v1); +typedef void (GLAD_API_PTR *PFNGLUNIFORM2FVPROC)(GLint location, GLsizei count, const GLfloat * value); +typedef void (GLAD_API_PTR *PFNGLUNIFORM2IPROC)(GLint location, GLint v0, GLint v1); +typedef void (GLAD_API_PTR *PFNGLUNIFORM2IVPROC)(GLint location, GLsizei count, const GLint * value); +typedef void (GLAD_API_PTR *PFNGLUNIFORM2UIPROC)(GLint location, GLuint v0, GLuint v1); +typedef void (GLAD_API_PTR *PFNGLUNIFORM2UIVPROC)(GLint location, GLsizei count, const GLuint * value); +typedef void (GLAD_API_PTR *PFNGLUNIFORM3FPROC)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2); +typedef void (GLAD_API_PTR *PFNGLUNIFORM3FVPROC)(GLint location, GLsizei count, const GLfloat * value); +typedef void (GLAD_API_PTR *PFNGLUNIFORM3IPROC)(GLint location, GLint v0, GLint v1, GLint v2); +typedef void (GLAD_API_PTR *PFNGLUNIFORM3IVPROC)(GLint location, GLsizei count, const GLint * value); +typedef void (GLAD_API_PTR *PFNGLUNIFORM3UIPROC)(GLint location, GLuint v0, GLuint v1, GLuint v2); +typedef void (GLAD_API_PTR *PFNGLUNIFORM3UIVPROC)(GLint location, GLsizei count, const GLuint * value); +typedef void (GLAD_API_PTR *PFNGLUNIFORM4FPROC)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); +typedef void (GLAD_API_PTR *PFNGLUNIFORM4FVPROC)(GLint location, GLsizei count, const GLfloat * value); +typedef void (GLAD_API_PTR *PFNGLUNIFORM4IPROC)(GLint location, GLint v0, GLint v1, GLint v2, GLint v3); +typedef void (GLAD_API_PTR *PFNGLUNIFORM4IVPROC)(GLint location, GLsizei count, const GLint * value); +typedef void (GLAD_API_PTR *PFNGLUNIFORM4UIPROC)(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3); +typedef void (GLAD_API_PTR *PFNGLUNIFORM4UIVPROC)(GLint location, GLsizei count, const GLuint * value); +typedef void (GLAD_API_PTR *PFNGLUNIFORMBLOCKBINDINGPROC)(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding); +typedef void (GLAD_API_PTR *PFNGLUNIFORMMATRIX2FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value); +typedef void (GLAD_API_PTR *PFNGLUNIFORMMATRIX2X3FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value); +typedef void (GLAD_API_PTR *PFNGLUNIFORMMATRIX2X4FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value); +typedef void (GLAD_API_PTR *PFNGLUNIFORMMATRIX3FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value); +typedef void (GLAD_API_PTR *PFNGLUNIFORMMATRIX3X2FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value); +typedef void (GLAD_API_PTR *PFNGLUNIFORMMATRIX3X4FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value); +typedef void (GLAD_API_PTR *PFNGLUNIFORMMATRIX4FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value); +typedef void (GLAD_API_PTR *PFNGLUNIFORMMATRIX4X2FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value); +typedef void (GLAD_API_PTR *PFNGLUNIFORMMATRIX4X3FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value); +typedef GLboolean (GLAD_API_PTR *PFNGLUNMAPBUFFERPROC)(GLenum target); +typedef void (GLAD_API_PTR *PFNGLUSEPROGRAMPROC)(GLuint program); +typedef void (GLAD_API_PTR *PFNGLVALIDATEPROGRAMPROC)(GLuint program); +typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB1DPROC)(GLuint index, GLdouble x); +typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB1DVPROC)(GLuint index, const GLdouble * v); +typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB1FPROC)(GLuint index, GLfloat x); +typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB1FVPROC)(GLuint index, const GLfloat * v); +typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB1SPROC)(GLuint index, GLshort x); +typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB1SVPROC)(GLuint index, const GLshort * v); +typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB2DPROC)(GLuint index, GLdouble x, GLdouble y); +typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB2DVPROC)(GLuint index, const GLdouble * v); +typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB2FPROC)(GLuint index, GLfloat x, GLfloat y); +typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB2FVPROC)(GLuint index, const GLfloat * v); +typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB2SPROC)(GLuint index, GLshort x, GLshort y); +typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB2SVPROC)(GLuint index, const GLshort * v); +typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB3DPROC)(GLuint index, GLdouble x, GLdouble y, GLdouble z); +typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB3DVPROC)(GLuint index, const GLdouble * v); +typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB3FPROC)(GLuint index, GLfloat x, GLfloat y, GLfloat z); +typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB3FVPROC)(GLuint index, const GLfloat * v); +typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB3SPROC)(GLuint index, GLshort x, GLshort y, GLshort z); +typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB3SVPROC)(GLuint index, const GLshort * v); +typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4NBVPROC)(GLuint index, const GLbyte * v); +typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4NIVPROC)(GLuint index, const GLint * v); +typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4NSVPROC)(GLuint index, const GLshort * v); +typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4NUBPROC)(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w); +typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4NUBVPROC)(GLuint index, const GLubyte * v); +typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4NUIVPROC)(GLuint index, const GLuint * v); +typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4NUSVPROC)(GLuint index, const GLushort * v); +typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4BVPROC)(GLuint index, const GLbyte * v); +typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4DPROC)(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4DVPROC)(GLuint index, const GLdouble * v); +typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4FPROC)(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4FVPROC)(GLuint index, const GLfloat * v); +typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4IVPROC)(GLuint index, const GLint * v); +typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4SPROC)(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w); +typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4SVPROC)(GLuint index, const GLshort * v); +typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4UBVPROC)(GLuint index, const GLubyte * v); +typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4UIVPROC)(GLuint index, const GLuint * v); +typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4USVPROC)(GLuint index, const GLushort * v); +typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBDIVISORPROC)(GLuint index, GLuint divisor); +typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBI1IPROC)(GLuint index, GLint x); +typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBI1IVPROC)(GLuint index, const GLint * v); +typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBI1UIPROC)(GLuint index, GLuint x); +typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBI1UIVPROC)(GLuint index, const GLuint * v); +typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBI2IPROC)(GLuint index, GLint x, GLint y); +typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBI2IVPROC)(GLuint index, const GLint * v); +typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBI2UIPROC)(GLuint index, GLuint x, GLuint y); +typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBI2UIVPROC)(GLuint index, const GLuint * v); +typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBI3IPROC)(GLuint index, GLint x, GLint y, GLint z); +typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBI3IVPROC)(GLuint index, const GLint * v); +typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBI3UIPROC)(GLuint index, GLuint x, GLuint y, GLuint z); +typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBI3UIVPROC)(GLuint index, const GLuint * v); +typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBI4BVPROC)(GLuint index, const GLbyte * v); +typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBI4IPROC)(GLuint index, GLint x, GLint y, GLint z, GLint w); +typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBI4IVPROC)(GLuint index, const GLint * v); +typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBI4SVPROC)(GLuint index, const GLshort * v); +typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBI4UBVPROC)(GLuint index, const GLubyte * v); +typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBI4UIPROC)(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w); +typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBI4UIVPROC)(GLuint index, const GLuint * v); +typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBI4USVPROC)(GLuint index, const GLushort * v); +typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBIPOINTERPROC)(GLuint index, GLint size, GLenum type, GLsizei stride, const void * pointer); +typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBP1UIPROC)(GLuint index, GLenum type, GLboolean normalized, GLuint value); +typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBP1UIVPROC)(GLuint index, GLenum type, GLboolean normalized, const GLuint * value); +typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBP2UIPROC)(GLuint index, GLenum type, GLboolean normalized, GLuint value); +typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBP2UIVPROC)(GLuint index, GLenum type, GLboolean normalized, const GLuint * value); +typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBP3UIPROC)(GLuint index, GLenum type, GLboolean normalized, GLuint value); +typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBP3UIVPROC)(GLuint index, GLenum type, GLboolean normalized, const GLuint * value); +typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBP4UIPROC)(GLuint index, GLenum type, GLboolean normalized, GLuint value); +typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBP4UIVPROC)(GLuint index, GLenum type, GLboolean normalized, const GLuint * value); +typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBPOINTERPROC)(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void * pointer); +typedef void (GLAD_API_PTR *PFNGLVIEWPORTPROC)(GLint x, GLint y, GLsizei width, GLsizei height); +typedef void (GLAD_API_PTR *PFNGLWAITSYNCPROC)(GLsync sync, GLbitfield flags, GLuint64 timeout); + +GLAD_API_CALL PFNGLACTIVETEXTUREPROC glad_glActiveTexture; +#define glActiveTexture glad_glActiveTexture +GLAD_API_CALL PFNGLATTACHSHADERPROC glad_glAttachShader; +#define glAttachShader glad_glAttachShader +GLAD_API_CALL PFNGLBEGINCONDITIONALRENDERPROC glad_glBeginConditionalRender; +#define glBeginConditionalRender glad_glBeginConditionalRender +GLAD_API_CALL PFNGLBEGINQUERYPROC glad_glBeginQuery; +#define glBeginQuery glad_glBeginQuery +GLAD_API_CALL PFNGLBEGINTRANSFORMFEEDBACKPROC glad_glBeginTransformFeedback; +#define glBeginTransformFeedback glad_glBeginTransformFeedback +GLAD_API_CALL PFNGLBINDATTRIBLOCATIONPROC glad_glBindAttribLocation; +#define glBindAttribLocation glad_glBindAttribLocation +GLAD_API_CALL PFNGLBINDBUFFERPROC glad_glBindBuffer; +#define glBindBuffer glad_glBindBuffer +GLAD_API_CALL PFNGLBINDBUFFERBASEPROC glad_glBindBufferBase; +#define glBindBufferBase glad_glBindBufferBase +GLAD_API_CALL PFNGLBINDBUFFERRANGEPROC glad_glBindBufferRange; +#define glBindBufferRange glad_glBindBufferRange +GLAD_API_CALL PFNGLBINDFRAGDATALOCATIONPROC glad_glBindFragDataLocation; +#define glBindFragDataLocation glad_glBindFragDataLocation +GLAD_API_CALL PFNGLBINDFRAGDATALOCATIONINDEXEDPROC glad_glBindFragDataLocationIndexed; +#define glBindFragDataLocationIndexed glad_glBindFragDataLocationIndexed +GLAD_API_CALL PFNGLBINDFRAMEBUFFERPROC glad_glBindFramebuffer; +#define glBindFramebuffer glad_glBindFramebuffer +GLAD_API_CALL PFNGLBINDRENDERBUFFERPROC glad_glBindRenderbuffer; +#define glBindRenderbuffer glad_glBindRenderbuffer +GLAD_API_CALL PFNGLBINDSAMPLERPROC glad_glBindSampler; +#define glBindSampler glad_glBindSampler +GLAD_API_CALL PFNGLBINDTEXTUREPROC glad_glBindTexture; +#define glBindTexture glad_glBindTexture +GLAD_API_CALL PFNGLBINDVERTEXARRAYPROC glad_glBindVertexArray; +#define glBindVertexArray glad_glBindVertexArray +GLAD_API_CALL PFNGLBLENDCOLORPROC glad_glBlendColor; +#define glBlendColor glad_glBlendColor +GLAD_API_CALL PFNGLBLENDEQUATIONPROC glad_glBlendEquation; +#define glBlendEquation glad_glBlendEquation +GLAD_API_CALL PFNGLBLENDEQUATIONSEPARATEPROC glad_glBlendEquationSeparate; +#define glBlendEquationSeparate glad_glBlendEquationSeparate +GLAD_API_CALL PFNGLBLENDFUNCPROC glad_glBlendFunc; +#define glBlendFunc glad_glBlendFunc +GLAD_API_CALL PFNGLBLENDFUNCSEPARATEPROC glad_glBlendFuncSeparate; +#define glBlendFuncSeparate glad_glBlendFuncSeparate +GLAD_API_CALL PFNGLBLITFRAMEBUFFERPROC glad_glBlitFramebuffer; +#define glBlitFramebuffer glad_glBlitFramebuffer +GLAD_API_CALL PFNGLBUFFERDATAPROC glad_glBufferData; +#define glBufferData glad_glBufferData +GLAD_API_CALL PFNGLBUFFERSUBDATAPROC glad_glBufferSubData; +#define glBufferSubData glad_glBufferSubData +GLAD_API_CALL PFNGLCHECKFRAMEBUFFERSTATUSPROC glad_glCheckFramebufferStatus; +#define glCheckFramebufferStatus glad_glCheckFramebufferStatus +GLAD_API_CALL PFNGLCLAMPCOLORPROC glad_glClampColor; +#define glClampColor glad_glClampColor +GLAD_API_CALL PFNGLCLEARPROC glad_glClear; +#define glClear glad_glClear +GLAD_API_CALL PFNGLCLEARBUFFERFIPROC glad_glClearBufferfi; +#define glClearBufferfi glad_glClearBufferfi +GLAD_API_CALL PFNGLCLEARBUFFERFVPROC glad_glClearBufferfv; +#define glClearBufferfv glad_glClearBufferfv +GLAD_API_CALL PFNGLCLEARBUFFERIVPROC glad_glClearBufferiv; +#define glClearBufferiv glad_glClearBufferiv +GLAD_API_CALL PFNGLCLEARBUFFERUIVPROC glad_glClearBufferuiv; +#define glClearBufferuiv glad_glClearBufferuiv +GLAD_API_CALL PFNGLCLEARCOLORPROC glad_glClearColor; +#define glClearColor glad_glClearColor +GLAD_API_CALL PFNGLCLEARDEPTHPROC glad_glClearDepth; +#define glClearDepth glad_glClearDepth +GLAD_API_CALL PFNGLCLEARSTENCILPROC glad_glClearStencil; +#define glClearStencil glad_glClearStencil +GLAD_API_CALL PFNGLCLIENTWAITSYNCPROC glad_glClientWaitSync; +#define glClientWaitSync glad_glClientWaitSync +GLAD_API_CALL PFNGLCOLORMASKPROC glad_glColorMask; +#define glColorMask glad_glColorMask +GLAD_API_CALL PFNGLCOLORMASKIPROC glad_glColorMaski; +#define glColorMaski glad_glColorMaski +GLAD_API_CALL PFNGLCOMPILESHADERPROC glad_glCompileShader; +#define glCompileShader glad_glCompileShader +GLAD_API_CALL PFNGLCOMPRESSEDTEXIMAGE1DPROC glad_glCompressedTexImage1D; +#define glCompressedTexImage1D glad_glCompressedTexImage1D +GLAD_API_CALL PFNGLCOMPRESSEDTEXIMAGE2DPROC glad_glCompressedTexImage2D; +#define glCompressedTexImage2D glad_glCompressedTexImage2D +GLAD_API_CALL PFNGLCOMPRESSEDTEXIMAGE3DPROC glad_glCompressedTexImage3D; +#define glCompressedTexImage3D glad_glCompressedTexImage3D +GLAD_API_CALL PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC glad_glCompressedTexSubImage1D; +#define glCompressedTexSubImage1D glad_glCompressedTexSubImage1D +GLAD_API_CALL PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC glad_glCompressedTexSubImage2D; +#define glCompressedTexSubImage2D glad_glCompressedTexSubImage2D +GLAD_API_CALL PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC glad_glCompressedTexSubImage3D; +#define glCompressedTexSubImage3D glad_glCompressedTexSubImage3D +GLAD_API_CALL PFNGLCOPYBUFFERSUBDATAPROC glad_glCopyBufferSubData; +#define glCopyBufferSubData glad_glCopyBufferSubData +GLAD_API_CALL PFNGLCOPYTEXIMAGE1DPROC glad_glCopyTexImage1D; +#define glCopyTexImage1D glad_glCopyTexImage1D +GLAD_API_CALL PFNGLCOPYTEXIMAGE2DPROC glad_glCopyTexImage2D; +#define glCopyTexImage2D glad_glCopyTexImage2D +GLAD_API_CALL PFNGLCOPYTEXSUBIMAGE1DPROC glad_glCopyTexSubImage1D; +#define glCopyTexSubImage1D glad_glCopyTexSubImage1D +GLAD_API_CALL PFNGLCOPYTEXSUBIMAGE2DPROC glad_glCopyTexSubImage2D; +#define glCopyTexSubImage2D glad_glCopyTexSubImage2D +GLAD_API_CALL PFNGLCOPYTEXSUBIMAGE3DPROC glad_glCopyTexSubImage3D; +#define glCopyTexSubImage3D glad_glCopyTexSubImage3D +GLAD_API_CALL PFNGLCREATEPROGRAMPROC glad_glCreateProgram; +#define glCreateProgram glad_glCreateProgram +GLAD_API_CALL PFNGLCREATESHADERPROC glad_glCreateShader; +#define glCreateShader glad_glCreateShader +GLAD_API_CALL PFNGLCULLFACEPROC glad_glCullFace; +#define glCullFace glad_glCullFace +GLAD_API_CALL PFNGLDEBUGMESSAGECALLBACKPROC glad_glDebugMessageCallback; +#define glDebugMessageCallback glad_glDebugMessageCallback +GLAD_API_CALL PFNGLDEBUGMESSAGECONTROLPROC glad_glDebugMessageControl; +#define glDebugMessageControl glad_glDebugMessageControl +GLAD_API_CALL PFNGLDEBUGMESSAGEINSERTPROC glad_glDebugMessageInsert; +#define glDebugMessageInsert glad_glDebugMessageInsert +GLAD_API_CALL PFNGLDELETEBUFFERSPROC glad_glDeleteBuffers; +#define glDeleteBuffers glad_glDeleteBuffers +GLAD_API_CALL PFNGLDELETEFRAMEBUFFERSPROC glad_glDeleteFramebuffers; +#define glDeleteFramebuffers glad_glDeleteFramebuffers +GLAD_API_CALL PFNGLDELETEPROGRAMPROC glad_glDeleteProgram; +#define glDeleteProgram glad_glDeleteProgram +GLAD_API_CALL PFNGLDELETEQUERIESPROC glad_glDeleteQueries; +#define glDeleteQueries glad_glDeleteQueries +GLAD_API_CALL PFNGLDELETERENDERBUFFERSPROC glad_glDeleteRenderbuffers; +#define glDeleteRenderbuffers glad_glDeleteRenderbuffers +GLAD_API_CALL PFNGLDELETESAMPLERSPROC glad_glDeleteSamplers; +#define glDeleteSamplers glad_glDeleteSamplers +GLAD_API_CALL PFNGLDELETESHADERPROC glad_glDeleteShader; +#define glDeleteShader glad_glDeleteShader +GLAD_API_CALL PFNGLDELETESYNCPROC glad_glDeleteSync; +#define glDeleteSync glad_glDeleteSync +GLAD_API_CALL PFNGLDELETETEXTURESPROC glad_glDeleteTextures; +#define glDeleteTextures glad_glDeleteTextures +GLAD_API_CALL PFNGLDELETEVERTEXARRAYSPROC glad_glDeleteVertexArrays; +#define glDeleteVertexArrays glad_glDeleteVertexArrays +GLAD_API_CALL PFNGLDEPTHFUNCPROC glad_glDepthFunc; +#define glDepthFunc glad_glDepthFunc +GLAD_API_CALL PFNGLDEPTHMASKPROC glad_glDepthMask; +#define glDepthMask glad_glDepthMask +GLAD_API_CALL PFNGLDEPTHRANGEPROC glad_glDepthRange; +#define glDepthRange glad_glDepthRange +GLAD_API_CALL PFNGLDETACHSHADERPROC glad_glDetachShader; +#define glDetachShader glad_glDetachShader +GLAD_API_CALL PFNGLDISABLEPROC glad_glDisable; +#define glDisable glad_glDisable +GLAD_API_CALL PFNGLDISABLEVERTEXATTRIBARRAYPROC glad_glDisableVertexAttribArray; +#define glDisableVertexAttribArray glad_glDisableVertexAttribArray +GLAD_API_CALL PFNGLDISABLEIPROC glad_glDisablei; +#define glDisablei glad_glDisablei +GLAD_API_CALL PFNGLDRAWARRAYSPROC glad_glDrawArrays; +#define glDrawArrays glad_glDrawArrays +GLAD_API_CALL PFNGLDRAWARRAYSINSTANCEDPROC glad_glDrawArraysInstanced; +#define glDrawArraysInstanced glad_glDrawArraysInstanced +GLAD_API_CALL PFNGLDRAWBUFFERPROC glad_glDrawBuffer; +#define glDrawBuffer glad_glDrawBuffer +GLAD_API_CALL PFNGLDRAWBUFFERSPROC glad_glDrawBuffers; +#define glDrawBuffers glad_glDrawBuffers +GLAD_API_CALL PFNGLDRAWELEMENTSPROC glad_glDrawElements; +#define glDrawElements glad_glDrawElements +GLAD_API_CALL PFNGLDRAWELEMENTSBASEVERTEXPROC glad_glDrawElementsBaseVertex; +#define glDrawElementsBaseVertex glad_glDrawElementsBaseVertex +GLAD_API_CALL PFNGLDRAWELEMENTSINSTANCEDPROC glad_glDrawElementsInstanced; +#define glDrawElementsInstanced glad_glDrawElementsInstanced +GLAD_API_CALL PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC glad_glDrawElementsInstancedBaseVertex; +#define glDrawElementsInstancedBaseVertex glad_glDrawElementsInstancedBaseVertex +GLAD_API_CALL PFNGLDRAWRANGEELEMENTSPROC glad_glDrawRangeElements; +#define glDrawRangeElements glad_glDrawRangeElements +GLAD_API_CALL PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC glad_glDrawRangeElementsBaseVertex; +#define glDrawRangeElementsBaseVertex glad_glDrawRangeElementsBaseVertex +GLAD_API_CALL PFNGLENABLEPROC glad_glEnable; +#define glEnable glad_glEnable +GLAD_API_CALL PFNGLENABLEVERTEXATTRIBARRAYPROC glad_glEnableVertexAttribArray; +#define glEnableVertexAttribArray glad_glEnableVertexAttribArray +GLAD_API_CALL PFNGLENABLEIPROC glad_glEnablei; +#define glEnablei glad_glEnablei +GLAD_API_CALL PFNGLENDCONDITIONALRENDERPROC glad_glEndConditionalRender; +#define glEndConditionalRender glad_glEndConditionalRender +GLAD_API_CALL PFNGLENDQUERYPROC glad_glEndQuery; +#define glEndQuery glad_glEndQuery +GLAD_API_CALL PFNGLENDTRANSFORMFEEDBACKPROC glad_glEndTransformFeedback; +#define glEndTransformFeedback glad_glEndTransformFeedback +GLAD_API_CALL PFNGLFENCESYNCPROC glad_glFenceSync; +#define glFenceSync glad_glFenceSync +GLAD_API_CALL PFNGLFINISHPROC glad_glFinish; +#define glFinish glad_glFinish +GLAD_API_CALL PFNGLFLUSHPROC glad_glFlush; +#define glFlush glad_glFlush +GLAD_API_CALL PFNGLFLUSHMAPPEDBUFFERRANGEPROC glad_glFlushMappedBufferRange; +#define glFlushMappedBufferRange glad_glFlushMappedBufferRange +GLAD_API_CALL PFNGLFRAMEBUFFERRENDERBUFFERPROC glad_glFramebufferRenderbuffer; +#define glFramebufferRenderbuffer glad_glFramebufferRenderbuffer +GLAD_API_CALL PFNGLFRAMEBUFFERTEXTUREPROC glad_glFramebufferTexture; +#define glFramebufferTexture glad_glFramebufferTexture +GLAD_API_CALL PFNGLFRAMEBUFFERTEXTURE1DPROC glad_glFramebufferTexture1D; +#define glFramebufferTexture1D glad_glFramebufferTexture1D +GLAD_API_CALL PFNGLFRAMEBUFFERTEXTURE2DPROC glad_glFramebufferTexture2D; +#define glFramebufferTexture2D glad_glFramebufferTexture2D +GLAD_API_CALL PFNGLFRAMEBUFFERTEXTURE3DPROC glad_glFramebufferTexture3D; +#define glFramebufferTexture3D glad_glFramebufferTexture3D +GLAD_API_CALL PFNGLFRAMEBUFFERTEXTURELAYERPROC glad_glFramebufferTextureLayer; +#define glFramebufferTextureLayer glad_glFramebufferTextureLayer +GLAD_API_CALL PFNGLFRONTFACEPROC glad_glFrontFace; +#define glFrontFace glad_glFrontFace +GLAD_API_CALL PFNGLGENBUFFERSPROC glad_glGenBuffers; +#define glGenBuffers glad_glGenBuffers +GLAD_API_CALL PFNGLGENFRAMEBUFFERSPROC glad_glGenFramebuffers; +#define glGenFramebuffers glad_glGenFramebuffers +GLAD_API_CALL PFNGLGENQUERIESPROC glad_glGenQueries; +#define glGenQueries glad_glGenQueries +GLAD_API_CALL PFNGLGENRENDERBUFFERSPROC glad_glGenRenderbuffers; +#define glGenRenderbuffers glad_glGenRenderbuffers +GLAD_API_CALL PFNGLGENSAMPLERSPROC glad_glGenSamplers; +#define glGenSamplers glad_glGenSamplers +GLAD_API_CALL PFNGLGENTEXTURESPROC glad_glGenTextures; +#define glGenTextures glad_glGenTextures +GLAD_API_CALL PFNGLGENVERTEXARRAYSPROC glad_glGenVertexArrays; +#define glGenVertexArrays glad_glGenVertexArrays +GLAD_API_CALL PFNGLGENERATEMIPMAPPROC glad_glGenerateMipmap; +#define glGenerateMipmap glad_glGenerateMipmap +GLAD_API_CALL PFNGLGETACTIVEATTRIBPROC glad_glGetActiveAttrib; +#define glGetActiveAttrib glad_glGetActiveAttrib +GLAD_API_CALL PFNGLGETACTIVEUNIFORMPROC glad_glGetActiveUniform; +#define glGetActiveUniform glad_glGetActiveUniform +GLAD_API_CALL PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC glad_glGetActiveUniformBlockName; +#define glGetActiveUniformBlockName glad_glGetActiveUniformBlockName +GLAD_API_CALL PFNGLGETACTIVEUNIFORMBLOCKIVPROC glad_glGetActiveUniformBlockiv; +#define glGetActiveUniformBlockiv glad_glGetActiveUniformBlockiv +GLAD_API_CALL PFNGLGETACTIVEUNIFORMNAMEPROC glad_glGetActiveUniformName; +#define glGetActiveUniformName glad_glGetActiveUniformName +GLAD_API_CALL PFNGLGETACTIVEUNIFORMSIVPROC glad_glGetActiveUniformsiv; +#define glGetActiveUniformsiv glad_glGetActiveUniformsiv +GLAD_API_CALL PFNGLGETATTACHEDSHADERSPROC glad_glGetAttachedShaders; +#define glGetAttachedShaders glad_glGetAttachedShaders +GLAD_API_CALL PFNGLGETATTRIBLOCATIONPROC glad_glGetAttribLocation; +#define glGetAttribLocation glad_glGetAttribLocation +GLAD_API_CALL PFNGLGETBOOLEANI_VPROC glad_glGetBooleani_v; +#define glGetBooleani_v glad_glGetBooleani_v +GLAD_API_CALL PFNGLGETBOOLEANVPROC glad_glGetBooleanv; +#define glGetBooleanv glad_glGetBooleanv +GLAD_API_CALL PFNGLGETBUFFERPARAMETERI64VPROC glad_glGetBufferParameteri64v; +#define glGetBufferParameteri64v glad_glGetBufferParameteri64v +GLAD_API_CALL PFNGLGETBUFFERPARAMETERIVPROC glad_glGetBufferParameteriv; +#define glGetBufferParameteriv glad_glGetBufferParameteriv +GLAD_API_CALL PFNGLGETBUFFERPOINTERVPROC glad_glGetBufferPointerv; +#define glGetBufferPointerv glad_glGetBufferPointerv +GLAD_API_CALL PFNGLGETBUFFERSUBDATAPROC glad_glGetBufferSubData; +#define glGetBufferSubData glad_glGetBufferSubData +GLAD_API_CALL PFNGLGETCOMPRESSEDTEXIMAGEPROC glad_glGetCompressedTexImage; +#define glGetCompressedTexImage glad_glGetCompressedTexImage +GLAD_API_CALL PFNGLGETDEBUGMESSAGELOGPROC glad_glGetDebugMessageLog; +#define glGetDebugMessageLog glad_glGetDebugMessageLog +GLAD_API_CALL PFNGLGETDOUBLEVPROC glad_glGetDoublev; +#define glGetDoublev glad_glGetDoublev +GLAD_API_CALL PFNGLGETERRORPROC glad_glGetError; +#define glGetError glad_glGetError +GLAD_API_CALL PFNGLGETFLOATVPROC glad_glGetFloatv; +#define glGetFloatv glad_glGetFloatv +GLAD_API_CALL PFNGLGETFRAGDATAINDEXPROC glad_glGetFragDataIndex; +#define glGetFragDataIndex glad_glGetFragDataIndex +GLAD_API_CALL PFNGLGETFRAGDATALOCATIONPROC glad_glGetFragDataLocation; +#define glGetFragDataLocation glad_glGetFragDataLocation +GLAD_API_CALL PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC glad_glGetFramebufferAttachmentParameteriv; +#define glGetFramebufferAttachmentParameteriv glad_glGetFramebufferAttachmentParameteriv +GLAD_API_CALL PFNGLGETINTEGER64I_VPROC glad_glGetInteger64i_v; +#define glGetInteger64i_v glad_glGetInteger64i_v +GLAD_API_CALL PFNGLGETINTEGER64VPROC glad_glGetInteger64v; +#define glGetInteger64v glad_glGetInteger64v +GLAD_API_CALL PFNGLGETINTEGERI_VPROC glad_glGetIntegeri_v; +#define glGetIntegeri_v glad_glGetIntegeri_v +GLAD_API_CALL PFNGLGETINTEGERVPROC glad_glGetIntegerv; +#define glGetIntegerv glad_glGetIntegerv +GLAD_API_CALL PFNGLGETMULTISAMPLEFVPROC glad_glGetMultisamplefv; +#define glGetMultisamplefv glad_glGetMultisamplefv +GLAD_API_CALL PFNGLGETOBJECTLABELPROC glad_glGetObjectLabel; +#define glGetObjectLabel glad_glGetObjectLabel +GLAD_API_CALL PFNGLGETOBJECTPTRLABELPROC glad_glGetObjectPtrLabel; +#define glGetObjectPtrLabel glad_glGetObjectPtrLabel +GLAD_API_CALL PFNGLGETPOINTERVPROC glad_glGetPointerv; +#define glGetPointerv glad_glGetPointerv +GLAD_API_CALL PFNGLGETPROGRAMINFOLOGPROC glad_glGetProgramInfoLog; +#define glGetProgramInfoLog glad_glGetProgramInfoLog +GLAD_API_CALL PFNGLGETPROGRAMIVPROC glad_glGetProgramiv; +#define glGetProgramiv glad_glGetProgramiv +GLAD_API_CALL PFNGLGETQUERYOBJECTI64VPROC glad_glGetQueryObjecti64v; +#define glGetQueryObjecti64v glad_glGetQueryObjecti64v +GLAD_API_CALL PFNGLGETQUERYOBJECTIVPROC glad_glGetQueryObjectiv; +#define glGetQueryObjectiv glad_glGetQueryObjectiv +GLAD_API_CALL PFNGLGETQUERYOBJECTUI64VPROC glad_glGetQueryObjectui64v; +#define glGetQueryObjectui64v glad_glGetQueryObjectui64v +GLAD_API_CALL PFNGLGETQUERYOBJECTUIVPROC glad_glGetQueryObjectuiv; +#define glGetQueryObjectuiv glad_glGetQueryObjectuiv +GLAD_API_CALL PFNGLGETQUERYIVPROC glad_glGetQueryiv; +#define glGetQueryiv glad_glGetQueryiv +GLAD_API_CALL PFNGLGETRENDERBUFFERPARAMETERIVPROC glad_glGetRenderbufferParameteriv; +#define glGetRenderbufferParameteriv glad_glGetRenderbufferParameteriv +GLAD_API_CALL PFNGLGETSAMPLERPARAMETERIIVPROC glad_glGetSamplerParameterIiv; +#define glGetSamplerParameterIiv glad_glGetSamplerParameterIiv +GLAD_API_CALL PFNGLGETSAMPLERPARAMETERIUIVPROC glad_glGetSamplerParameterIuiv; +#define glGetSamplerParameterIuiv glad_glGetSamplerParameterIuiv +GLAD_API_CALL PFNGLGETSAMPLERPARAMETERFVPROC glad_glGetSamplerParameterfv; +#define glGetSamplerParameterfv glad_glGetSamplerParameterfv +GLAD_API_CALL PFNGLGETSAMPLERPARAMETERIVPROC glad_glGetSamplerParameteriv; +#define glGetSamplerParameteriv glad_glGetSamplerParameteriv +GLAD_API_CALL PFNGLGETSHADERINFOLOGPROC glad_glGetShaderInfoLog; +#define glGetShaderInfoLog glad_glGetShaderInfoLog +GLAD_API_CALL PFNGLGETSHADERSOURCEPROC glad_glGetShaderSource; +#define glGetShaderSource glad_glGetShaderSource +GLAD_API_CALL PFNGLGETSHADERIVPROC glad_glGetShaderiv; +#define glGetShaderiv glad_glGetShaderiv +GLAD_API_CALL PFNGLGETSTRINGPROC glad_glGetString; +#define glGetString glad_glGetString +GLAD_API_CALL PFNGLGETSTRINGIPROC glad_glGetStringi; +#define glGetStringi glad_glGetStringi +GLAD_API_CALL PFNGLGETSYNCIVPROC glad_glGetSynciv; +#define glGetSynciv glad_glGetSynciv +GLAD_API_CALL PFNGLGETTEXIMAGEPROC glad_glGetTexImage; +#define glGetTexImage glad_glGetTexImage +GLAD_API_CALL PFNGLGETTEXLEVELPARAMETERFVPROC glad_glGetTexLevelParameterfv; +#define glGetTexLevelParameterfv glad_glGetTexLevelParameterfv +GLAD_API_CALL PFNGLGETTEXLEVELPARAMETERIVPROC glad_glGetTexLevelParameteriv; +#define glGetTexLevelParameteriv glad_glGetTexLevelParameteriv +GLAD_API_CALL PFNGLGETTEXPARAMETERIIVPROC glad_glGetTexParameterIiv; +#define glGetTexParameterIiv glad_glGetTexParameterIiv +GLAD_API_CALL PFNGLGETTEXPARAMETERIUIVPROC glad_glGetTexParameterIuiv; +#define glGetTexParameterIuiv glad_glGetTexParameterIuiv +GLAD_API_CALL PFNGLGETTEXPARAMETERFVPROC glad_glGetTexParameterfv; +#define glGetTexParameterfv glad_glGetTexParameterfv +GLAD_API_CALL PFNGLGETTEXPARAMETERIVPROC glad_glGetTexParameteriv; +#define glGetTexParameteriv glad_glGetTexParameteriv +GLAD_API_CALL PFNGLGETTRANSFORMFEEDBACKVARYINGPROC glad_glGetTransformFeedbackVarying; +#define glGetTransformFeedbackVarying glad_glGetTransformFeedbackVarying +GLAD_API_CALL PFNGLGETUNIFORMBLOCKINDEXPROC glad_glGetUniformBlockIndex; +#define glGetUniformBlockIndex glad_glGetUniformBlockIndex +GLAD_API_CALL PFNGLGETUNIFORMINDICESPROC glad_glGetUniformIndices; +#define glGetUniformIndices glad_glGetUniformIndices +GLAD_API_CALL PFNGLGETUNIFORMLOCATIONPROC glad_glGetUniformLocation; +#define glGetUniformLocation glad_glGetUniformLocation +GLAD_API_CALL PFNGLGETUNIFORMFVPROC glad_glGetUniformfv; +#define glGetUniformfv glad_glGetUniformfv +GLAD_API_CALL PFNGLGETUNIFORMIVPROC glad_glGetUniformiv; +#define glGetUniformiv glad_glGetUniformiv +GLAD_API_CALL PFNGLGETUNIFORMUIVPROC glad_glGetUniformuiv; +#define glGetUniformuiv glad_glGetUniformuiv +GLAD_API_CALL PFNGLGETVERTEXATTRIBIIVPROC glad_glGetVertexAttribIiv; +#define glGetVertexAttribIiv glad_glGetVertexAttribIiv +GLAD_API_CALL PFNGLGETVERTEXATTRIBIUIVPROC glad_glGetVertexAttribIuiv; +#define glGetVertexAttribIuiv glad_glGetVertexAttribIuiv +GLAD_API_CALL PFNGLGETVERTEXATTRIBPOINTERVPROC glad_glGetVertexAttribPointerv; +#define glGetVertexAttribPointerv glad_glGetVertexAttribPointerv +GLAD_API_CALL PFNGLGETVERTEXATTRIBDVPROC glad_glGetVertexAttribdv; +#define glGetVertexAttribdv glad_glGetVertexAttribdv +GLAD_API_CALL PFNGLGETVERTEXATTRIBFVPROC glad_glGetVertexAttribfv; +#define glGetVertexAttribfv glad_glGetVertexAttribfv +GLAD_API_CALL PFNGLGETVERTEXATTRIBIVPROC glad_glGetVertexAttribiv; +#define glGetVertexAttribiv glad_glGetVertexAttribiv +GLAD_API_CALL PFNGLHINTPROC glad_glHint; +#define glHint glad_glHint +GLAD_API_CALL PFNGLISBUFFERPROC glad_glIsBuffer; +#define glIsBuffer glad_glIsBuffer +GLAD_API_CALL PFNGLISENABLEDPROC glad_glIsEnabled; +#define glIsEnabled glad_glIsEnabled +GLAD_API_CALL PFNGLISENABLEDIPROC glad_glIsEnabledi; +#define glIsEnabledi glad_glIsEnabledi +GLAD_API_CALL PFNGLISFRAMEBUFFERPROC glad_glIsFramebuffer; +#define glIsFramebuffer glad_glIsFramebuffer +GLAD_API_CALL PFNGLISPROGRAMPROC glad_glIsProgram; +#define glIsProgram glad_glIsProgram +GLAD_API_CALL PFNGLISQUERYPROC glad_glIsQuery; +#define glIsQuery glad_glIsQuery +GLAD_API_CALL PFNGLISRENDERBUFFERPROC glad_glIsRenderbuffer; +#define glIsRenderbuffer glad_glIsRenderbuffer +GLAD_API_CALL PFNGLISSAMPLERPROC glad_glIsSampler; +#define glIsSampler glad_glIsSampler +GLAD_API_CALL PFNGLISSHADERPROC glad_glIsShader; +#define glIsShader glad_glIsShader +GLAD_API_CALL PFNGLISSYNCPROC glad_glIsSync; +#define glIsSync glad_glIsSync +GLAD_API_CALL PFNGLISTEXTUREPROC glad_glIsTexture; +#define glIsTexture glad_glIsTexture +GLAD_API_CALL PFNGLISVERTEXARRAYPROC glad_glIsVertexArray; +#define glIsVertexArray glad_glIsVertexArray +GLAD_API_CALL PFNGLLINEWIDTHPROC glad_glLineWidth; +#define glLineWidth glad_glLineWidth +GLAD_API_CALL PFNGLLINKPROGRAMPROC glad_glLinkProgram; +#define glLinkProgram glad_glLinkProgram +GLAD_API_CALL PFNGLLOGICOPPROC glad_glLogicOp; +#define glLogicOp glad_glLogicOp +GLAD_API_CALL PFNGLMAPBUFFERPROC glad_glMapBuffer; +#define glMapBuffer glad_glMapBuffer +GLAD_API_CALL PFNGLMAPBUFFERRANGEPROC glad_glMapBufferRange; +#define glMapBufferRange glad_glMapBufferRange +GLAD_API_CALL PFNGLMULTIDRAWARRAYSPROC glad_glMultiDrawArrays; +#define glMultiDrawArrays glad_glMultiDrawArrays +GLAD_API_CALL PFNGLMULTIDRAWELEMENTSPROC glad_glMultiDrawElements; +#define glMultiDrawElements glad_glMultiDrawElements +GLAD_API_CALL PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC glad_glMultiDrawElementsBaseVertex; +#define glMultiDrawElementsBaseVertex glad_glMultiDrawElementsBaseVertex +GLAD_API_CALL PFNGLOBJECTLABELPROC glad_glObjectLabel; +#define glObjectLabel glad_glObjectLabel +GLAD_API_CALL PFNGLOBJECTPTRLABELPROC glad_glObjectPtrLabel; +#define glObjectPtrLabel glad_glObjectPtrLabel +GLAD_API_CALL PFNGLPIXELSTOREFPROC glad_glPixelStoref; +#define glPixelStoref glad_glPixelStoref +GLAD_API_CALL PFNGLPIXELSTOREIPROC glad_glPixelStorei; +#define glPixelStorei glad_glPixelStorei +GLAD_API_CALL PFNGLPOINTPARAMETERFPROC glad_glPointParameterf; +#define glPointParameterf glad_glPointParameterf +GLAD_API_CALL PFNGLPOINTPARAMETERFVPROC glad_glPointParameterfv; +#define glPointParameterfv glad_glPointParameterfv +GLAD_API_CALL PFNGLPOINTPARAMETERIPROC glad_glPointParameteri; +#define glPointParameteri glad_glPointParameteri +GLAD_API_CALL PFNGLPOINTPARAMETERIVPROC glad_glPointParameteriv; +#define glPointParameteriv glad_glPointParameteriv +GLAD_API_CALL PFNGLPOINTSIZEPROC glad_glPointSize; +#define glPointSize glad_glPointSize +GLAD_API_CALL PFNGLPOLYGONMODEPROC glad_glPolygonMode; +#define glPolygonMode glad_glPolygonMode +GLAD_API_CALL PFNGLPOLYGONOFFSETPROC glad_glPolygonOffset; +#define glPolygonOffset glad_glPolygonOffset +GLAD_API_CALL PFNGLPOPDEBUGGROUPPROC glad_glPopDebugGroup; +#define glPopDebugGroup glad_glPopDebugGroup +GLAD_API_CALL PFNGLPRIMITIVERESTARTINDEXPROC glad_glPrimitiveRestartIndex; +#define glPrimitiveRestartIndex glad_glPrimitiveRestartIndex +GLAD_API_CALL PFNGLPROVOKINGVERTEXPROC glad_glProvokingVertex; +#define glProvokingVertex glad_glProvokingVertex +GLAD_API_CALL PFNGLPUSHDEBUGGROUPPROC glad_glPushDebugGroup; +#define glPushDebugGroup glad_glPushDebugGroup +GLAD_API_CALL PFNGLQUERYCOUNTERPROC glad_glQueryCounter; +#define glQueryCounter glad_glQueryCounter +GLAD_API_CALL PFNGLREADBUFFERPROC glad_glReadBuffer; +#define glReadBuffer glad_glReadBuffer +GLAD_API_CALL PFNGLREADPIXELSPROC glad_glReadPixels; +#define glReadPixels glad_glReadPixels +GLAD_API_CALL PFNGLRENDERBUFFERSTORAGEPROC glad_glRenderbufferStorage; +#define glRenderbufferStorage glad_glRenderbufferStorage +GLAD_API_CALL PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC glad_glRenderbufferStorageMultisample; +#define glRenderbufferStorageMultisample glad_glRenderbufferStorageMultisample +GLAD_API_CALL PFNGLSAMPLECOVERAGEPROC glad_glSampleCoverage; +#define glSampleCoverage glad_glSampleCoverage +GLAD_API_CALL PFNGLSAMPLEMASKIPROC glad_glSampleMaski; +#define glSampleMaski glad_glSampleMaski +GLAD_API_CALL PFNGLSAMPLERPARAMETERIIVPROC glad_glSamplerParameterIiv; +#define glSamplerParameterIiv glad_glSamplerParameterIiv +GLAD_API_CALL PFNGLSAMPLERPARAMETERIUIVPROC glad_glSamplerParameterIuiv; +#define glSamplerParameterIuiv glad_glSamplerParameterIuiv +GLAD_API_CALL PFNGLSAMPLERPARAMETERFPROC glad_glSamplerParameterf; +#define glSamplerParameterf glad_glSamplerParameterf +GLAD_API_CALL PFNGLSAMPLERPARAMETERFVPROC glad_glSamplerParameterfv; +#define glSamplerParameterfv glad_glSamplerParameterfv +GLAD_API_CALL PFNGLSAMPLERPARAMETERIPROC glad_glSamplerParameteri; +#define glSamplerParameteri glad_glSamplerParameteri +GLAD_API_CALL PFNGLSAMPLERPARAMETERIVPROC glad_glSamplerParameteriv; +#define glSamplerParameteriv glad_glSamplerParameteriv +GLAD_API_CALL PFNGLSCISSORPROC glad_glScissor; +#define glScissor glad_glScissor +GLAD_API_CALL PFNGLSHADERSOURCEPROC glad_glShaderSource; +#define glShaderSource glad_glShaderSource +GLAD_API_CALL PFNGLSTENCILFUNCPROC glad_glStencilFunc; +#define glStencilFunc glad_glStencilFunc +GLAD_API_CALL PFNGLSTENCILFUNCSEPARATEPROC glad_glStencilFuncSeparate; +#define glStencilFuncSeparate glad_glStencilFuncSeparate +GLAD_API_CALL PFNGLSTENCILMASKPROC glad_glStencilMask; +#define glStencilMask glad_glStencilMask +GLAD_API_CALL PFNGLSTENCILMASKSEPARATEPROC glad_glStencilMaskSeparate; +#define glStencilMaskSeparate glad_glStencilMaskSeparate +GLAD_API_CALL PFNGLSTENCILOPPROC glad_glStencilOp; +#define glStencilOp glad_glStencilOp +GLAD_API_CALL PFNGLSTENCILOPSEPARATEPROC glad_glStencilOpSeparate; +#define glStencilOpSeparate glad_glStencilOpSeparate +GLAD_API_CALL PFNGLTEXBUFFERPROC glad_glTexBuffer; +#define glTexBuffer glad_glTexBuffer +GLAD_API_CALL PFNGLTEXIMAGE1DPROC glad_glTexImage1D; +#define glTexImage1D glad_glTexImage1D +GLAD_API_CALL PFNGLTEXIMAGE2DPROC glad_glTexImage2D; +#define glTexImage2D glad_glTexImage2D +GLAD_API_CALL PFNGLTEXIMAGE2DMULTISAMPLEPROC glad_glTexImage2DMultisample; +#define glTexImage2DMultisample glad_glTexImage2DMultisample +GLAD_API_CALL PFNGLTEXIMAGE3DPROC glad_glTexImage3D; +#define glTexImage3D glad_glTexImage3D +GLAD_API_CALL PFNGLTEXIMAGE3DMULTISAMPLEPROC glad_glTexImage3DMultisample; +#define glTexImage3DMultisample glad_glTexImage3DMultisample +GLAD_API_CALL PFNGLTEXPARAMETERIIVPROC glad_glTexParameterIiv; +#define glTexParameterIiv glad_glTexParameterIiv +GLAD_API_CALL PFNGLTEXPARAMETERIUIVPROC glad_glTexParameterIuiv; +#define glTexParameterIuiv glad_glTexParameterIuiv +GLAD_API_CALL PFNGLTEXPARAMETERFPROC glad_glTexParameterf; +#define glTexParameterf glad_glTexParameterf +GLAD_API_CALL PFNGLTEXPARAMETERFVPROC glad_glTexParameterfv; +#define glTexParameterfv glad_glTexParameterfv +GLAD_API_CALL PFNGLTEXPARAMETERIPROC glad_glTexParameteri; +#define glTexParameteri glad_glTexParameteri +GLAD_API_CALL PFNGLTEXPARAMETERIVPROC glad_glTexParameteriv; +#define glTexParameteriv glad_glTexParameteriv +GLAD_API_CALL PFNGLTEXSUBIMAGE1DPROC glad_glTexSubImage1D; +#define glTexSubImage1D glad_glTexSubImage1D +GLAD_API_CALL PFNGLTEXSUBIMAGE2DPROC glad_glTexSubImage2D; +#define glTexSubImage2D glad_glTexSubImage2D +GLAD_API_CALL PFNGLTEXSUBIMAGE3DPROC glad_glTexSubImage3D; +#define glTexSubImage3D glad_glTexSubImage3D +GLAD_API_CALL PFNGLTRANSFORMFEEDBACKVARYINGSPROC glad_glTransformFeedbackVaryings; +#define glTransformFeedbackVaryings glad_glTransformFeedbackVaryings +GLAD_API_CALL PFNGLUNIFORM1FPROC glad_glUniform1f; +#define glUniform1f glad_glUniform1f +GLAD_API_CALL PFNGLUNIFORM1FVPROC glad_glUniform1fv; +#define glUniform1fv glad_glUniform1fv +GLAD_API_CALL PFNGLUNIFORM1IPROC glad_glUniform1i; +#define glUniform1i glad_glUniform1i +GLAD_API_CALL PFNGLUNIFORM1IVPROC glad_glUniform1iv; +#define glUniform1iv glad_glUniform1iv +GLAD_API_CALL PFNGLUNIFORM1UIPROC glad_glUniform1ui; +#define glUniform1ui glad_glUniform1ui +GLAD_API_CALL PFNGLUNIFORM1UIVPROC glad_glUniform1uiv; +#define glUniform1uiv glad_glUniform1uiv +GLAD_API_CALL PFNGLUNIFORM2FPROC glad_glUniform2f; +#define glUniform2f glad_glUniform2f +GLAD_API_CALL PFNGLUNIFORM2FVPROC glad_glUniform2fv; +#define glUniform2fv glad_glUniform2fv +GLAD_API_CALL PFNGLUNIFORM2IPROC glad_glUniform2i; +#define glUniform2i glad_glUniform2i +GLAD_API_CALL PFNGLUNIFORM2IVPROC glad_glUniform2iv; +#define glUniform2iv glad_glUniform2iv +GLAD_API_CALL PFNGLUNIFORM2UIPROC glad_glUniform2ui; +#define glUniform2ui glad_glUniform2ui +GLAD_API_CALL PFNGLUNIFORM2UIVPROC glad_glUniform2uiv; +#define glUniform2uiv glad_glUniform2uiv +GLAD_API_CALL PFNGLUNIFORM3FPROC glad_glUniform3f; +#define glUniform3f glad_glUniform3f +GLAD_API_CALL PFNGLUNIFORM3FVPROC glad_glUniform3fv; +#define glUniform3fv glad_glUniform3fv +GLAD_API_CALL PFNGLUNIFORM3IPROC glad_glUniform3i; +#define glUniform3i glad_glUniform3i +GLAD_API_CALL PFNGLUNIFORM3IVPROC glad_glUniform3iv; +#define glUniform3iv glad_glUniform3iv +GLAD_API_CALL PFNGLUNIFORM3UIPROC glad_glUniform3ui; +#define glUniform3ui glad_glUniform3ui +GLAD_API_CALL PFNGLUNIFORM3UIVPROC glad_glUniform3uiv; +#define glUniform3uiv glad_glUniform3uiv +GLAD_API_CALL PFNGLUNIFORM4FPROC glad_glUniform4f; +#define glUniform4f glad_glUniform4f +GLAD_API_CALL PFNGLUNIFORM4FVPROC glad_glUniform4fv; +#define glUniform4fv glad_glUniform4fv +GLAD_API_CALL PFNGLUNIFORM4IPROC glad_glUniform4i; +#define glUniform4i glad_glUniform4i +GLAD_API_CALL PFNGLUNIFORM4IVPROC glad_glUniform4iv; +#define glUniform4iv glad_glUniform4iv +GLAD_API_CALL PFNGLUNIFORM4UIPROC glad_glUniform4ui; +#define glUniform4ui glad_glUniform4ui +GLAD_API_CALL PFNGLUNIFORM4UIVPROC glad_glUniform4uiv; +#define glUniform4uiv glad_glUniform4uiv +GLAD_API_CALL PFNGLUNIFORMBLOCKBINDINGPROC glad_glUniformBlockBinding; +#define glUniformBlockBinding glad_glUniformBlockBinding +GLAD_API_CALL PFNGLUNIFORMMATRIX2FVPROC glad_glUniformMatrix2fv; +#define glUniformMatrix2fv glad_glUniformMatrix2fv +GLAD_API_CALL PFNGLUNIFORMMATRIX2X3FVPROC glad_glUniformMatrix2x3fv; +#define glUniformMatrix2x3fv glad_glUniformMatrix2x3fv +GLAD_API_CALL PFNGLUNIFORMMATRIX2X4FVPROC glad_glUniformMatrix2x4fv; +#define glUniformMatrix2x4fv glad_glUniformMatrix2x4fv +GLAD_API_CALL PFNGLUNIFORMMATRIX3FVPROC glad_glUniformMatrix3fv; +#define glUniformMatrix3fv glad_glUniformMatrix3fv +GLAD_API_CALL PFNGLUNIFORMMATRIX3X2FVPROC glad_glUniformMatrix3x2fv; +#define glUniformMatrix3x2fv glad_glUniformMatrix3x2fv +GLAD_API_CALL PFNGLUNIFORMMATRIX3X4FVPROC glad_glUniformMatrix3x4fv; +#define glUniformMatrix3x4fv glad_glUniformMatrix3x4fv +GLAD_API_CALL PFNGLUNIFORMMATRIX4FVPROC glad_glUniformMatrix4fv; +#define glUniformMatrix4fv glad_glUniformMatrix4fv +GLAD_API_CALL PFNGLUNIFORMMATRIX4X2FVPROC glad_glUniformMatrix4x2fv; +#define glUniformMatrix4x2fv glad_glUniformMatrix4x2fv +GLAD_API_CALL PFNGLUNIFORMMATRIX4X3FVPROC glad_glUniformMatrix4x3fv; +#define glUniformMatrix4x3fv glad_glUniformMatrix4x3fv +GLAD_API_CALL PFNGLUNMAPBUFFERPROC glad_glUnmapBuffer; +#define glUnmapBuffer glad_glUnmapBuffer +GLAD_API_CALL PFNGLUSEPROGRAMPROC glad_glUseProgram; +#define glUseProgram glad_glUseProgram +GLAD_API_CALL PFNGLVALIDATEPROGRAMPROC glad_glValidateProgram; +#define glValidateProgram glad_glValidateProgram +GLAD_API_CALL PFNGLVERTEXATTRIB1DPROC glad_glVertexAttrib1d; +#define glVertexAttrib1d glad_glVertexAttrib1d +GLAD_API_CALL PFNGLVERTEXATTRIB1DVPROC glad_glVertexAttrib1dv; +#define glVertexAttrib1dv glad_glVertexAttrib1dv +GLAD_API_CALL PFNGLVERTEXATTRIB1FPROC glad_glVertexAttrib1f; +#define glVertexAttrib1f glad_glVertexAttrib1f +GLAD_API_CALL PFNGLVERTEXATTRIB1FVPROC glad_glVertexAttrib1fv; +#define glVertexAttrib1fv glad_glVertexAttrib1fv +GLAD_API_CALL PFNGLVERTEXATTRIB1SPROC glad_glVertexAttrib1s; +#define glVertexAttrib1s glad_glVertexAttrib1s +GLAD_API_CALL PFNGLVERTEXATTRIB1SVPROC glad_glVertexAttrib1sv; +#define glVertexAttrib1sv glad_glVertexAttrib1sv +GLAD_API_CALL PFNGLVERTEXATTRIB2DPROC glad_glVertexAttrib2d; +#define glVertexAttrib2d glad_glVertexAttrib2d +GLAD_API_CALL PFNGLVERTEXATTRIB2DVPROC glad_glVertexAttrib2dv; +#define glVertexAttrib2dv glad_glVertexAttrib2dv +GLAD_API_CALL PFNGLVERTEXATTRIB2FPROC glad_glVertexAttrib2f; +#define glVertexAttrib2f glad_glVertexAttrib2f +GLAD_API_CALL PFNGLVERTEXATTRIB2FVPROC glad_glVertexAttrib2fv; +#define glVertexAttrib2fv glad_glVertexAttrib2fv +GLAD_API_CALL PFNGLVERTEXATTRIB2SPROC glad_glVertexAttrib2s; +#define glVertexAttrib2s glad_glVertexAttrib2s +GLAD_API_CALL PFNGLVERTEXATTRIB2SVPROC glad_glVertexAttrib2sv; +#define glVertexAttrib2sv glad_glVertexAttrib2sv +GLAD_API_CALL PFNGLVERTEXATTRIB3DPROC glad_glVertexAttrib3d; +#define glVertexAttrib3d glad_glVertexAttrib3d +GLAD_API_CALL PFNGLVERTEXATTRIB3DVPROC glad_glVertexAttrib3dv; +#define glVertexAttrib3dv glad_glVertexAttrib3dv +GLAD_API_CALL PFNGLVERTEXATTRIB3FPROC glad_glVertexAttrib3f; +#define glVertexAttrib3f glad_glVertexAttrib3f +GLAD_API_CALL PFNGLVERTEXATTRIB3FVPROC glad_glVertexAttrib3fv; +#define glVertexAttrib3fv glad_glVertexAttrib3fv +GLAD_API_CALL PFNGLVERTEXATTRIB3SPROC glad_glVertexAttrib3s; +#define glVertexAttrib3s glad_glVertexAttrib3s +GLAD_API_CALL PFNGLVERTEXATTRIB3SVPROC glad_glVertexAttrib3sv; +#define glVertexAttrib3sv glad_glVertexAttrib3sv +GLAD_API_CALL PFNGLVERTEXATTRIB4NBVPROC glad_glVertexAttrib4Nbv; +#define glVertexAttrib4Nbv glad_glVertexAttrib4Nbv +GLAD_API_CALL PFNGLVERTEXATTRIB4NIVPROC glad_glVertexAttrib4Niv; +#define glVertexAttrib4Niv glad_glVertexAttrib4Niv +GLAD_API_CALL PFNGLVERTEXATTRIB4NSVPROC glad_glVertexAttrib4Nsv; +#define glVertexAttrib4Nsv glad_glVertexAttrib4Nsv +GLAD_API_CALL PFNGLVERTEXATTRIB4NUBPROC glad_glVertexAttrib4Nub; +#define glVertexAttrib4Nub glad_glVertexAttrib4Nub +GLAD_API_CALL PFNGLVERTEXATTRIB4NUBVPROC glad_glVertexAttrib4Nubv; +#define glVertexAttrib4Nubv glad_glVertexAttrib4Nubv +GLAD_API_CALL PFNGLVERTEXATTRIB4NUIVPROC glad_glVertexAttrib4Nuiv; +#define glVertexAttrib4Nuiv glad_glVertexAttrib4Nuiv +GLAD_API_CALL PFNGLVERTEXATTRIB4NUSVPROC glad_glVertexAttrib4Nusv; +#define glVertexAttrib4Nusv glad_glVertexAttrib4Nusv +GLAD_API_CALL PFNGLVERTEXATTRIB4BVPROC glad_glVertexAttrib4bv; +#define glVertexAttrib4bv glad_glVertexAttrib4bv +GLAD_API_CALL PFNGLVERTEXATTRIB4DPROC glad_glVertexAttrib4d; +#define glVertexAttrib4d glad_glVertexAttrib4d +GLAD_API_CALL PFNGLVERTEXATTRIB4DVPROC glad_glVertexAttrib4dv; +#define glVertexAttrib4dv glad_glVertexAttrib4dv +GLAD_API_CALL PFNGLVERTEXATTRIB4FPROC glad_glVertexAttrib4f; +#define glVertexAttrib4f glad_glVertexAttrib4f +GLAD_API_CALL PFNGLVERTEXATTRIB4FVPROC glad_glVertexAttrib4fv; +#define glVertexAttrib4fv glad_glVertexAttrib4fv +GLAD_API_CALL PFNGLVERTEXATTRIB4IVPROC glad_glVertexAttrib4iv; +#define glVertexAttrib4iv glad_glVertexAttrib4iv +GLAD_API_CALL PFNGLVERTEXATTRIB4SPROC glad_glVertexAttrib4s; +#define glVertexAttrib4s glad_glVertexAttrib4s +GLAD_API_CALL PFNGLVERTEXATTRIB4SVPROC glad_glVertexAttrib4sv; +#define glVertexAttrib4sv glad_glVertexAttrib4sv +GLAD_API_CALL PFNGLVERTEXATTRIB4UBVPROC glad_glVertexAttrib4ubv; +#define glVertexAttrib4ubv glad_glVertexAttrib4ubv +GLAD_API_CALL PFNGLVERTEXATTRIB4UIVPROC glad_glVertexAttrib4uiv; +#define glVertexAttrib4uiv glad_glVertexAttrib4uiv +GLAD_API_CALL PFNGLVERTEXATTRIB4USVPROC glad_glVertexAttrib4usv; +#define glVertexAttrib4usv glad_glVertexAttrib4usv +GLAD_API_CALL PFNGLVERTEXATTRIBDIVISORPROC glad_glVertexAttribDivisor; +#define glVertexAttribDivisor glad_glVertexAttribDivisor +GLAD_API_CALL PFNGLVERTEXATTRIBI1IPROC glad_glVertexAttribI1i; +#define glVertexAttribI1i glad_glVertexAttribI1i +GLAD_API_CALL PFNGLVERTEXATTRIBI1IVPROC glad_glVertexAttribI1iv; +#define glVertexAttribI1iv glad_glVertexAttribI1iv +GLAD_API_CALL PFNGLVERTEXATTRIBI1UIPROC glad_glVertexAttribI1ui; +#define glVertexAttribI1ui glad_glVertexAttribI1ui +GLAD_API_CALL PFNGLVERTEXATTRIBI1UIVPROC glad_glVertexAttribI1uiv; +#define glVertexAttribI1uiv glad_glVertexAttribI1uiv +GLAD_API_CALL PFNGLVERTEXATTRIBI2IPROC glad_glVertexAttribI2i; +#define glVertexAttribI2i glad_glVertexAttribI2i +GLAD_API_CALL PFNGLVERTEXATTRIBI2IVPROC glad_glVertexAttribI2iv; +#define glVertexAttribI2iv glad_glVertexAttribI2iv +GLAD_API_CALL PFNGLVERTEXATTRIBI2UIPROC glad_glVertexAttribI2ui; +#define glVertexAttribI2ui glad_glVertexAttribI2ui +GLAD_API_CALL PFNGLVERTEXATTRIBI2UIVPROC glad_glVertexAttribI2uiv; +#define glVertexAttribI2uiv glad_glVertexAttribI2uiv +GLAD_API_CALL PFNGLVERTEXATTRIBI3IPROC glad_glVertexAttribI3i; +#define glVertexAttribI3i glad_glVertexAttribI3i +GLAD_API_CALL PFNGLVERTEXATTRIBI3IVPROC glad_glVertexAttribI3iv; +#define glVertexAttribI3iv glad_glVertexAttribI3iv +GLAD_API_CALL PFNGLVERTEXATTRIBI3UIPROC glad_glVertexAttribI3ui; +#define glVertexAttribI3ui glad_glVertexAttribI3ui +GLAD_API_CALL PFNGLVERTEXATTRIBI3UIVPROC glad_glVertexAttribI3uiv; +#define glVertexAttribI3uiv glad_glVertexAttribI3uiv +GLAD_API_CALL PFNGLVERTEXATTRIBI4BVPROC glad_glVertexAttribI4bv; +#define glVertexAttribI4bv glad_glVertexAttribI4bv +GLAD_API_CALL PFNGLVERTEXATTRIBI4IPROC glad_glVertexAttribI4i; +#define glVertexAttribI4i glad_glVertexAttribI4i +GLAD_API_CALL PFNGLVERTEXATTRIBI4IVPROC glad_glVertexAttribI4iv; +#define glVertexAttribI4iv glad_glVertexAttribI4iv +GLAD_API_CALL PFNGLVERTEXATTRIBI4SVPROC glad_glVertexAttribI4sv; +#define glVertexAttribI4sv glad_glVertexAttribI4sv +GLAD_API_CALL PFNGLVERTEXATTRIBI4UBVPROC glad_glVertexAttribI4ubv; +#define glVertexAttribI4ubv glad_glVertexAttribI4ubv +GLAD_API_CALL PFNGLVERTEXATTRIBI4UIPROC glad_glVertexAttribI4ui; +#define glVertexAttribI4ui glad_glVertexAttribI4ui +GLAD_API_CALL PFNGLVERTEXATTRIBI4UIVPROC glad_glVertexAttribI4uiv; +#define glVertexAttribI4uiv glad_glVertexAttribI4uiv +GLAD_API_CALL PFNGLVERTEXATTRIBI4USVPROC glad_glVertexAttribI4usv; +#define glVertexAttribI4usv glad_glVertexAttribI4usv +GLAD_API_CALL PFNGLVERTEXATTRIBIPOINTERPROC glad_glVertexAttribIPointer; +#define glVertexAttribIPointer glad_glVertexAttribIPointer +GLAD_API_CALL PFNGLVERTEXATTRIBP1UIPROC glad_glVertexAttribP1ui; +#define glVertexAttribP1ui glad_glVertexAttribP1ui +GLAD_API_CALL PFNGLVERTEXATTRIBP1UIVPROC glad_glVertexAttribP1uiv; +#define glVertexAttribP1uiv glad_glVertexAttribP1uiv +GLAD_API_CALL PFNGLVERTEXATTRIBP2UIPROC glad_glVertexAttribP2ui; +#define glVertexAttribP2ui glad_glVertexAttribP2ui +GLAD_API_CALL PFNGLVERTEXATTRIBP2UIVPROC glad_glVertexAttribP2uiv; +#define glVertexAttribP2uiv glad_glVertexAttribP2uiv +GLAD_API_CALL PFNGLVERTEXATTRIBP3UIPROC glad_glVertexAttribP3ui; +#define glVertexAttribP3ui glad_glVertexAttribP3ui +GLAD_API_CALL PFNGLVERTEXATTRIBP3UIVPROC glad_glVertexAttribP3uiv; +#define glVertexAttribP3uiv glad_glVertexAttribP3uiv +GLAD_API_CALL PFNGLVERTEXATTRIBP4UIPROC glad_glVertexAttribP4ui; +#define glVertexAttribP4ui glad_glVertexAttribP4ui +GLAD_API_CALL PFNGLVERTEXATTRIBP4UIVPROC glad_glVertexAttribP4uiv; +#define glVertexAttribP4uiv glad_glVertexAttribP4uiv +GLAD_API_CALL PFNGLVERTEXATTRIBPOINTERPROC glad_glVertexAttribPointer; +#define glVertexAttribPointer glad_glVertexAttribPointer +GLAD_API_CALL PFNGLVIEWPORTPROC glad_glViewport; +#define glViewport glad_glViewport +GLAD_API_CALL PFNGLWAITSYNCPROC glad_glWaitSync; +#define glWaitSync glad_glWaitSync + + + + + +GLAD_API_CALL int gladLoadGLUserPtr( GLADuserptrloadfunc load, void *userptr); +GLAD_API_CALL int gladLoadGL( GLADloadfunc load); + + + +#ifdef __cplusplus +} +#endif +#endif diff --git a/lib/glad/wgl.h b/lib/glad/wgl.h new file mode 100644 index 000000000..0b7d297d2 --- /dev/null +++ b/lib/glad/wgl.h @@ -0,0 +1,298 @@ +/** + * Loader generated by glad 2.0.6 on Thu Apr 18 05:15:26 2024 + * + * SPDX-License-Identifier: (WTFPL OR CC0-1.0) AND Apache-2.0 + * + * Generator: C/C++ + * Specification: wgl + * Extensions: 2 + * + * APIs: + * - wgl=1.0 + * + * Options: + * - ALIAS = False + * - DEBUG = False + * - HEADER_ONLY = False + * - LOADER = True + * - MX = False + * - ON_DEMAND = False + * + * Commandline: + * --api='wgl=1.0' --extensions='WGL_ARB_extensions_string,WGL_EXT_extensions_string' c --loader + * + * Online: + * http://glad.sh/#api=wgl%3D1.0&extensions=WGL_ARB_extensions_string%2CWGL_EXT_extensions_string&generator=c&options=LOADER + * + */ + +#ifndef GLAD_WGL_H_ +#define GLAD_WGL_H_ + +#include +#include + +#define GLAD_WGL +#define GLAD_OPTION_WGL_LOADER + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef GLAD_PLATFORM_H_ +#define GLAD_PLATFORM_H_ + +#ifndef GLAD_PLATFORM_WIN32 +#if defined(_WIN32) || defined(__WIN32__) || defined(WIN32) || defined(__MINGW32__) +#define GLAD_PLATFORM_WIN32 1 +#else +#define GLAD_PLATFORM_WIN32 0 +#endif +#endif + +#ifndef GLAD_PLATFORM_APPLE +#ifdef __APPLE__ +#define GLAD_PLATFORM_APPLE 1 +#else +#define GLAD_PLATFORM_APPLE 0 +#endif +#endif + +#ifndef GLAD_PLATFORM_EMSCRIPTEN +#ifdef __EMSCRIPTEN__ +#define GLAD_PLATFORM_EMSCRIPTEN 1 +#else +#define GLAD_PLATFORM_EMSCRIPTEN 0 +#endif +#endif + +#ifndef GLAD_PLATFORM_UWP +#if defined(_MSC_VER) && !defined(GLAD_INTERNAL_HAVE_WINAPIFAMILY) +#ifdef __has_include +#if __has_include() +#define GLAD_INTERNAL_HAVE_WINAPIFAMILY 1 +#endif +#elif _MSC_VER >= 1700 && !_USING_V110_SDK71_ +#define GLAD_INTERNAL_HAVE_WINAPIFAMILY 1 +#endif +#endif + +#ifdef GLAD_INTERNAL_HAVE_WINAPIFAMILY +#include +#if !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) && WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) +#define GLAD_PLATFORM_UWP 1 +#endif +#endif + +#ifndef GLAD_PLATFORM_UWP +#define GLAD_PLATFORM_UWP 0 +#endif +#endif + +#ifdef __GNUC__ +#define GLAD_GNUC_EXTENSION __extension__ +#else +#define GLAD_GNUC_EXTENSION +#endif + +#define GLAD_UNUSED(x) (void)(x) + +#ifndef GLAD_API_CALL +#if defined(GLAD_API_CALL_EXPORT) +#if GLAD_PLATFORM_WIN32 || defined(__CYGWIN__) +#if defined(GLAD_API_CALL_EXPORT_BUILD) +#if defined(__GNUC__) +#define GLAD_API_CALL __attribute__ ((dllexport)) extern +#else +#define GLAD_API_CALL __declspec(dllexport) extern +#endif +#else +#if defined(__GNUC__) +#define GLAD_API_CALL __attribute__ ((dllimport)) extern +#else +#define GLAD_API_CALL __declspec(dllimport) extern +#endif +#endif +#elif defined(__GNUC__) && defined(GLAD_API_CALL_EXPORT_BUILD) +#define GLAD_API_CALL __attribute__ ((visibility ("default"))) extern +#else +#define GLAD_API_CALL extern +#endif +#else +#define GLAD_API_CALL extern +#endif +#endif + +#ifdef APIENTRY +#define GLAD_API_PTR APIENTRY +#elif GLAD_PLATFORM_WIN32 +#define GLAD_API_PTR __stdcall +#else +#define GLAD_API_PTR +#endif + +#ifndef GLAPI +#define GLAPI GLAD_API_CALL +#endif + +#ifndef GLAPIENTRY +#define GLAPIENTRY GLAD_API_PTR +#endif + +#define GLAD_MAKE_VERSION(major, minor) (major * 10000 + minor) +#define GLAD_VERSION_MAJOR(version) (version / 10000) +#define GLAD_VERSION_MINOR(version) (version % 10000) + +#define GLAD_GENERATOR_VERSION "2.0.6" + + typedef void (*GLADapiproc)(void); + + typedef GLADapiproc(*GLADloadfunc)(const char* name); + typedef GLADapiproc(*GLADuserptrloadfunc)(void* userptr, const char* name); + + typedef void (*GLADprecallback)(const char* name, GLADapiproc apiproc, int len_args, ...); + typedef void (*GLADpostcallback)(void* ret, const char* name, GLADapiproc apiproc, int len_args, ...); + +#endif /* GLAD_PLATFORM_H_ */ + +#define WGL_FONT_LINES 0 +#define WGL_FONT_POLYGONS 1 +#define WGL_SWAP_MAIN_PLANE 0x00000001 +#define WGL_SWAP_OVERLAY1 0x00000002 +#define WGL_SWAP_OVERLAY10 0x00000400 +#define WGL_SWAP_OVERLAY11 0x00000800 +#define WGL_SWAP_OVERLAY12 0x00001000 +#define WGL_SWAP_OVERLAY13 0x00002000 +#define WGL_SWAP_OVERLAY14 0x00004000 +#define WGL_SWAP_OVERLAY15 0x00008000 +#define WGL_SWAP_OVERLAY2 0x00000004 +#define WGL_SWAP_OVERLAY3 0x00000008 +#define WGL_SWAP_OVERLAY4 0x00000010 +#define WGL_SWAP_OVERLAY5 0x00000020 +#define WGL_SWAP_OVERLAY6 0x00000040 +#define WGL_SWAP_OVERLAY7 0x00000080 +#define WGL_SWAP_OVERLAY8 0x00000100 +#define WGL_SWAP_OVERLAY9 0x00000200 +#define WGL_SWAP_UNDERLAY1 0x00010000 +#define WGL_SWAP_UNDERLAY10 0x02000000 +#define WGL_SWAP_UNDERLAY11 0x04000000 +#define WGL_SWAP_UNDERLAY12 0x08000000 +#define WGL_SWAP_UNDERLAY13 0x10000000 +#define WGL_SWAP_UNDERLAY14 0x20000000 +#define WGL_SWAP_UNDERLAY15 0x40000000 +#define WGL_SWAP_UNDERLAY2 0x00020000 +#define WGL_SWAP_UNDERLAY3 0x00040000 +#define WGL_SWAP_UNDERLAY4 0x00080000 +#define WGL_SWAP_UNDERLAY5 0x00100000 +#define WGL_SWAP_UNDERLAY6 0x00200000 +#define WGL_SWAP_UNDERLAY7 0x00400000 +#define WGL_SWAP_UNDERLAY8 0x00800000 +#define WGL_SWAP_UNDERLAY9 0x01000000 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + struct _GPU_DEVICE { + DWORD cb; + CHAR DeviceName[32]; + CHAR DeviceString[128]; + DWORD Flags; + RECT rcVirtualScreen; + }; + DECLARE_HANDLE(HPBUFFERARB); + DECLARE_HANDLE(HPBUFFEREXT); + DECLARE_HANDLE(HVIDEOOUTPUTDEVICENV); + DECLARE_HANDLE(HPVIDEODEV); + DECLARE_HANDLE(HPGPUNV); + DECLARE_HANDLE(HGPUNV); + DECLARE_HANDLE(HVIDEOINPUTDEVICENV); + typedef struct _GPU_DEVICE GPU_DEVICE; + typedef struct _GPU_DEVICE* PGPU_DEVICE; + + +#define WGL_VERSION_1_0 1 + GLAD_API_CALL int GLAD_WGL_VERSION_1_0; +#define WGL_ARB_extensions_string 1 + GLAD_API_CALL int GLAD_WGL_ARB_extensions_string; +#define WGL_EXT_extensions_string 1 + GLAD_API_CALL int GLAD_WGL_EXT_extensions_string; + + + typedef int (GLAD_API_PTR* PFNCHOOSEPIXELFORMATPROC)(HDC hDc, const PIXELFORMATDESCRIPTOR* pPfd); + typedef int (GLAD_API_PTR* PFNDESCRIBEPIXELFORMATPROC)(HDC hdc, int ipfd, UINT cjpfd, PIXELFORMATDESCRIPTOR* ppfd); + typedef UINT(GLAD_API_PTR* PFNGETENHMETAFILEPIXELFORMATPROC)(HENHMETAFILE hemf, UINT cbBuffer, PIXELFORMATDESCRIPTOR* ppfd); + typedef int (GLAD_API_PTR* PFNGETPIXELFORMATPROC)(HDC hdc); + typedef BOOL(GLAD_API_PTR* PFNSETPIXELFORMATPROC)(HDC hdc, int ipfd, const PIXELFORMATDESCRIPTOR* ppfd); + typedef BOOL(GLAD_API_PTR* PFNSWAPBUFFERSPROC)(HDC hdc); + typedef BOOL(GLAD_API_PTR* PFNWGLCOPYCONTEXTPROC)(HGLRC hglrcSrc, HGLRC hglrcDst, UINT mask); + typedef HGLRC(GLAD_API_PTR* PFNWGLCREATECONTEXTPROC)(HDC hDc); + typedef HGLRC(GLAD_API_PTR* PFNWGLCREATELAYERCONTEXTPROC)(HDC hDc, int level); + typedef BOOL(GLAD_API_PTR* PFNWGLDELETECONTEXTPROC)(HGLRC oldContext); + typedef BOOL(GLAD_API_PTR* PFNWGLDESCRIBELAYERPLANEPROC)(HDC hDc, int pixelFormat, int layerPlane, UINT nBytes, LAYERPLANEDESCRIPTOR* plpd); + typedef HGLRC(GLAD_API_PTR* PFNWGLGETCURRENTCONTEXTPROC)(void); + typedef HDC(GLAD_API_PTR* PFNWGLGETCURRENTDCPROC)(void); + typedef const char* (GLAD_API_PTR* PFNWGLGETEXTENSIONSSTRINGARBPROC)(HDC hdc); + typedef const char* (GLAD_API_PTR* PFNWGLGETEXTENSIONSSTRINGEXTPROC)(void); + typedef int (GLAD_API_PTR* PFNWGLGETLAYERPALETTEENTRIESPROC)(HDC hdc, int iLayerPlane, int iStart, int cEntries, COLORREF* pcr); + typedef PROC(GLAD_API_PTR* PFNWGLGETPROCADDRESSPROC)(LPCSTR lpszProc); + typedef BOOL(GLAD_API_PTR* PFNWGLMAKECURRENTPROC)(HDC hDc, HGLRC newContext); + typedef BOOL(GLAD_API_PTR* PFNWGLREALIZELAYERPALETTEPROC)(HDC hdc, int iLayerPlane, BOOL bRealize); + typedef int (GLAD_API_PTR* PFNWGLSETLAYERPALETTEENTRIESPROC)(HDC hdc, int iLayerPlane, int iStart, int cEntries, const COLORREF* pcr); + typedef BOOL(GLAD_API_PTR* PFNWGLSHARELISTSPROC)(HGLRC hrcSrvShare, HGLRC hrcSrvSource); + typedef BOOL(GLAD_API_PTR* PFNWGLSWAPLAYERBUFFERSPROC)(HDC hdc, UINT fuFlags); + typedef BOOL(GLAD_API_PTR* PFNWGLUSEFONTBITMAPSPROC)(HDC hDC, DWORD first, DWORD count, DWORD listBase); + typedef BOOL(GLAD_API_PTR* PFNWGLUSEFONTBITMAPSAPROC)(HDC hDC, DWORD first, DWORD count, DWORD listBase); + typedef BOOL(GLAD_API_PTR* PFNWGLUSEFONTBITMAPSWPROC)(HDC hDC, DWORD first, DWORD count, DWORD listBase); + typedef BOOL(GLAD_API_PTR* PFNWGLUSEFONTOUTLINESPROC)(HDC hDC, DWORD first, DWORD count, DWORD listBase, FLOAT deviation, FLOAT extrusion, int format, LPGLYPHMETRICSFLOAT lpgmf); + typedef BOOL(GLAD_API_PTR* PFNWGLUSEFONTOUTLINESAPROC)(HDC hDC, DWORD first, DWORD count, DWORD listBase, FLOAT deviation, FLOAT extrusion, int format, LPGLYPHMETRICSFLOAT lpgmf); + typedef BOOL(GLAD_API_PTR* PFNWGLUSEFONTOUTLINESWPROC)(HDC hDC, DWORD first, DWORD count, DWORD listBase, FLOAT deviation, FLOAT extrusion, int format, LPGLYPHMETRICSFLOAT lpgmf); + + GLAD_API_CALL PFNWGLGETEXTENSIONSSTRINGARBPROC glad_wglGetExtensionsStringARB; +#define wglGetExtensionsStringARB glad_wglGetExtensionsStringARB + GLAD_API_CALL PFNWGLGETEXTENSIONSSTRINGEXTPROC glad_wglGetExtensionsStringEXT; +#define wglGetExtensionsStringEXT glad_wglGetExtensionsStringEXT + + + + + + GLAD_API_CALL int gladLoadWGLUserPtr(HDC hdc, GLADuserptrloadfunc load, void* userptr); + GLAD_API_CALL int gladLoadWGL(HDC hdc, GLADloadfunc load); + +#ifdef GLAD_WGL + + GLAD_API_CALL int gladLoaderLoadWGL(HDC hdc); + +#endif +#ifdef __cplusplus +} +#endif +#endif diff --git a/lib/renderer.h b/lib/renderer.h index 6a44552ee..0b029ebc7 100644 --- a/lib/renderer.h +++ b/lib/renderer.h @@ -1,5 +1,5 @@ /* -* Descent 3 +* Descent 3 * Copyright (C) 2024 Parallax Software * * This program is free software: you can redistribute it and/or modify @@ -317,10 +317,12 @@ extern int Triangles_drawn; // Is this hardware or software rendered? enum renderer_type { - RENDERER_OPENGL = 2, - RENDERER_DIRECT3D = 3, - RENDERER_GLIDE = 4, - RENDERER_NONE = 5, + RENDERER_SOFTWARE_8BIT, + RENDERER_SOFTWARE_16BIT, + RENDERER_OPENGL, + RENDERER_DIRECT3D, + RENDERER_GLIDE, + RENDERER_NONE, }; extern renderer_type Renderer_type; @@ -413,7 +415,7 @@ enum texture_type { #define AT_SATURATE_TEXTURE_VERTEX 14 // Texture * vertex saturation #define AT_LIGHTMAP_BLEND_VERTEX 15 // Like AT_LIGHTMAP_BLEND, but take vertex alpha into account #define AT_LIGHTMAP_BLEND_CONSTANT 16 // Like AT_LIGHTMAP_BLEND, but take constant alpha into account -#define AT_SPECULAR 32 +#define AT_SPECULAR 32 // Forces texturing on, but replaces color with diffuse color. Alpha is texture * vertex #define AT_LIGHTMAP_BLEND_SATURATE 33 // Light lightmap blend, but add instead of multiply #define LFB_LOCK_READ 0 @@ -442,6 +444,7 @@ struct rendering_state { float cur_fog_start, cur_fog_end; float cur_near_z, cur_far_z; + float depth_const_a, depth_const_b; float gamma_value; int cur_alpha; @@ -452,16 +455,51 @@ struct rendering_state { int clip_x1, clip_x2, clip_y1, clip_y2; int screen_width, screen_height; + int view_width, view_height; +}; + +// [ISB] Legacy compatible rendering_state for dlls. +struct DLLrendering_state { + int8_t initted; + + int8_t cur_bilinear_state; + int8_t cur_zbuffer_state; + int8_t cur_fog_state; + int8_t cur_mip_state; + + texture_type cur_texture_type; + color_model cur_color_model; + light_state cur_light_state; + int8_t cur_alpha_type; + + wrap_type cur_wrap_type; + + float cur_fog_start, cur_fog_end; + float cur_near_z, cur_far_z; + float gamma_value; + int cur_alpha; + ddgr_color cur_color; + ddgr_color cur_fog_color; + + int8_t cur_texture_quality; // 0-none, 1-linear, 2-perspective + + int clip_x1, clip_x2, clip_y1, clip_y2; + int screen_width, screen_height; }; struct renderer_preferred_state { uint8_t mipping; uint8_t filtering; float gamma; + bool antialised; uint8_t bit_depth; + int width, height; + int window_width, window_height; // Size of the game window, may != width/height. + uint8_t vsync_on; + bool fullscreen; // Informs the window system that fullscreen should be used. }; struct renderer_lfb { @@ -517,6 +555,9 @@ void rend_Close(); void rend_DrawScaledBitmap(int x1, int y1, int x2, int y2, int bm, float u0, float v0, float u1, float v1, int color = -1, float *alphas = NULL); +void rend_DrawScaledBitmapWithZ(int x1, int y1, int x2, int y2, int bm, float u0, float v0, float u1, float v1, + float zval, int color, float *alphas = nullptr); + // Sets the state of bilinear filtering for our textures void rend_SetFiltering(int8_t state); @@ -632,12 +673,19 @@ void rend_SetGammaValue(float val); // Fills in the passed in pointer with the current rendering state void rend_GetRenderState(rendering_state *rstate); +// Fills in the passed in pointer with the current rendering state +// Uses legacy structure for compatibiltity with current DLLs. +void rend_DLLGetRenderState(DLLrendering_state *rstate); + // Draws a simple bitmap at the specified x,y location void rend_DrawSimpleBitmap(int bm_handle, int x, int y); // Gets OpenGL ready to work in a window int rend_InitOpenGLWindow(oeApplication *app, renderer_preferred_state *pref_state); +// Changes the resolution of the renderer +void rend_SetResolution(int width, int height); + // Shuts down OpenGL in a window void rend_CloseOpenGLWindow(); @@ -680,9 +728,20 @@ void rend_CopyBitmapToFramebuffer(int bm_handle, int x, int y); // Gets a renderer ready for a framebuffer copy, or stops a framebuffer copy void rend_SetFrameBufferCopyState(bool state); +void rend_UpdateCommon(float *projection, float *modelview); + +// These are temporary, used to test shader code. +// Use the test shader. +void rend_UseShaderTest(void); + +// Revert to non-shader rendering +void rend_EndShaderTest(void); + +#if defined(DD_ACCESS_RING) #if defined(WIN32) // returns the direct draw object void *rend_RetrieveDirectDrawObj(void **frontsurf, void **backsurf); #endif +#endif #endif diff --git a/lib/wglext.h b/lib/wglext.h new file mode 100644 index 000000000..453c195cb --- /dev/null +++ b/lib/wglext.h @@ -0,0 +1,845 @@ +#ifndef __wgl_wglext_h_ +#define __wgl_wglext_h_ 1 + +#ifdef __cplusplus +extern "C" { +#endif + +/* +** Copyright 2013-2020 The Khronos Group Inc. +** SPDX-License-Identifier: MIT +** +** This header is generated from the Khronos OpenGL / OpenGL ES XML +** API Registry. The current version of the Registry, generator scripts +** used to make the header, and the header can be found at +** https://github.com/KhronosGroup/OpenGL-Registry +*/ + +#if defined(_WIN32) && !defined(APIENTRY) && !defined(__CYGWIN__) && !defined(__SCITECH_SNAP__) +#define WIN32_LEAN_AND_MEAN 1 +#include +#endif + +#define WGL_WGLEXT_VERSION 20231018 + +/* Generated C header for: + * API: wgl + * Versions considered: .* + * Versions emitted: _nomatch_^ + * Default extensions included: wgl + * Additional extensions included: _nomatch_^ + * Extensions removed: _nomatch_^ + */ + +#ifndef WGL_ARB_buffer_region +#define WGL_ARB_buffer_region 1 +#define WGL_FRONT_COLOR_BUFFER_BIT_ARB 0x00000001 +#define WGL_BACK_COLOR_BUFFER_BIT_ARB 0x00000002 +#define WGL_DEPTH_BUFFER_BIT_ARB 0x00000004 +#define WGL_STENCIL_BUFFER_BIT_ARB 0x00000008 +typedef HANDLE (WINAPI * PFNWGLCREATEBUFFERREGIONARBPROC) (HDC hDC, int iLayerPlane, UINT uType); +typedef VOID (WINAPI * PFNWGLDELETEBUFFERREGIONARBPROC) (HANDLE hRegion); +typedef BOOL (WINAPI * PFNWGLSAVEBUFFERREGIONARBPROC) (HANDLE hRegion, int x, int y, int width, int height); +typedef BOOL (WINAPI * PFNWGLRESTOREBUFFERREGIONARBPROC) (HANDLE hRegion, int x, int y, int width, int height, int xSrc, int ySrc); +#ifdef WGL_WGLEXT_PROTOTYPES +HANDLE WINAPI wglCreateBufferRegionARB (HDC hDC, int iLayerPlane, UINT uType); +VOID WINAPI wglDeleteBufferRegionARB (HANDLE hRegion); +BOOL WINAPI wglSaveBufferRegionARB (HANDLE hRegion, int x, int y, int width, int height); +BOOL WINAPI wglRestoreBufferRegionARB (HANDLE hRegion, int x, int y, int width, int height, int xSrc, int ySrc); +#endif +#endif /* WGL_ARB_buffer_region */ + +#ifndef WGL_ARB_context_flush_control +#define WGL_ARB_context_flush_control 1 +#define WGL_CONTEXT_RELEASE_BEHAVIOR_ARB 0x2097 +#define WGL_CONTEXT_RELEASE_BEHAVIOR_NONE_ARB 0 +#define WGL_CONTEXT_RELEASE_BEHAVIOR_FLUSH_ARB 0x2098 +#endif /* WGL_ARB_context_flush_control */ + +#ifndef WGL_ARB_create_context +#define WGL_ARB_create_context 1 +#define WGL_CONTEXT_DEBUG_BIT_ARB 0x00000001 +#define WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB 0x00000002 +#define WGL_CONTEXT_MAJOR_VERSION_ARB 0x2091 +#define WGL_CONTEXT_MINOR_VERSION_ARB 0x2092 +#define WGL_CONTEXT_LAYER_PLANE_ARB 0x2093 +#define WGL_CONTEXT_FLAGS_ARB 0x2094 +#define ERROR_INVALID_VERSION_ARB 0x2095 +typedef HGLRC (WINAPI * PFNWGLCREATECONTEXTATTRIBSARBPROC) (HDC hDC, HGLRC hShareContext, const int *attribList); +#ifdef WGL_WGLEXT_PROTOTYPES +HGLRC WINAPI wglCreateContextAttribsARB (HDC hDC, HGLRC hShareContext, const int *attribList); +#endif +#endif /* WGL_ARB_create_context */ + +#ifndef WGL_ARB_create_context_no_error +#define WGL_ARB_create_context_no_error 1 +#define WGL_CONTEXT_OPENGL_NO_ERROR_ARB 0x31B3 +#endif /* WGL_ARB_create_context_no_error */ + +#ifndef WGL_ARB_create_context_profile +#define WGL_ARB_create_context_profile 1 +#define WGL_CONTEXT_PROFILE_MASK_ARB 0x9126 +#define WGL_CONTEXT_CORE_PROFILE_BIT_ARB 0x00000001 +#define WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB 0x00000002 +#define ERROR_INVALID_PROFILE_ARB 0x2096 +#endif /* WGL_ARB_create_context_profile */ + +#ifndef WGL_ARB_create_context_robustness +#define WGL_ARB_create_context_robustness 1 +#define WGL_CONTEXT_ROBUST_ACCESS_BIT_ARB 0x00000004 +#define WGL_LOSE_CONTEXT_ON_RESET_ARB 0x8252 +#define WGL_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB 0x8256 +#define WGL_NO_RESET_NOTIFICATION_ARB 0x8261 +#endif /* WGL_ARB_create_context_robustness */ + +#ifndef WGL_ARB_extensions_string +#define WGL_ARB_extensions_string 1 +typedef const char *(WINAPI * PFNWGLGETEXTENSIONSSTRINGARBPROC) (HDC hdc); +#ifdef WGL_WGLEXT_PROTOTYPES +const char *WINAPI wglGetExtensionsStringARB (HDC hdc); +#endif +#endif /* WGL_ARB_extensions_string */ + +#ifndef WGL_ARB_framebuffer_sRGB +#define WGL_ARB_framebuffer_sRGB 1 +#define WGL_FRAMEBUFFER_SRGB_CAPABLE_ARB 0x20A9 +#endif /* WGL_ARB_framebuffer_sRGB */ + +#ifndef WGL_ARB_make_current_read +#define WGL_ARB_make_current_read 1 +#define ERROR_INVALID_PIXEL_TYPE_ARB 0x2043 +#define ERROR_INCOMPATIBLE_DEVICE_CONTEXTS_ARB 0x2054 +typedef BOOL (WINAPI * PFNWGLMAKECONTEXTCURRENTARBPROC) (HDC hDrawDC, HDC hReadDC, HGLRC hglrc); +typedef HDC (WINAPI * PFNWGLGETCURRENTREADDCARBPROC) (void); +#ifdef WGL_WGLEXT_PROTOTYPES +BOOL WINAPI wglMakeContextCurrentARB (HDC hDrawDC, HDC hReadDC, HGLRC hglrc); +HDC WINAPI wglGetCurrentReadDCARB (void); +#endif +#endif /* WGL_ARB_make_current_read */ + +#ifndef WGL_ARB_multisample +#define WGL_ARB_multisample 1 +#define WGL_SAMPLE_BUFFERS_ARB 0x2041 +#define WGL_SAMPLES_ARB 0x2042 +#endif /* WGL_ARB_multisample */ + +#ifndef WGL_ARB_pbuffer +#define WGL_ARB_pbuffer 1 +DECLARE_HANDLE(HPBUFFERARB); +#define WGL_DRAW_TO_PBUFFER_ARB 0x202D +#define WGL_MAX_PBUFFER_PIXELS_ARB 0x202E +#define WGL_MAX_PBUFFER_WIDTH_ARB 0x202F +#define WGL_MAX_PBUFFER_HEIGHT_ARB 0x2030 +#define WGL_PBUFFER_LARGEST_ARB 0x2033 +#define WGL_PBUFFER_WIDTH_ARB 0x2034 +#define WGL_PBUFFER_HEIGHT_ARB 0x2035 +#define WGL_PBUFFER_LOST_ARB 0x2036 +typedef HPBUFFERARB (WINAPI * PFNWGLCREATEPBUFFERARBPROC) (HDC hDC, int iPixelFormat, int iWidth, int iHeight, const int *piAttribList); +typedef HDC (WINAPI * PFNWGLGETPBUFFERDCARBPROC) (HPBUFFERARB hPbuffer); +typedef int (WINAPI * PFNWGLRELEASEPBUFFERDCARBPROC) (HPBUFFERARB hPbuffer, HDC hDC); +typedef BOOL (WINAPI * PFNWGLDESTROYPBUFFERARBPROC) (HPBUFFERARB hPbuffer); +typedef BOOL (WINAPI * PFNWGLQUERYPBUFFERARBPROC) (HPBUFFERARB hPbuffer, int iAttribute, int *piValue); +#ifdef WGL_WGLEXT_PROTOTYPES +HPBUFFERARB WINAPI wglCreatePbufferARB (HDC hDC, int iPixelFormat, int iWidth, int iHeight, const int *piAttribList); +HDC WINAPI wglGetPbufferDCARB (HPBUFFERARB hPbuffer); +int WINAPI wglReleasePbufferDCARB (HPBUFFERARB hPbuffer, HDC hDC); +BOOL WINAPI wglDestroyPbufferARB (HPBUFFERARB hPbuffer); +BOOL WINAPI wglQueryPbufferARB (HPBUFFERARB hPbuffer, int iAttribute, int *piValue); +#endif +#endif /* WGL_ARB_pbuffer */ + +#ifndef WGL_ARB_pixel_format +#define WGL_ARB_pixel_format 1 +#define WGL_NUMBER_PIXEL_FORMATS_ARB 0x2000 +#define WGL_DRAW_TO_WINDOW_ARB 0x2001 +#define WGL_DRAW_TO_BITMAP_ARB 0x2002 +#define WGL_ACCELERATION_ARB 0x2003 +#define WGL_NEED_PALETTE_ARB 0x2004 +#define WGL_NEED_SYSTEM_PALETTE_ARB 0x2005 +#define WGL_SWAP_LAYER_BUFFERS_ARB 0x2006 +#define WGL_SWAP_METHOD_ARB 0x2007 +#define WGL_NUMBER_OVERLAYS_ARB 0x2008 +#define WGL_NUMBER_UNDERLAYS_ARB 0x2009 +#define WGL_TRANSPARENT_ARB 0x200A +#define WGL_TRANSPARENT_RED_VALUE_ARB 0x2037 +#define WGL_TRANSPARENT_GREEN_VALUE_ARB 0x2038 +#define WGL_TRANSPARENT_BLUE_VALUE_ARB 0x2039 +#define WGL_TRANSPARENT_ALPHA_VALUE_ARB 0x203A +#define WGL_TRANSPARENT_INDEX_VALUE_ARB 0x203B +#define WGL_SHARE_DEPTH_ARB 0x200C +#define WGL_SHARE_STENCIL_ARB 0x200D +#define WGL_SHARE_ACCUM_ARB 0x200E +#define WGL_SUPPORT_GDI_ARB 0x200F +#define WGL_SUPPORT_OPENGL_ARB 0x2010 +#define WGL_DOUBLE_BUFFER_ARB 0x2011 +#define WGL_STEREO_ARB 0x2012 +#define WGL_PIXEL_TYPE_ARB 0x2013 +#define WGL_COLOR_BITS_ARB 0x2014 +#define WGL_RED_BITS_ARB 0x2015 +#define WGL_RED_SHIFT_ARB 0x2016 +#define WGL_GREEN_BITS_ARB 0x2017 +#define WGL_GREEN_SHIFT_ARB 0x2018 +#define WGL_BLUE_BITS_ARB 0x2019 +#define WGL_BLUE_SHIFT_ARB 0x201A +#define WGL_ALPHA_BITS_ARB 0x201B +#define WGL_ALPHA_SHIFT_ARB 0x201C +#define WGL_ACCUM_BITS_ARB 0x201D +#define WGL_ACCUM_RED_BITS_ARB 0x201E +#define WGL_ACCUM_GREEN_BITS_ARB 0x201F +#define WGL_ACCUM_BLUE_BITS_ARB 0x2020 +#define WGL_ACCUM_ALPHA_BITS_ARB 0x2021 +#define WGL_DEPTH_BITS_ARB 0x2022 +#define WGL_STENCIL_BITS_ARB 0x2023 +#define WGL_AUX_BUFFERS_ARB 0x2024 +#define WGL_NO_ACCELERATION_ARB 0x2025 +#define WGL_GENERIC_ACCELERATION_ARB 0x2026 +#define WGL_FULL_ACCELERATION_ARB 0x2027 +#define WGL_SWAP_EXCHANGE_ARB 0x2028 +#define WGL_SWAP_COPY_ARB 0x2029 +#define WGL_SWAP_UNDEFINED_ARB 0x202A +#define WGL_TYPE_RGBA_ARB 0x202B +#define WGL_TYPE_COLORINDEX_ARB 0x202C +typedef BOOL (WINAPI * PFNWGLGETPIXELFORMATATTRIBIVARBPROC) (HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, const int *piAttributes, int *piValues); +typedef BOOL (WINAPI * PFNWGLGETPIXELFORMATATTRIBFVARBPROC) (HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, const int *piAttributes, FLOAT *pfValues); +typedef BOOL (WINAPI * PFNWGLCHOOSEPIXELFORMATARBPROC) (HDC hdc, const int *piAttribIList, const FLOAT *pfAttribFList, UINT nMaxFormats, int *piFormats, UINT *nNumFormats); +#ifdef WGL_WGLEXT_PROTOTYPES +BOOL WINAPI wglGetPixelFormatAttribivARB (HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, const int *piAttributes, int *piValues); +BOOL WINAPI wglGetPixelFormatAttribfvARB (HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, const int *piAttributes, FLOAT *pfValues); +BOOL WINAPI wglChoosePixelFormatARB (HDC hdc, const int *piAttribIList, const FLOAT *pfAttribFList, UINT nMaxFormats, int *piFormats, UINT *nNumFormats); +#endif +#endif /* WGL_ARB_pixel_format */ + +#ifndef WGL_ARB_pixel_format_float +#define WGL_ARB_pixel_format_float 1 +#define WGL_TYPE_RGBA_FLOAT_ARB 0x21A0 +#endif /* WGL_ARB_pixel_format_float */ + +#ifndef WGL_ARB_render_texture +#define WGL_ARB_render_texture 1 +#define WGL_BIND_TO_TEXTURE_RGB_ARB 0x2070 +#define WGL_BIND_TO_TEXTURE_RGBA_ARB 0x2071 +#define WGL_TEXTURE_FORMAT_ARB 0x2072 +#define WGL_TEXTURE_TARGET_ARB 0x2073 +#define WGL_MIPMAP_TEXTURE_ARB 0x2074 +#define WGL_TEXTURE_RGB_ARB 0x2075 +#define WGL_TEXTURE_RGBA_ARB 0x2076 +#define WGL_NO_TEXTURE_ARB 0x2077 +#define WGL_TEXTURE_CUBE_MAP_ARB 0x2078 +#define WGL_TEXTURE_1D_ARB 0x2079 +#define WGL_TEXTURE_2D_ARB 0x207A +#define WGL_MIPMAP_LEVEL_ARB 0x207B +#define WGL_CUBE_MAP_FACE_ARB 0x207C +#define WGL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB 0x207D +#define WGL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB 0x207E +#define WGL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB 0x207F +#define WGL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB 0x2080 +#define WGL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB 0x2081 +#define WGL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB 0x2082 +#define WGL_FRONT_LEFT_ARB 0x2083 +#define WGL_FRONT_RIGHT_ARB 0x2084 +#define WGL_BACK_LEFT_ARB 0x2085 +#define WGL_BACK_RIGHT_ARB 0x2086 +#define WGL_AUX0_ARB 0x2087 +#define WGL_AUX1_ARB 0x2088 +#define WGL_AUX2_ARB 0x2089 +#define WGL_AUX3_ARB 0x208A +#define WGL_AUX4_ARB 0x208B +#define WGL_AUX5_ARB 0x208C +#define WGL_AUX6_ARB 0x208D +#define WGL_AUX7_ARB 0x208E +#define WGL_AUX8_ARB 0x208F +#define WGL_AUX9_ARB 0x2090 +typedef BOOL (WINAPI * PFNWGLBINDTEXIMAGEARBPROC) (HPBUFFERARB hPbuffer, int iBuffer); +typedef BOOL (WINAPI * PFNWGLRELEASETEXIMAGEARBPROC) (HPBUFFERARB hPbuffer, int iBuffer); +typedef BOOL (WINAPI * PFNWGLSETPBUFFERATTRIBARBPROC) (HPBUFFERARB hPbuffer, const int *piAttribList); +#ifdef WGL_WGLEXT_PROTOTYPES +BOOL WINAPI wglBindTexImageARB (HPBUFFERARB hPbuffer, int iBuffer); +BOOL WINAPI wglReleaseTexImageARB (HPBUFFERARB hPbuffer, int iBuffer); +BOOL WINAPI wglSetPbufferAttribARB (HPBUFFERARB hPbuffer, const int *piAttribList); +#endif +#endif /* WGL_ARB_render_texture */ + +#ifndef WGL_ARB_robustness_application_isolation +#define WGL_ARB_robustness_application_isolation 1 +#define WGL_CONTEXT_RESET_ISOLATION_BIT_ARB 0x00000008 +#endif /* WGL_ARB_robustness_application_isolation */ + +#ifndef WGL_ARB_robustness_share_group_isolation +#define WGL_ARB_robustness_share_group_isolation 1 +#endif /* WGL_ARB_robustness_share_group_isolation */ + +#ifndef WGL_3DFX_multisample +#define WGL_3DFX_multisample 1 +#define WGL_SAMPLE_BUFFERS_3DFX 0x2060 +#define WGL_SAMPLES_3DFX 0x2061 +#endif /* WGL_3DFX_multisample */ + +#ifndef WGL_3DL_stereo_control +#define WGL_3DL_stereo_control 1 +#define WGL_STEREO_EMITTER_ENABLE_3DL 0x2055 +#define WGL_STEREO_EMITTER_DISABLE_3DL 0x2056 +#define WGL_STEREO_POLARITY_NORMAL_3DL 0x2057 +#define WGL_STEREO_POLARITY_INVERT_3DL 0x2058 +typedef BOOL (WINAPI * PFNWGLSETSTEREOEMITTERSTATE3DLPROC) (HDC hDC, UINT uState); +#ifdef WGL_WGLEXT_PROTOTYPES +BOOL WINAPI wglSetStereoEmitterState3DL (HDC hDC, UINT uState); +#endif +#endif /* WGL_3DL_stereo_control */ + +#ifndef WGL_AMD_gpu_association +#define WGL_AMD_gpu_association 1 +#define WGL_GPU_VENDOR_AMD 0x1F00 +#define WGL_GPU_RENDERER_STRING_AMD 0x1F01 +#define WGL_GPU_OPENGL_VERSION_STRING_AMD 0x1F02 +#define WGL_GPU_FASTEST_TARGET_GPUS_AMD 0x21A2 +#define WGL_GPU_RAM_AMD 0x21A3 +#define WGL_GPU_CLOCK_AMD 0x21A4 +#define WGL_GPU_NUM_PIPES_AMD 0x21A5 +#define WGL_GPU_NUM_SIMD_AMD 0x21A6 +#define WGL_GPU_NUM_RB_AMD 0x21A7 +#define WGL_GPU_NUM_SPI_AMD 0x21A8 +typedef UINT (WINAPI * PFNWGLGETGPUIDSAMDPROC) (UINT maxCount, UINT *ids); +typedef INT (WINAPI * PFNWGLGETGPUINFOAMDPROC) (UINT id, INT property, GLenum dataType, UINT size, void *data); +typedef UINT (WINAPI * PFNWGLGETCONTEXTGPUIDAMDPROC) (HGLRC hglrc); +typedef HGLRC (WINAPI * PFNWGLCREATEASSOCIATEDCONTEXTAMDPROC) (UINT id); +typedef HGLRC (WINAPI * PFNWGLCREATEASSOCIATEDCONTEXTATTRIBSAMDPROC) (UINT id, HGLRC hShareContext, const int *attribList); +typedef BOOL (WINAPI * PFNWGLDELETEASSOCIATEDCONTEXTAMDPROC) (HGLRC hglrc); +typedef BOOL (WINAPI * PFNWGLMAKEASSOCIATEDCONTEXTCURRENTAMDPROC) (HGLRC hglrc); +typedef HGLRC (WINAPI * PFNWGLGETCURRENTASSOCIATEDCONTEXTAMDPROC) (void); +typedef VOID (WINAPI * PFNWGLBLITCONTEXTFRAMEBUFFERAMDPROC) (HGLRC dstCtx, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter); +#ifdef WGL_WGLEXT_PROTOTYPES +UINT WINAPI wglGetGPUIDsAMD (UINT maxCount, UINT *ids); +INT WINAPI wglGetGPUInfoAMD (UINT id, INT property, GLenum dataType, UINT size, void *data); +UINT WINAPI wglGetContextGPUIDAMD (HGLRC hglrc); +HGLRC WINAPI wglCreateAssociatedContextAMD (UINT id); +HGLRC WINAPI wglCreateAssociatedContextAttribsAMD (UINT id, HGLRC hShareContext, const int *attribList); +BOOL WINAPI wglDeleteAssociatedContextAMD (HGLRC hglrc); +BOOL WINAPI wglMakeAssociatedContextCurrentAMD (HGLRC hglrc); +HGLRC WINAPI wglGetCurrentAssociatedContextAMD (void); +VOID WINAPI wglBlitContextFramebufferAMD (HGLRC dstCtx, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter); +#endif +#endif /* WGL_AMD_gpu_association */ + +#ifndef WGL_ATI_pixel_format_float +#define WGL_ATI_pixel_format_float 1 +#define WGL_TYPE_RGBA_FLOAT_ATI 0x21A0 +#endif /* WGL_ATI_pixel_format_float */ + +#ifndef WGL_ATI_render_texture_rectangle +#define WGL_ATI_render_texture_rectangle 1 +#define WGL_TEXTURE_RECTANGLE_ATI 0x21A5 +#endif /* WGL_ATI_render_texture_rectangle */ + +#ifndef WGL_EXT_colorspace +#define WGL_EXT_colorspace 1 +#define WGL_COLORSPACE_EXT 0x309D +#define WGL_COLORSPACE_SRGB_EXT 0x3089 +#define WGL_COLORSPACE_LINEAR_EXT 0x308A +#endif /* WGL_EXT_colorspace */ + +#ifndef WGL_EXT_create_context_es2_profile +#define WGL_EXT_create_context_es2_profile 1 +#define WGL_CONTEXT_ES2_PROFILE_BIT_EXT 0x00000004 +#endif /* WGL_EXT_create_context_es2_profile */ + +#ifndef WGL_EXT_create_context_es_profile +#define WGL_EXT_create_context_es_profile 1 +#define WGL_CONTEXT_ES_PROFILE_BIT_EXT 0x00000004 +#endif /* WGL_EXT_create_context_es_profile */ + +#ifndef WGL_EXT_depth_float +#define WGL_EXT_depth_float 1 +#define WGL_DEPTH_FLOAT_EXT 0x2040 +#endif /* WGL_EXT_depth_float */ + +#ifndef WGL_EXT_display_color_table +#define WGL_EXT_display_color_table 1 +typedef GLboolean (WINAPI * PFNWGLCREATEDISPLAYCOLORTABLEEXTPROC) (GLushort id); +typedef GLboolean (WINAPI * PFNWGLLOADDISPLAYCOLORTABLEEXTPROC) (const GLushort *table, GLuint length); +typedef GLboolean (WINAPI * PFNWGLBINDDISPLAYCOLORTABLEEXTPROC) (GLushort id); +typedef VOID (WINAPI * PFNWGLDESTROYDISPLAYCOLORTABLEEXTPROC) (GLushort id); +#ifdef WGL_WGLEXT_PROTOTYPES +GLboolean WINAPI wglCreateDisplayColorTableEXT (GLushort id); +GLboolean WINAPI wglLoadDisplayColorTableEXT (const GLushort *table, GLuint length); +GLboolean WINAPI wglBindDisplayColorTableEXT (GLushort id); +VOID WINAPI wglDestroyDisplayColorTableEXT (GLushort id); +#endif +#endif /* WGL_EXT_display_color_table */ + +#ifndef WGL_EXT_extensions_string +#define WGL_EXT_extensions_string 1 +typedef const char *(WINAPI * PFNWGLGETEXTENSIONSSTRINGEXTPROC) (void); +#ifdef WGL_WGLEXT_PROTOTYPES +const char *WINAPI wglGetExtensionsStringEXT (void); +#endif +#endif /* WGL_EXT_extensions_string */ + +#ifndef WGL_EXT_framebuffer_sRGB +#define WGL_EXT_framebuffer_sRGB 1 +#define WGL_FRAMEBUFFER_SRGB_CAPABLE_EXT 0x20A9 +#endif /* WGL_EXT_framebuffer_sRGB */ + +#ifndef WGL_EXT_make_current_read +#define WGL_EXT_make_current_read 1 +#define ERROR_INVALID_PIXEL_TYPE_EXT 0x2043 +typedef BOOL (WINAPI * PFNWGLMAKECONTEXTCURRENTEXTPROC) (HDC hDrawDC, HDC hReadDC, HGLRC hglrc); +typedef HDC (WINAPI * PFNWGLGETCURRENTREADDCEXTPROC) (void); +#ifdef WGL_WGLEXT_PROTOTYPES +BOOL WINAPI wglMakeContextCurrentEXT (HDC hDrawDC, HDC hReadDC, HGLRC hglrc); +HDC WINAPI wglGetCurrentReadDCEXT (void); +#endif +#endif /* WGL_EXT_make_current_read */ + +#ifndef WGL_EXT_multisample +#define WGL_EXT_multisample 1 +#define WGL_SAMPLE_BUFFERS_EXT 0x2041 +#define WGL_SAMPLES_EXT 0x2042 +#endif /* WGL_EXT_multisample */ + +#ifndef WGL_EXT_pbuffer +#define WGL_EXT_pbuffer 1 +DECLARE_HANDLE(HPBUFFEREXT); +#define WGL_DRAW_TO_PBUFFER_EXT 0x202D +#define WGL_MAX_PBUFFER_PIXELS_EXT 0x202E +#define WGL_MAX_PBUFFER_WIDTH_EXT 0x202F +#define WGL_MAX_PBUFFER_HEIGHT_EXT 0x2030 +#define WGL_OPTIMAL_PBUFFER_WIDTH_EXT 0x2031 +#define WGL_OPTIMAL_PBUFFER_HEIGHT_EXT 0x2032 +#define WGL_PBUFFER_LARGEST_EXT 0x2033 +#define WGL_PBUFFER_WIDTH_EXT 0x2034 +#define WGL_PBUFFER_HEIGHT_EXT 0x2035 +typedef HPBUFFEREXT (WINAPI * PFNWGLCREATEPBUFFEREXTPROC) (HDC hDC, int iPixelFormat, int iWidth, int iHeight, const int *piAttribList); +typedef HDC (WINAPI * PFNWGLGETPBUFFERDCEXTPROC) (HPBUFFEREXT hPbuffer); +typedef int (WINAPI * PFNWGLRELEASEPBUFFERDCEXTPROC) (HPBUFFEREXT hPbuffer, HDC hDC); +typedef BOOL (WINAPI * PFNWGLDESTROYPBUFFEREXTPROC) (HPBUFFEREXT hPbuffer); +typedef BOOL (WINAPI * PFNWGLQUERYPBUFFEREXTPROC) (HPBUFFEREXT hPbuffer, int iAttribute, int *piValue); +#ifdef WGL_WGLEXT_PROTOTYPES +HPBUFFEREXT WINAPI wglCreatePbufferEXT (HDC hDC, int iPixelFormat, int iWidth, int iHeight, const int *piAttribList); +HDC WINAPI wglGetPbufferDCEXT (HPBUFFEREXT hPbuffer); +int WINAPI wglReleasePbufferDCEXT (HPBUFFEREXT hPbuffer, HDC hDC); +BOOL WINAPI wglDestroyPbufferEXT (HPBUFFEREXT hPbuffer); +BOOL WINAPI wglQueryPbufferEXT (HPBUFFEREXT hPbuffer, int iAttribute, int *piValue); +#endif +#endif /* WGL_EXT_pbuffer */ + +#ifndef WGL_EXT_pixel_format +#define WGL_EXT_pixel_format 1 +#define WGL_NUMBER_PIXEL_FORMATS_EXT 0x2000 +#define WGL_DRAW_TO_WINDOW_EXT 0x2001 +#define WGL_DRAW_TO_BITMAP_EXT 0x2002 +#define WGL_ACCELERATION_EXT 0x2003 +#define WGL_NEED_PALETTE_EXT 0x2004 +#define WGL_NEED_SYSTEM_PALETTE_EXT 0x2005 +#define WGL_SWAP_LAYER_BUFFERS_EXT 0x2006 +#define WGL_SWAP_METHOD_EXT 0x2007 +#define WGL_NUMBER_OVERLAYS_EXT 0x2008 +#define WGL_NUMBER_UNDERLAYS_EXT 0x2009 +#define WGL_TRANSPARENT_EXT 0x200A +#define WGL_TRANSPARENT_VALUE_EXT 0x200B +#define WGL_SHARE_DEPTH_EXT 0x200C +#define WGL_SHARE_STENCIL_EXT 0x200D +#define WGL_SHARE_ACCUM_EXT 0x200E +#define WGL_SUPPORT_GDI_EXT 0x200F +#define WGL_SUPPORT_OPENGL_EXT 0x2010 +#define WGL_DOUBLE_BUFFER_EXT 0x2011 +#define WGL_STEREO_EXT 0x2012 +#define WGL_PIXEL_TYPE_EXT 0x2013 +#define WGL_COLOR_BITS_EXT 0x2014 +#define WGL_RED_BITS_EXT 0x2015 +#define WGL_RED_SHIFT_EXT 0x2016 +#define WGL_GREEN_BITS_EXT 0x2017 +#define WGL_GREEN_SHIFT_EXT 0x2018 +#define WGL_BLUE_BITS_EXT 0x2019 +#define WGL_BLUE_SHIFT_EXT 0x201A +#define WGL_ALPHA_BITS_EXT 0x201B +#define WGL_ALPHA_SHIFT_EXT 0x201C +#define WGL_ACCUM_BITS_EXT 0x201D +#define WGL_ACCUM_RED_BITS_EXT 0x201E +#define WGL_ACCUM_GREEN_BITS_EXT 0x201F +#define WGL_ACCUM_BLUE_BITS_EXT 0x2020 +#define WGL_ACCUM_ALPHA_BITS_EXT 0x2021 +#define WGL_DEPTH_BITS_EXT 0x2022 +#define WGL_STENCIL_BITS_EXT 0x2023 +#define WGL_AUX_BUFFERS_EXT 0x2024 +#define WGL_NO_ACCELERATION_EXT 0x2025 +#define WGL_GENERIC_ACCELERATION_EXT 0x2026 +#define WGL_FULL_ACCELERATION_EXT 0x2027 +#define WGL_SWAP_EXCHANGE_EXT 0x2028 +#define WGL_SWAP_COPY_EXT 0x2029 +#define WGL_SWAP_UNDEFINED_EXT 0x202A +#define WGL_TYPE_RGBA_EXT 0x202B +#define WGL_TYPE_COLORINDEX_EXT 0x202C +typedef BOOL (WINAPI * PFNWGLGETPIXELFORMATATTRIBIVEXTPROC) (HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, int *piAttributes, int *piValues); +typedef BOOL (WINAPI * PFNWGLGETPIXELFORMATATTRIBFVEXTPROC) (HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, int *piAttributes, FLOAT *pfValues); +typedef BOOL (WINAPI * PFNWGLCHOOSEPIXELFORMATEXTPROC) (HDC hdc, const int *piAttribIList, const FLOAT *pfAttribFList, UINT nMaxFormats, int *piFormats, UINT *nNumFormats); +#ifdef WGL_WGLEXT_PROTOTYPES +BOOL WINAPI wglGetPixelFormatAttribivEXT (HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, int *piAttributes, int *piValues); +BOOL WINAPI wglGetPixelFormatAttribfvEXT (HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, int *piAttributes, FLOAT *pfValues); +BOOL WINAPI wglChoosePixelFormatEXT (HDC hdc, const int *piAttribIList, const FLOAT *pfAttribFList, UINT nMaxFormats, int *piFormats, UINT *nNumFormats); +#endif +#endif /* WGL_EXT_pixel_format */ + +#ifndef WGL_EXT_pixel_format_packed_float +#define WGL_EXT_pixel_format_packed_float 1 +#define WGL_TYPE_RGBA_UNSIGNED_FLOAT_EXT 0x20A8 +#endif /* WGL_EXT_pixel_format_packed_float */ + +#ifndef WGL_EXT_swap_control +#define WGL_EXT_swap_control 1 +typedef BOOL (WINAPI * PFNWGLSWAPINTERVALEXTPROC) (int interval); +typedef int (WINAPI * PFNWGLGETSWAPINTERVALEXTPROC) (void); +#ifdef WGL_WGLEXT_PROTOTYPES +BOOL WINAPI wglSwapIntervalEXT (int interval); +int WINAPI wglGetSwapIntervalEXT (void); +#endif +#endif /* WGL_EXT_swap_control */ + +#ifndef WGL_EXT_swap_control_tear +#define WGL_EXT_swap_control_tear 1 +#endif /* WGL_EXT_swap_control_tear */ + +#ifndef WGL_I3D_digital_video_control +#define WGL_I3D_digital_video_control 1 +#define WGL_DIGITAL_VIDEO_CURSOR_ALPHA_FRAMEBUFFER_I3D 0x2050 +#define WGL_DIGITAL_VIDEO_CURSOR_ALPHA_VALUE_I3D 0x2051 +#define WGL_DIGITAL_VIDEO_CURSOR_INCLUDED_I3D 0x2052 +#define WGL_DIGITAL_VIDEO_GAMMA_CORRECTED_I3D 0x2053 +typedef BOOL (WINAPI * PFNWGLGETDIGITALVIDEOPARAMETERSI3DPROC) (HDC hDC, int iAttribute, int *piValue); +typedef BOOL (WINAPI * PFNWGLSETDIGITALVIDEOPARAMETERSI3DPROC) (HDC hDC, int iAttribute, const int *piValue); +#ifdef WGL_WGLEXT_PROTOTYPES +BOOL WINAPI wglGetDigitalVideoParametersI3D (HDC hDC, int iAttribute, int *piValue); +BOOL WINAPI wglSetDigitalVideoParametersI3D (HDC hDC, int iAttribute, const int *piValue); +#endif +#endif /* WGL_I3D_digital_video_control */ + +#ifndef WGL_I3D_gamma +#define WGL_I3D_gamma 1 +#define WGL_GAMMA_TABLE_SIZE_I3D 0x204E +#define WGL_GAMMA_EXCLUDE_DESKTOP_I3D 0x204F +typedef BOOL (WINAPI * PFNWGLGETGAMMATABLEPARAMETERSI3DPROC) (HDC hDC, int iAttribute, int *piValue); +typedef BOOL (WINAPI * PFNWGLSETGAMMATABLEPARAMETERSI3DPROC) (HDC hDC, int iAttribute, const int *piValue); +typedef BOOL (WINAPI * PFNWGLGETGAMMATABLEI3DPROC) (HDC hDC, int iEntries, USHORT *puRed, USHORT *puGreen, USHORT *puBlue); +typedef BOOL (WINAPI * PFNWGLSETGAMMATABLEI3DPROC) (HDC hDC, int iEntries, const USHORT *puRed, const USHORT *puGreen, const USHORT *puBlue); +#ifdef WGL_WGLEXT_PROTOTYPES +BOOL WINAPI wglGetGammaTableParametersI3D (HDC hDC, int iAttribute, int *piValue); +BOOL WINAPI wglSetGammaTableParametersI3D (HDC hDC, int iAttribute, const int *piValue); +BOOL WINAPI wglGetGammaTableI3D (HDC hDC, int iEntries, USHORT *puRed, USHORT *puGreen, USHORT *puBlue); +BOOL WINAPI wglSetGammaTableI3D (HDC hDC, int iEntries, const USHORT *puRed, const USHORT *puGreen, const USHORT *puBlue); +#endif +#endif /* WGL_I3D_gamma */ + +#ifndef WGL_I3D_genlock +#define WGL_I3D_genlock 1 +#define WGL_GENLOCK_SOURCE_MULTIVIEW_I3D 0x2044 +#define WGL_GENLOCK_SOURCE_EXTERNAL_SYNC_I3D 0x2045 +#define WGL_GENLOCK_SOURCE_EXTERNAL_FIELD_I3D 0x2046 +#define WGL_GENLOCK_SOURCE_EXTERNAL_TTL_I3D 0x2047 +#define WGL_GENLOCK_SOURCE_DIGITAL_SYNC_I3D 0x2048 +#define WGL_GENLOCK_SOURCE_DIGITAL_FIELD_I3D 0x2049 +#define WGL_GENLOCK_SOURCE_EDGE_FALLING_I3D 0x204A +#define WGL_GENLOCK_SOURCE_EDGE_RISING_I3D 0x204B +#define WGL_GENLOCK_SOURCE_EDGE_BOTH_I3D 0x204C +typedef BOOL (WINAPI * PFNWGLENABLEGENLOCKI3DPROC) (HDC hDC); +typedef BOOL (WINAPI * PFNWGLDISABLEGENLOCKI3DPROC) (HDC hDC); +typedef BOOL (WINAPI * PFNWGLISENABLEDGENLOCKI3DPROC) (HDC hDC, BOOL *pFlag); +typedef BOOL (WINAPI * PFNWGLGENLOCKSOURCEI3DPROC) (HDC hDC, UINT uSource); +typedef BOOL (WINAPI * PFNWGLGETGENLOCKSOURCEI3DPROC) (HDC hDC, UINT *uSource); +typedef BOOL (WINAPI * PFNWGLGENLOCKSOURCEEDGEI3DPROC) (HDC hDC, UINT uEdge); +typedef BOOL (WINAPI * PFNWGLGETGENLOCKSOURCEEDGEI3DPROC) (HDC hDC, UINT *uEdge); +typedef BOOL (WINAPI * PFNWGLGENLOCKSAMPLERATEI3DPROC) (HDC hDC, UINT uRate); +typedef BOOL (WINAPI * PFNWGLGETGENLOCKSAMPLERATEI3DPROC) (HDC hDC, UINT *uRate); +typedef BOOL (WINAPI * PFNWGLGENLOCKSOURCEDELAYI3DPROC) (HDC hDC, UINT uDelay); +typedef BOOL (WINAPI * PFNWGLGETGENLOCKSOURCEDELAYI3DPROC) (HDC hDC, UINT *uDelay); +typedef BOOL (WINAPI * PFNWGLQUERYGENLOCKMAXSOURCEDELAYI3DPROC) (HDC hDC, UINT *uMaxLineDelay, UINT *uMaxPixelDelay); +#ifdef WGL_WGLEXT_PROTOTYPES +BOOL WINAPI wglEnableGenlockI3D (HDC hDC); +BOOL WINAPI wglDisableGenlockI3D (HDC hDC); +BOOL WINAPI wglIsEnabledGenlockI3D (HDC hDC, BOOL *pFlag); +BOOL WINAPI wglGenlockSourceI3D (HDC hDC, UINT uSource); +BOOL WINAPI wglGetGenlockSourceI3D (HDC hDC, UINT *uSource); +BOOL WINAPI wglGenlockSourceEdgeI3D (HDC hDC, UINT uEdge); +BOOL WINAPI wglGetGenlockSourceEdgeI3D (HDC hDC, UINT *uEdge); +BOOL WINAPI wglGenlockSampleRateI3D (HDC hDC, UINT uRate); +BOOL WINAPI wglGetGenlockSampleRateI3D (HDC hDC, UINT *uRate); +BOOL WINAPI wglGenlockSourceDelayI3D (HDC hDC, UINT uDelay); +BOOL WINAPI wglGetGenlockSourceDelayI3D (HDC hDC, UINT *uDelay); +BOOL WINAPI wglQueryGenlockMaxSourceDelayI3D (HDC hDC, UINT *uMaxLineDelay, UINT *uMaxPixelDelay); +#endif +#endif /* WGL_I3D_genlock */ + +#ifndef WGL_I3D_image_buffer +#define WGL_I3D_image_buffer 1 +#define WGL_IMAGE_BUFFER_MIN_ACCESS_I3D 0x00000001 +#define WGL_IMAGE_BUFFER_LOCK_I3D 0x00000002 +typedef LPVOID (WINAPI * PFNWGLCREATEIMAGEBUFFERI3DPROC) (HDC hDC, DWORD dwSize, UINT uFlags); +typedef BOOL (WINAPI * PFNWGLDESTROYIMAGEBUFFERI3DPROC) (HDC hDC, LPVOID pAddress); +typedef BOOL (WINAPI * PFNWGLASSOCIATEIMAGEBUFFEREVENTSI3DPROC) (HDC hDC, const HANDLE *pEvent, const LPVOID *pAddress, const DWORD *pSize, UINT count); +typedef BOOL (WINAPI * PFNWGLRELEASEIMAGEBUFFEREVENTSI3DPROC) (HDC hDC, const LPVOID *pAddress, UINT count); +#ifdef WGL_WGLEXT_PROTOTYPES +LPVOID WINAPI wglCreateImageBufferI3D (HDC hDC, DWORD dwSize, UINT uFlags); +BOOL WINAPI wglDestroyImageBufferI3D (HDC hDC, LPVOID pAddress); +BOOL WINAPI wglAssociateImageBufferEventsI3D (HDC hDC, const HANDLE *pEvent, const LPVOID *pAddress, const DWORD *pSize, UINT count); +BOOL WINAPI wglReleaseImageBufferEventsI3D (HDC hDC, const LPVOID *pAddress, UINT count); +#endif +#endif /* WGL_I3D_image_buffer */ + +#ifndef WGL_I3D_swap_frame_lock +#define WGL_I3D_swap_frame_lock 1 +typedef BOOL (WINAPI * PFNWGLENABLEFRAMELOCKI3DPROC) (void); +typedef BOOL (WINAPI * PFNWGLDISABLEFRAMELOCKI3DPROC) (void); +typedef BOOL (WINAPI * PFNWGLISENABLEDFRAMELOCKI3DPROC) (BOOL *pFlag); +typedef BOOL (WINAPI * PFNWGLQUERYFRAMELOCKMASTERI3DPROC) (BOOL *pFlag); +#ifdef WGL_WGLEXT_PROTOTYPES +BOOL WINAPI wglEnableFrameLockI3D (void); +BOOL WINAPI wglDisableFrameLockI3D (void); +BOOL WINAPI wglIsEnabledFrameLockI3D (BOOL *pFlag); +BOOL WINAPI wglQueryFrameLockMasterI3D (BOOL *pFlag); +#endif +#endif /* WGL_I3D_swap_frame_lock */ + +#ifndef WGL_I3D_swap_frame_usage +#define WGL_I3D_swap_frame_usage 1 +typedef BOOL (WINAPI * PFNWGLGETFRAMEUSAGEI3DPROC) (float *pUsage); +typedef BOOL (WINAPI * PFNWGLBEGINFRAMETRACKINGI3DPROC) (void); +typedef BOOL (WINAPI * PFNWGLENDFRAMETRACKINGI3DPROC) (void); +typedef BOOL (WINAPI * PFNWGLQUERYFRAMETRACKINGI3DPROC) (DWORD *pFrameCount, DWORD *pMissedFrames, float *pLastMissedUsage); +#ifdef WGL_WGLEXT_PROTOTYPES +BOOL WINAPI wglGetFrameUsageI3D (float *pUsage); +BOOL WINAPI wglBeginFrameTrackingI3D (void); +BOOL WINAPI wglEndFrameTrackingI3D (void); +BOOL WINAPI wglQueryFrameTrackingI3D (DWORD *pFrameCount, DWORD *pMissedFrames, float *pLastMissedUsage); +#endif +#endif /* WGL_I3D_swap_frame_usage */ + +#ifndef WGL_NV_DX_interop +#define WGL_NV_DX_interop 1 +#define WGL_ACCESS_READ_ONLY_NV 0x00000000 +#define WGL_ACCESS_READ_WRITE_NV 0x00000001 +#define WGL_ACCESS_WRITE_DISCARD_NV 0x00000002 +typedef BOOL (WINAPI * PFNWGLDXSETRESOURCESHAREHANDLENVPROC) (void *dxObject, HANDLE shareHandle); +typedef HANDLE (WINAPI * PFNWGLDXOPENDEVICENVPROC) (void *dxDevice); +typedef BOOL (WINAPI * PFNWGLDXCLOSEDEVICENVPROC) (HANDLE hDevice); +typedef HANDLE (WINAPI * PFNWGLDXREGISTEROBJECTNVPROC) (HANDLE hDevice, void *dxObject, GLuint name, GLenum type, GLenum access); +typedef BOOL (WINAPI * PFNWGLDXUNREGISTEROBJECTNVPROC) (HANDLE hDevice, HANDLE hObject); +typedef BOOL (WINAPI * PFNWGLDXOBJECTACCESSNVPROC) (HANDLE hObject, GLenum access); +typedef BOOL (WINAPI * PFNWGLDXLOCKOBJECTSNVPROC) (HANDLE hDevice, GLint count, HANDLE *hObjects); +typedef BOOL (WINAPI * PFNWGLDXUNLOCKOBJECTSNVPROC) (HANDLE hDevice, GLint count, HANDLE *hObjects); +#ifdef WGL_WGLEXT_PROTOTYPES +BOOL WINAPI wglDXSetResourceShareHandleNV (void *dxObject, HANDLE shareHandle); +HANDLE WINAPI wglDXOpenDeviceNV (void *dxDevice); +BOOL WINAPI wglDXCloseDeviceNV (HANDLE hDevice); +HANDLE WINAPI wglDXRegisterObjectNV (HANDLE hDevice, void *dxObject, GLuint name, GLenum type, GLenum access); +BOOL WINAPI wglDXUnregisterObjectNV (HANDLE hDevice, HANDLE hObject); +BOOL WINAPI wglDXObjectAccessNV (HANDLE hObject, GLenum access); +BOOL WINAPI wglDXLockObjectsNV (HANDLE hDevice, GLint count, HANDLE *hObjects); +BOOL WINAPI wglDXUnlockObjectsNV (HANDLE hDevice, GLint count, HANDLE *hObjects); +#endif +#endif /* WGL_NV_DX_interop */ + +#ifndef WGL_NV_DX_interop2 +#define WGL_NV_DX_interop2 1 +#endif /* WGL_NV_DX_interop2 */ + +#ifndef WGL_NV_copy_image +#define WGL_NV_copy_image 1 +typedef BOOL (WINAPI * PFNWGLCOPYIMAGESUBDATANVPROC) (HGLRC hSrcRC, GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, HGLRC hDstRC, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei width, GLsizei height, GLsizei depth); +#ifdef WGL_WGLEXT_PROTOTYPES +BOOL WINAPI wglCopyImageSubDataNV (HGLRC hSrcRC, GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, HGLRC hDstRC, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei width, GLsizei height, GLsizei depth); +#endif +#endif /* WGL_NV_copy_image */ + +#ifndef WGL_NV_delay_before_swap +#define WGL_NV_delay_before_swap 1 +typedef BOOL (WINAPI * PFNWGLDELAYBEFORESWAPNVPROC) (HDC hDC, GLfloat seconds); +#ifdef WGL_WGLEXT_PROTOTYPES +BOOL WINAPI wglDelayBeforeSwapNV (HDC hDC, GLfloat seconds); +#endif +#endif /* WGL_NV_delay_before_swap */ + +#ifndef WGL_NV_float_buffer +#define WGL_NV_float_buffer 1 +#define WGL_FLOAT_COMPONENTS_NV 0x20B0 +#define WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_R_NV 0x20B1 +#define WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RG_NV 0x20B2 +#define WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RGB_NV 0x20B3 +#define WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RGBA_NV 0x20B4 +#define WGL_TEXTURE_FLOAT_R_NV 0x20B5 +#define WGL_TEXTURE_FLOAT_RG_NV 0x20B6 +#define WGL_TEXTURE_FLOAT_RGB_NV 0x20B7 +#define WGL_TEXTURE_FLOAT_RGBA_NV 0x20B8 +#endif /* WGL_NV_float_buffer */ + +#ifndef WGL_NV_gpu_affinity +#define WGL_NV_gpu_affinity 1 +DECLARE_HANDLE(HGPUNV); +struct _GPU_DEVICE { + DWORD cb; + CHAR DeviceName[32]; + CHAR DeviceString[128]; + DWORD Flags; + RECT rcVirtualScreen; +}; +typedef struct _GPU_DEVICE *PGPU_DEVICE; +#define ERROR_INCOMPATIBLE_AFFINITY_MASKS_NV 0x20D0 +#define ERROR_MISSING_AFFINITY_MASK_NV 0x20D1 +typedef BOOL (WINAPI * PFNWGLENUMGPUSNVPROC) (UINT iGpuIndex, HGPUNV *phGpu); +typedef BOOL (WINAPI * PFNWGLENUMGPUDEVICESNVPROC) (HGPUNV hGpu, UINT iDeviceIndex, PGPU_DEVICE lpGpuDevice); +typedef HDC (WINAPI * PFNWGLCREATEAFFINITYDCNVPROC) (const HGPUNV *phGpuList); +typedef BOOL (WINAPI * PFNWGLENUMGPUSFROMAFFINITYDCNVPROC) (HDC hAffinityDC, UINT iGpuIndex, HGPUNV *hGpu); +typedef BOOL (WINAPI * PFNWGLDELETEDCNVPROC) (HDC hdc); +#ifdef WGL_WGLEXT_PROTOTYPES +BOOL WINAPI wglEnumGpusNV (UINT iGpuIndex, HGPUNV *phGpu); +BOOL WINAPI wglEnumGpuDevicesNV (HGPUNV hGpu, UINT iDeviceIndex, PGPU_DEVICE lpGpuDevice); +HDC WINAPI wglCreateAffinityDCNV (const HGPUNV *phGpuList); +BOOL WINAPI wglEnumGpusFromAffinityDCNV (HDC hAffinityDC, UINT iGpuIndex, HGPUNV *hGpu); +BOOL WINAPI wglDeleteDCNV (HDC hdc); +#endif +#endif /* WGL_NV_gpu_affinity */ + +#ifndef WGL_NV_multigpu_context +#define WGL_NV_multigpu_context 1 +#define WGL_CONTEXT_MULTIGPU_ATTRIB_NV 0x20AA +#define WGL_CONTEXT_MULTIGPU_ATTRIB_SINGLE_NV 0x20AB +#define WGL_CONTEXT_MULTIGPU_ATTRIB_AFR_NV 0x20AC +#define WGL_CONTEXT_MULTIGPU_ATTRIB_MULTICAST_NV 0x20AD +#define WGL_CONTEXT_MULTIGPU_ATTRIB_MULTI_DISPLAY_MULTICAST_NV 0x20AE +#endif /* WGL_NV_multigpu_context */ + +#ifndef WGL_NV_multisample_coverage +#define WGL_NV_multisample_coverage 1 +#define WGL_COVERAGE_SAMPLES_NV 0x2042 +#define WGL_COLOR_SAMPLES_NV 0x20B9 +#endif /* WGL_NV_multisample_coverage */ + +#ifndef WGL_NV_present_video +#define WGL_NV_present_video 1 +DECLARE_HANDLE(HVIDEOOUTPUTDEVICENV); +#define WGL_NUM_VIDEO_SLOTS_NV 0x20F0 +typedef int (WINAPI * PFNWGLENUMERATEVIDEODEVICESNVPROC) (HDC hDc, HVIDEOOUTPUTDEVICENV *phDeviceList); +typedef BOOL (WINAPI * PFNWGLBINDVIDEODEVICENVPROC) (HDC hDc, unsigned int uVideoSlot, HVIDEOOUTPUTDEVICENV hVideoDevice, const int *piAttribList); +typedef BOOL (WINAPI * PFNWGLQUERYCURRENTCONTEXTNVPROC) (int iAttribute, int *piValue); +#ifdef WGL_WGLEXT_PROTOTYPES +int WINAPI wglEnumerateVideoDevicesNV (HDC hDc, HVIDEOOUTPUTDEVICENV *phDeviceList); +BOOL WINAPI wglBindVideoDeviceNV (HDC hDc, unsigned int uVideoSlot, HVIDEOOUTPUTDEVICENV hVideoDevice, const int *piAttribList); +BOOL WINAPI wglQueryCurrentContextNV (int iAttribute, int *piValue); +#endif +#endif /* WGL_NV_present_video */ + +#ifndef WGL_NV_render_depth_texture +#define WGL_NV_render_depth_texture 1 +#define WGL_BIND_TO_TEXTURE_DEPTH_NV 0x20A3 +#define WGL_BIND_TO_TEXTURE_RECTANGLE_DEPTH_NV 0x20A4 +#define WGL_DEPTH_TEXTURE_FORMAT_NV 0x20A5 +#define WGL_TEXTURE_DEPTH_COMPONENT_NV 0x20A6 +#define WGL_DEPTH_COMPONENT_NV 0x20A7 +#endif /* WGL_NV_render_depth_texture */ + +#ifndef WGL_NV_render_texture_rectangle +#define WGL_NV_render_texture_rectangle 1 +#define WGL_BIND_TO_TEXTURE_RECTANGLE_RGB_NV 0x20A0 +#define WGL_BIND_TO_TEXTURE_RECTANGLE_RGBA_NV 0x20A1 +#define WGL_TEXTURE_RECTANGLE_NV 0x20A2 +#endif /* WGL_NV_render_texture_rectangle */ + +#ifndef WGL_NV_swap_group +#define WGL_NV_swap_group 1 +typedef BOOL (WINAPI * PFNWGLJOINSWAPGROUPNVPROC) (HDC hDC, GLuint group); +typedef BOOL (WINAPI * PFNWGLBINDSWAPBARRIERNVPROC) (GLuint group, GLuint barrier); +typedef BOOL (WINAPI * PFNWGLQUERYSWAPGROUPNVPROC) (HDC hDC, GLuint *group, GLuint *barrier); +typedef BOOL (WINAPI * PFNWGLQUERYMAXSWAPGROUPSNVPROC) (HDC hDC, GLuint *maxGroups, GLuint *maxBarriers); +typedef BOOL (WINAPI * PFNWGLQUERYFRAMECOUNTNVPROC) (HDC hDC, GLuint *count); +typedef BOOL (WINAPI * PFNWGLRESETFRAMECOUNTNVPROC) (HDC hDC); +#ifdef WGL_WGLEXT_PROTOTYPES +BOOL WINAPI wglJoinSwapGroupNV (HDC hDC, GLuint group); +BOOL WINAPI wglBindSwapBarrierNV (GLuint group, GLuint barrier); +BOOL WINAPI wglQuerySwapGroupNV (HDC hDC, GLuint *group, GLuint *barrier); +BOOL WINAPI wglQueryMaxSwapGroupsNV (HDC hDC, GLuint *maxGroups, GLuint *maxBarriers); +BOOL WINAPI wglQueryFrameCountNV (HDC hDC, GLuint *count); +BOOL WINAPI wglResetFrameCountNV (HDC hDC); +#endif +#endif /* WGL_NV_swap_group */ + +#ifndef WGL_NV_vertex_array_range +#define WGL_NV_vertex_array_range 1 +typedef void *(WINAPI * PFNWGLALLOCATEMEMORYNVPROC) (GLsizei size, GLfloat readfreq, GLfloat writefreq, GLfloat priority); +typedef void (WINAPI * PFNWGLFREEMEMORYNVPROC) (void *pointer); +#ifdef WGL_WGLEXT_PROTOTYPES +void *WINAPI wglAllocateMemoryNV (GLsizei size, GLfloat readfreq, GLfloat writefreq, GLfloat priority); +void WINAPI wglFreeMemoryNV (void *pointer); +#endif +#endif /* WGL_NV_vertex_array_range */ + +#ifndef WGL_NV_video_capture +#define WGL_NV_video_capture 1 +DECLARE_HANDLE(HVIDEOINPUTDEVICENV); +#define WGL_UNIQUE_ID_NV 0x20CE +#define WGL_NUM_VIDEO_CAPTURE_SLOTS_NV 0x20CF +typedef BOOL (WINAPI * PFNWGLBINDVIDEOCAPTUREDEVICENVPROC) (UINT uVideoSlot, HVIDEOINPUTDEVICENV hDevice); +typedef UINT (WINAPI * PFNWGLENUMERATEVIDEOCAPTUREDEVICESNVPROC) (HDC hDc, HVIDEOINPUTDEVICENV *phDeviceList); +typedef BOOL (WINAPI * PFNWGLLOCKVIDEOCAPTUREDEVICENVPROC) (HDC hDc, HVIDEOINPUTDEVICENV hDevice); +typedef BOOL (WINAPI * PFNWGLQUERYVIDEOCAPTUREDEVICENVPROC) (HDC hDc, HVIDEOINPUTDEVICENV hDevice, int iAttribute, int *piValue); +typedef BOOL (WINAPI * PFNWGLRELEASEVIDEOCAPTUREDEVICENVPROC) (HDC hDc, HVIDEOINPUTDEVICENV hDevice); +#ifdef WGL_WGLEXT_PROTOTYPES +BOOL WINAPI wglBindVideoCaptureDeviceNV (UINT uVideoSlot, HVIDEOINPUTDEVICENV hDevice); +UINT WINAPI wglEnumerateVideoCaptureDevicesNV (HDC hDc, HVIDEOINPUTDEVICENV *phDeviceList); +BOOL WINAPI wglLockVideoCaptureDeviceNV (HDC hDc, HVIDEOINPUTDEVICENV hDevice); +BOOL WINAPI wglQueryVideoCaptureDeviceNV (HDC hDc, HVIDEOINPUTDEVICENV hDevice, int iAttribute, int *piValue); +BOOL WINAPI wglReleaseVideoCaptureDeviceNV (HDC hDc, HVIDEOINPUTDEVICENV hDevice); +#endif +#endif /* WGL_NV_video_capture */ + +#ifndef WGL_NV_video_output +#define WGL_NV_video_output 1 +DECLARE_HANDLE(HPVIDEODEV); +#define WGL_BIND_TO_VIDEO_RGB_NV 0x20C0 +#define WGL_BIND_TO_VIDEO_RGBA_NV 0x20C1 +#define WGL_BIND_TO_VIDEO_RGB_AND_DEPTH_NV 0x20C2 +#define WGL_VIDEO_OUT_COLOR_NV 0x20C3 +#define WGL_VIDEO_OUT_ALPHA_NV 0x20C4 +#define WGL_VIDEO_OUT_DEPTH_NV 0x20C5 +#define WGL_VIDEO_OUT_COLOR_AND_ALPHA_NV 0x20C6 +#define WGL_VIDEO_OUT_COLOR_AND_DEPTH_NV 0x20C7 +#define WGL_VIDEO_OUT_FRAME 0x20C8 +#define WGL_VIDEO_OUT_FIELD_1 0x20C9 +#define WGL_VIDEO_OUT_FIELD_2 0x20CA +#define WGL_VIDEO_OUT_STACKED_FIELDS_1_2 0x20CB +#define WGL_VIDEO_OUT_STACKED_FIELDS_2_1 0x20CC +typedef BOOL (WINAPI * PFNWGLGETVIDEODEVICENVPROC) (HDC hDC, int numDevices, HPVIDEODEV *hVideoDevice); +typedef BOOL (WINAPI * PFNWGLRELEASEVIDEODEVICENVPROC) (HPVIDEODEV hVideoDevice); +typedef BOOL (WINAPI * PFNWGLBINDVIDEOIMAGENVPROC) (HPVIDEODEV hVideoDevice, HPBUFFERARB hPbuffer, int iVideoBuffer); +typedef BOOL (WINAPI * PFNWGLRELEASEVIDEOIMAGENVPROC) (HPBUFFERARB hPbuffer, int iVideoBuffer); +typedef BOOL (WINAPI * PFNWGLSENDPBUFFERTOVIDEONVPROC) (HPBUFFERARB hPbuffer, int iBufferType, unsigned long *pulCounterPbuffer, BOOL bBlock); +typedef BOOL (WINAPI * PFNWGLGETVIDEOINFONVPROC) (HPVIDEODEV hpVideoDevice, unsigned long *pulCounterOutputPbuffer, unsigned long *pulCounterOutputVideo); +#ifdef WGL_WGLEXT_PROTOTYPES +BOOL WINAPI wglGetVideoDeviceNV (HDC hDC, int numDevices, HPVIDEODEV *hVideoDevice); +BOOL WINAPI wglReleaseVideoDeviceNV (HPVIDEODEV hVideoDevice); +BOOL WINAPI wglBindVideoImageNV (HPVIDEODEV hVideoDevice, HPBUFFERARB hPbuffer, int iVideoBuffer); +BOOL WINAPI wglReleaseVideoImageNV (HPBUFFERARB hPbuffer, int iVideoBuffer); +BOOL WINAPI wglSendPbufferToVideoNV (HPBUFFERARB hPbuffer, int iBufferType, unsigned long *pulCounterPbuffer, BOOL bBlock); +BOOL WINAPI wglGetVideoInfoNV (HPVIDEODEV hpVideoDevice, unsigned long *pulCounterOutputPbuffer, unsigned long *pulCounterOutputVideo); +#endif +#endif /* WGL_NV_video_output */ + +#ifndef WGL_OML_sync_control +#define WGL_OML_sync_control 1 +typedef BOOL (WINAPI * PFNWGLGETSYNCVALUESOMLPROC) (HDC hdc, INT64 *ust, INT64 *msc, INT64 *sbc); +typedef BOOL (WINAPI * PFNWGLGETMSCRATEOMLPROC) (HDC hdc, INT32 *numerator, INT32 *denominator); +typedef INT64 (WINAPI * PFNWGLSWAPBUFFERSMSCOMLPROC) (HDC hdc, INT64 target_msc, INT64 divisor, INT64 remainder); +typedef INT64 (WINAPI * PFNWGLSWAPLAYERBUFFERSMSCOMLPROC) (HDC hdc, INT fuPlanes, INT64 target_msc, INT64 divisor, INT64 remainder); +typedef BOOL (WINAPI * PFNWGLWAITFORMSCOMLPROC) (HDC hdc, INT64 target_msc, INT64 divisor, INT64 remainder, INT64 *ust, INT64 *msc, INT64 *sbc); +typedef BOOL (WINAPI * PFNWGLWAITFORSBCOMLPROC) (HDC hdc, INT64 target_sbc, INT64 *ust, INT64 *msc, INT64 *sbc); +#ifdef WGL_WGLEXT_PROTOTYPES +BOOL WINAPI wglGetSyncValuesOML (HDC hdc, INT64 *ust, INT64 *msc, INT64 *sbc); +BOOL WINAPI wglGetMscRateOML (HDC hdc, INT32 *numerator, INT32 *denominator); +INT64 WINAPI wglSwapBuffersMscOML (HDC hdc, INT64 target_msc, INT64 divisor, INT64 remainder); +INT64 WINAPI wglSwapLayerBuffersMscOML (HDC hdc, INT fuPlanes, INT64 target_msc, INT64 divisor, INT64 remainder); +BOOL WINAPI wglWaitForMscOML (HDC hdc, INT64 target_msc, INT64 divisor, INT64 remainder, INT64 *ust, INT64 *msc, INT64 *sbc); +BOOL WINAPI wglWaitForSbcOML (HDC hdc, INT64 target_sbc, INT64 *ust, INT64 *msc, INT64 *sbc); +#endif +#endif /* WGL_OML_sync_control */ + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/lib/win/win32app.h b/lib/win/win32app.h index bbf74a361..7f5e7d062 100644 --- a/lib/win/win32app.h +++ b/lib/win/win32app.h @@ -160,6 +160,7 @@ class oeWin32Application : public oeApplication { private: int defer_block(); // real defer code. + void change_window(); // Adjusts the window based on style public: // Creates the window handle @@ -215,6 +216,8 @@ class oeWin32Application : public oeApplication { // detect if application can handle what we want of it. static bool GetSystemSpecs(const char *fname); + virtual void set_flags(int newflags); + public: HWnd m_hWnd{}; // handles created by the system HInstance m_hInstance{}; diff --git a/linux/lnxapp.cpp b/linux/lnxapp.cpp index c3109abd3..c2e8bf027 100644 --- a/linux/lnxapp.cpp +++ b/linux/lnxapp.cpp @@ -206,6 +206,10 @@ void oeLnxApplication::delay(float secs) { // Function to get the flags int oeLnxApplication::flags() const { return m_Flags; } +void oeLnxApplication::set_flags(int newflags) { + m_Flags = newflags; +} + // Sizes the displayable region of the app (the window) void oeLnxApplication::set_sizepos(int x, int y, int w, int h) { m_X = x; diff --git a/linux/lnxapp.h b/linux/lnxapp.h index e3b059a51..2f95896c5 100644 --- a/linux/lnxapp.h +++ b/linux/lnxapp.h @@ -76,6 +76,7 @@ class oeLnxApplication : public oeApplication { void set_sizepos(int x, int y, int w, int h); virtual int flags(void) const; + virtual void set_flags(int newflags); unsigned m_Flags; int m_X, m_Y, m_W, m_H; // window dimensions. diff --git a/renderer/CMakeLists.txt b/renderer/CMakeLists.txt index 094d7cca3..7342857bf 100644 --- a/renderer/CMakeLists.txt +++ b/renderer/CMakeLists.txt @@ -1,28 +1,33 @@ set(HEADERS - dyna_gl.h HardwareInternal.h + RendererConfig.h + dyna_gl.h + gl_local.h + gl_mesh.h + gl_shader.h ) set(CPPS - HardwareClipper.cpp - HardwareDraw.cpp - HardwareGlobalVars.cpp - HardwareInstance.cpp - HardwareOpenGL.cpp - HardwareBaseGPU.cpp - HardwarePoints.cpp - HardwareSetup.cpp - HardwareTransforms.cpp + clipper.cpp + draw.cpp + gl.c + gl_draw.cpp + gl_framebuffer.cpp + gl_image.cpp + gl_init.cpp + gl_main.cpp + gl_mesh.cpp + gl_shader.cpp + gl_shadersource.cpp + globalvars.cpp + instance.cpp + points.cpp + setup.cpp + transforms.cpp + $<$: + wgl.c + > ) -if(UNIX) - set(CPPS ${CPPS} lnxscreenmode.cpp) -endif() - -# These are excluded. -#opengl.cpp -#renderer.cpp -#Direct3D.cpp - add_library(renderer STATIC ${HEADERS} ${CPPS}) target_link_libraries(renderer PRIVATE bitmap diff --git a/renderer/HardwareBaseGPU.cpp b/renderer/HardwareBaseGPU.cpp deleted file mode 100644 index 3449dc54a..000000000 --- a/renderer/HardwareBaseGPU.cpp +++ /dev/null @@ -1,756 +0,0 @@ -/* -* Descent 3 -* Copyright (C) 2024 Descent Developers -* -* This program is free software: you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation, either version 3 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program. If not, see . - */ - -// TODO: This is missing a good way of overriding base behavior (like, you know, method overrides...) - -#include "pserror.h" -#include "mono.h" -#include "3d.h" -#include "renderer.h" -#include "bitmap.h" -#include "grdefs.h" -#include - -#include "HardwareInternal.h" -#include "lightmap.h" - -// FIXME: Unused -// The font characteristics -static float rend_FontRed[4], rend_FontBlue[4], rend_FontGreen[4], rend_FontAlpha[4]; -char Renderer_error_message[256] = "Generic renderer error"; - -// The following values are referenced by the game code, but only -// UseMultitexture is actually referenced and used in this code - and -// even that can probably go away and we just assume there is more than -// one texture unit (which, since I believe OpenGL 1.2 is a requirement) -bool UseHardware = true; -bool NoLightmaps = false; -bool StateLimited = false; -bool UseMultitexture = false; -bool UseWBuffer = false; - -// General renderer states -int gpu_Overlay_map = -1; -uint8_t gpu_Overlay_type = OT_NONE; -uint8_t Renderer_initted = 0; - -// Generic GPU data -rendering_state gpu_state; -renderer_preferred_state gpu_preferred_state = {0, 1, 1.5}; - -int gpu_last_frame_polys_drawn = 0; -int gpu_last_frame_verts_processed = 0; -int gpu_last_uploaded = 0; - -float gpu_Alpha_factor = 1.0f; -float gpu_Alpha_multiplier = 1.0f; - -PosColorUVVertex vArray[100]; -PosColorUV2Vertex vArray2[100]; - -// returns the alpha that we should use -float rend_GetAlphaMultiplier() { - switch (gpu_state.cur_alpha_type) { - case AT_ALWAYS: - case AT_TEXTURE: - case AT_VERTEX: - case AT_TEXTURE_VERTEX: - case AT_SATURATE_VERTEX: - case AT_SATURATE_TEXTURE_VERTEX: - case AT_SPECULAR: - return 1.0; - case AT_CONSTANT: - case AT_CONSTANT_TEXTURE: - case AT_CONSTANT_TEXTURE_VERTEX: - case AT_CONSTANT_VERTEX: - case AT_LIGHTMAP_BLEND: - case AT_LIGHTMAP_BLEND_SATURATE: - case AT_SATURATE_TEXTURE: - case AT_SATURATE_CONSTANT_VERTEX: - return gpu_state.cur_alpha / 255.0; - default: - // Int3(); // no type defined,get jason - return 0; - } -} - -// Retrieves an error message -const char *rend_GetErrorMessage() { return Renderer_error_message; } - -// Sets an error message -void rend_SetErrorMessage(const char *str) { - ASSERT(strlen(str) < 256); - strcpy(Renderer_error_message, str); -} - -// FIXME: Unused -// Sets the argb characteristics of the font characters. color1 is the upper left and proceeds clockwise -void rend_SetCharacterParameters(ddgr_color color1, ddgr_color color2, ddgr_color color3, ddgr_color color4) { - rend_FontRed[0] = (float)(GR_COLOR_RED(color1) / 255.0f); - rend_FontRed[1] = (float)(GR_COLOR_RED(color2) / 255.0f); - rend_FontRed[2] = (float)(GR_COLOR_RED(color3) / 255.0f); - rend_FontRed[3] = (float)(GR_COLOR_RED(color4) / 255.0f); - rend_FontGreen[0] = (float)(GR_COLOR_GREEN(color1) / 255.0f); - rend_FontGreen[1] = (float)(GR_COLOR_GREEN(color2) / 255.0f); - rend_FontGreen[2] = (float)(GR_COLOR_GREEN(color3) / 255.0f); - rend_FontGreen[3] = (float)(GR_COLOR_GREEN(color4) / 255.0f); - rend_FontBlue[0] = (float)(GR_COLOR_BLUE(color1) / 255.0f); - rend_FontBlue[1] = (float)(GR_COLOR_BLUE(color2) / 255.0f); - rend_FontBlue[2] = (float)(GR_COLOR_BLUE(color3) / 255.0f); - rend_FontBlue[3] = (float)(GR_COLOR_BLUE(color4) / 255.0f); - rend_FontAlpha[0] = (color1 >> 24) / 255.0f; - rend_FontAlpha[1] = (color2 >> 24) / 255.0f; - rend_FontAlpha[2] = (color3 >> 24) / 255.0f; - rend_FontAlpha[3] = (color4 >> 24) / 255.0f; -} - -// Sets where the software renderer should write to -void rend_SetSoftwareParameters(float aspect, int width, int height, int pitch, uint8_t *framebuffer) {} - -// Sets the state of bilinear filtering for our textures -void rend_SetFiltering(int8_t state) { - gpu_state.cur_bilinear_state = state; -} - -// Sets the near and far planes for z buffer -void rend_SetZValues(float nearz, float farz) { - gpu_state.cur_near_z = nearz; - gpu_state.cur_far_z = farz; - // mprintf(0,"OPENGL:Setting depth range to %f - %f\n",nearz,farz); - - // JEFF: glDepthRange must take parameters [0,1] - // It is set in init - //@@dglDepthRange (0,farz); -} - -// Sets a bitmap as a overlay map to rendered on top of the next texture map -// a -1 value indicates no overlay map -void rend_SetOverlayMap(int handle) { gpu_Overlay_map = handle; } - -void rend_SetOverlayType(uint8_t type) { gpu_Overlay_type = type; } - - -void rend_FillCircle(ddgr_color col, int x, int y, int rad) {} - -void rend_DrawCircle(int x, int y, int rad) {} - -// Sets up a font character to draw. We draw our fonts as pieces of textures -void rend_DrawFontCharacter(int bm_handle, int x1, int y1, int x2, int y2, float u, float v, float w, float h) { - g3Point *ptr_pnts[4]; - g3Point pnts[4]; - for (int i = 0; i < 4; i++) { - pnts[i].p3_z = 1; // Make REALLY close! - pnts[i].p3_flags = PF_PROJECTED; - ptr_pnts[i] = &pnts[i]; - } - pnts[0].p3_sx = x1; - pnts[0].p3_sy = y1; - pnts[0].p3_u = u; - pnts[0].p3_v = v; - pnts[1].p3_sx = x2; - pnts[1].p3_sy = y1; - pnts[1].p3_u = u + w; - pnts[1].p3_v = v; - pnts[2].p3_sx = x2; - pnts[2].p3_sy = y2; - pnts[2].p3_u = u + w; - pnts[2].p3_v = v + h; - pnts[3].p3_sx = x1; - pnts[3].p3_sy = y2; - pnts[3].p3_u = u; - pnts[3].p3_v = v + h; - rend_DrawPolygon2D(bm_handle, ptr_pnts, 4); -} - -// Sets the alpha value for constant alpha -void rend_SetAlphaValue(uint8_t val) { - gpu_state.cur_alpha = val; - gpu_Alpha_multiplier = rend_GetAlphaMultiplier(); -} - -// Sets the texture wrapping type -void rend_SetWrapType(wrap_type val) { gpu_state.cur_wrap_type = val; } - -void rend_SetZBias(float z_bias) { - if (Z_bias != z_bias) { - Z_bias = z_bias; - - // Force refresh our transforms to take the Zbias into account - g3_GetModelViewMatrix(&View_position, &Unscaled_matrix, (float *)gTransformModelView); - g3_UpdateFullTransform(); - g3_ForceTransformRefresh(); - } -} - -// Sets the overall alpha scale factor (all alpha values are scaled by this value) -// usefull for motion blur effect -void rend_SetAlphaFactor(float val) { - if (val < 0.0f) - val = 0.0f; - if (val > 1.0f) - val = 1.0f; - gpu_Alpha_factor = val; -} - -// Returns the current Alpha factor -float rend_GetAlphaFactor(void) { return gpu_Alpha_factor; } - -// Gets a pointer to a linear frame buffer -void rend_GetLFBLock(renderer_lfb *lfb) {} - -// Releases an lfb lock -void rend_ReleaseLFBLock(renderer_lfb *lfb) {} - -// Returns the aspect ratio of the physical screen -void rend_GetProjectionParameters(int *width, int *height) { - *width = gpu_state.clip_x2 - gpu_state.clip_x1; - *height = gpu_state.clip_y2 - gpu_state.clip_y1; -} - -void rend_GetProjectionScreenParameters(int &screenLX, int &screenTY, int &screenW, int &screenH) { - screenLX = gpu_state.clip_x1; - screenTY = gpu_state.clip_y1; - screenW = gpu_state.clip_x2 - gpu_state.clip_x1 + 1; - screenH = gpu_state.clip_y2 - gpu_state.clip_y1 + 1; -} - -// Returns the aspect ratio of the physical screen -float rend_GetAspectRatio(void) { - float aspect_ratio = (float)((3.0f * gpu_state.screen_width) / (4.0f * gpu_state.screen_height)); - return aspect_ratio; -} - -// Given a source x,y and width,height, draws any sized bitmap into the renderer lfb -void rend_DrawLFBBitmap(int sx, int sy, int w, int h, int dx, int dy, uint16_t *data, int rowsize) {} - -// draws a scaled 2d bitmap to our buffer -void rend_DrawScaledBitmap(int x1, int y1, int x2, int y2, int bm, float u0, float v0, float u1, float v1, int color, - float *alphas) { - g3Point *ptr_pnts[4]; - g3Point pnts[4]; - float r, g, b; - if (color != -1) { - r = GR_COLOR_RED(color) / 255.0; - g = GR_COLOR_GREEN(color) / 255.0; - b = GR_COLOR_BLUE(color) / 255.0; - } - for (int i = 0; i < 4; i++) { - if (color == -1) - pnts[i].p3_l = 1.0; - else { - pnts[i].p3_r = r; - pnts[i].p3_g = g; - pnts[i].p3_b = b; - } - if (alphas) { - pnts[i].p3_a = alphas[i]; - } - - pnts[i].p3_z = 1.0f; - pnts[i].p3_flags = PF_PROJECTED; - } - - pnts[0].p3_sx = x1; - pnts[0].p3_sy = y1; - pnts[0].p3_u = u0; - pnts[0].p3_v = v0; - pnts[1].p3_sx = x2; - pnts[1].p3_sy = y1; - pnts[1].p3_u = u1; - pnts[1].p3_v = v0; - pnts[2].p3_sx = x2; - pnts[2].p3_sy = y2; - pnts[2].p3_u = u1; - pnts[2].p3_v = v1; - pnts[3].p3_sx = x1; - pnts[3].p3_sy = y2; - pnts[3].p3_u = u0; - pnts[3].p3_v = v1; - ptr_pnts[0] = &pnts[0]; - ptr_pnts[1] = &pnts[1]; - ptr_pnts[2] = &pnts[2]; - ptr_pnts[3] = &pnts[3]; - rend_SetTextureType(TT_LINEAR); - rend_DrawPolygon2D(bm, ptr_pnts, 4); -} - -// given a chunked bitmap, renders it. -void rend_DrawChunkedBitmap(chunked_bitmap *chunk, int x, int y, uint8_t alpha) { - int *bm_array = chunk->bm_array; - int w = chunk->w; - int h = chunk->h; - int piece_w = bm_w(bm_array[0], 0); - int piece_h = bm_h(bm_array[0], 0); - int screen_w, screen_h; - int i, t; - rend_SetZBufferState(0); - rend_GetProjectionParameters(&screen_w, &screen_h); - for (i = 0; i < h; i++) { - for (t = 0; t < w; t++) { - int dx = x + (piece_w * t); - int dy = y + (piece_h * i); - int dw, dh; - if ((dx + piece_w) > screen_w) - dw = piece_w - ((dx + piece_w) - screen_w); - else - dw = piece_w; - if ((dy + piece_h) > screen_h) - dh = piece_h - ((dy + piece_h) - screen_h); - else - dh = piece_h; - - float u2 = (float)dw / (float)piece_w; - float v2 = (float)dh / (float)piece_h; - rend_DrawSimpleBitmap(bm_array[i * w + t], dx, dy); - } - } - rend_SetZBufferState(1); -} - -// given a chunked bitmap, renders it.scaled -void rend_DrawScaledChunkedBitmap(chunked_bitmap *chunk, int x, int y, int neww, int newh, uint8_t alpha) { - int *bm_array = chunk->bm_array; - int w = chunk->w; - int h = chunk->h; - int piece_w; - int piece_h; - int screen_w, screen_h; - int i, t; - - float scalew, scaleh; - - scalew = ((float)neww) / ((float)chunk->pw); - scaleh = ((float)newh) / ((float)chunk->ph); - piece_w = scalew * ((float)bm_w(bm_array[0], 0)); - piece_h = scaleh * ((float)bm_h(bm_array[0], 0)); - rend_GetProjectionParameters(&screen_w, &screen_h); - rend_SetOverlayType(OT_NONE); - rend_SetLighting(LS_NONE); - rend_SetColorModel(CM_MONO); - rend_SetZBufferState(0); - rend_SetAlphaType(AT_CONSTANT_TEXTURE); - rend_SetAlphaValue(alpha); - rend_SetWrapType(WT_WRAP); - for (i = 0; i < h; i++) { - for (t = 0; t < w; t++) { - int dx = x + (piece_w * t); - int dy = y + (piece_h * i); - int dw, dh; - if ((dx + piece_w) > screen_w) - dw = piece_w - ((dx + piece_w) - screen_w); - else - dw = piece_w; - if ((dy + piece_h) > screen_h) - dh = piece_h - ((dy + piece_h) - screen_h); - else - dh = piece_h; - - float u2 = (float)dw / (float)piece_w; - float v2 = (float)dh / (float)piece_h; - rend_DrawScaledBitmap(dx, dy, dx + dw, dy + dh, bm_array[i * w + t], 0, 0, u2, v2); - } - } - rend_SetZBufferState(1); -} - -// Sets some global preferences for the renderer -int rend_SetPreferredState(renderer_preferred_state *pref_state) { - int retval = 1; - renderer_preferred_state old_state = gpu_preferred_state; - - gpu_preferred_state = *pref_state; - if (gpu_state.initted) { - int reinit = 0; - mprintf(0, "Inside pref state!\n"); - - // Change gamma if needed - if (pref_state->width != gpu_state.screen_width || pref_state->height != gpu_state.screen_height || - old_state.bit_depth != pref_state->bit_depth) { - reinit = 1; - } - - if (reinit) { - retval = rend_ReInit(); - } else { - if (old_state.gamma != pref_state->gamma) { - rend_SetGammaValue(pref_state->gamma); - } - } - } else { - gpu_preferred_state = *pref_state; - } - - return retval; -} - -// Draws a simple bitmap at the specified x,y location -void rend_DrawSimpleBitmap(int bm_handle, int x, int y) { - rend_SetAlphaType(AT_CONSTANT_TEXTURE); - rend_SetAlphaValue(255); - rend_SetLighting(LS_NONE); - rend_SetColorModel(CM_MONO); - rend_SetOverlayType(OT_NONE); - rend_SetFiltering(0); - rend_DrawScaledBitmap(x, y, x + bm_w(bm_handle, 0), y + bm_h(bm_handle, 0), bm_handle, 0, 0, 1, 1); - rend_SetFiltering(1); -} - -// Fills in the passed in pointer with the current rendering state -void rend_GetRenderState(rendering_state *rstate) { memcpy(rstate, &gpu_state, sizeof(rendering_state)); } - -// Preuploads a texture to the video card -void rend_PreUploadTextureToCard(int handle, int map_type) {} - -// Frees an uploaded texture from the video card -void rend_FreePreUploadedTexture(int handle, int map_type) {} - -// Returns 1 if there is mid video memory, 2 if there is low vid memory, or 0 if there is large vid memory -int rend_LowVidMem(void) { return 0; } - -// Returns 1 if the renderer supports bumpmapping -int rend_SupportsBumpmapping(void) { return 0; } - -// Sets a bumpmap to be rendered, or turns off bumpmapping altogether -void rend_SetBumpmapReadyState(int state, int map) {} - -// returns rendering statistics for the frame -void rend_GetStatistics(tRendererStats *stats) { - if (Renderer_initted) { - stats->poly_count = gpu_last_frame_polys_drawn; - stats->vert_count = gpu_last_frame_verts_processed; - stats->texture_uploads = gpu_last_uploaded; - } else { - memset(stats, 0, sizeof(tRendererStats)); - } -} - -#ifdef DEDICATED_ONLY - -void rend_DrawPolygon2D(int, g3Point **, int, int) {} -void rend_DrawPolygon3D(int, g3Point **, int, int) {} - -#else - -// Takes nv vertices and draws the 2D polygon defined by those vertices. -// Uses bitmap "handle" as a texture -void rend_DrawPolygon2D(int handle, g3Point **p, int nv) { - ASSERT(nv < 100); - ASSERT(gpu_Overlay_type == OT_NONE); - - g3_RefreshTransforms(true); - - if (UseMultitexture) { - gpu_SetMultitextureBlendMode(false); - } - - int xAdd = gpu_state.clip_x1; - int yAdd = gpu_state.clip_y1; - - float fr, fg, fb; - if (gpu_state.cur_light_state == LS_FLAT_GOURAUD || gpu_state.cur_texture_quality == 0) { - float scale = 1.0f / 255.0f; - fr = GR_COLOR_RED(gpu_state.cur_color) * scale; - fg = GR_COLOR_GREEN(gpu_state.cur_color) * scale; - fb = GR_COLOR_BLUE(gpu_state.cur_color) * scale; - } - - // make sure our bitmap is ready to be drawn - gpu_BindTexture(handle, MAP_TYPE_BITMAP, 0); - - float alpha = gpu_Alpha_multiplier * gpu_Alpha_factor; - - PosColorUVVertex *vData = &vArray[0]; - - // Specify our coordinates - int i; - for (i = 0; i < nv; ++i, ++vData) { - g3Point *pnt = p[i]; - - if (gpu_state.cur_alpha_type & ATF_VERTEX) { - // the alpha should come from the vertex - alpha = pnt->p3_a * gpu_Alpha_multiplier * gpu_Alpha_factor; - } - - // If we have a lighting model, apply the correct lighting! - if (gpu_state.cur_light_state == LS_FLAT_GOURAUD || gpu_state.cur_texture_quality == 0) { - // pull the color from the constant color data - vData->color.r = fr; - vData->color.g = fg; - vData->color.b = fb; - vData->color.a = alpha; - } else if (gpu_state.cur_light_state != LS_NONE) { - // Do lighting based on intensity (MONO) or colored (RGB) - if (gpu_state.cur_color_model == CM_MONO) { - vData->color.r = pnt->p3_l; - vData->color.g = pnt->p3_l; - vData->color.b = pnt->p3_l; - vData->color.a = alpha; - } else { - vData->color.r = pnt->p3_r; - vData->color.g = pnt->p3_g; - vData->color.b = pnt->p3_b; - vData->color.a = alpha; - } - } else { - // force white - vData->color.r = 1.0f; - vData->color.g = 1.0f; - vData->color.b = 1.0f; - vData->color.a = alpha; - } - - vData->uv.s = pnt->p3_u; - vData->uv.t = pnt->p3_v; - vData->uv.r = 0.0f; - vData->uv.w = 1.0f; - - // Finally, specify a vertex - vData->pos.x = pnt->p3_sx + xAdd; - vData->pos.y = pnt->p3_sy + yAdd; - vData->pos.z = 0.0f; - } - - gpu_RenderPolygon(&vArray[0], nv); -} - - -// Takes nv vertices and draws the 3D polygon defined by those vertices. -// Uses bitmap "handle" as a texture -void rend_DrawPolygon3D(int handle, g3Point **p, int nv, int map_type) { - g3Point *pnt; - int i; - float fr, fg, fb; - float alpha; - - ASSERT(nv < 100); - - g3_RefreshTransforms(false); - - if (gpu_state.cur_texture_quality == 0) { - gpu_DrawFlatPolygon3D(p, nv); - return; - } - - if (gpu_Overlay_type != OT_NONE && UseMultitexture) { - rend_DrawMultitexturePolygon3D(handle, p, nv, map_type); - return; - } - - if (gpu_state.cur_light_state == LS_FLAT_GOURAUD) { - fr = GR_COLOR_RED(gpu_state.cur_color) / 255.0; - fg = GR_COLOR_GREEN(gpu_state.cur_color) / 255.0; - fb = GR_COLOR_BLUE(gpu_state.cur_color) / 255.0; - } - - if (UseMultitexture) { - gpu_SetMultitextureBlendMode(false); - } - - gpu_BindTexture(handle, map_type, 0); - - alpha = gpu_Alpha_multiplier * gpu_Alpha_factor; - - PosColorUVVertex *vData = &vArray[0]; - - // Specify our coordinates - for (i = 0; i < nv; i++, vData++) { - pnt = p[i]; - - // all points should be original - ASSERT(pnt->p3_flags & PF_ORIGPOINT); - - //////////////////////////////////////////// - if (pnt->p3_flags & PF_ORIGPOINT) { - if (!(pnt->p3_flags & PF_PROJECTED)) { - g3_ProjectPoint(pnt); - } - - // get the original point - float origPoint[4]; - origPoint[0] = pnt->p3_vecPreRot.x; - origPoint[1] = pnt->p3_vecPreRot.y; - origPoint[2] = pnt->p3_vecPreRot.z; - origPoint[3] = 1.0f; - - // transform by the full transform - float view[4]; - g3_TransformVert(view, origPoint, gTransformFull); - - vector tempv = pnt->p3_vecPreRot - View_position; - vector testPt = tempv * Unscaled_matrix; - - float screenX = pnt->p3_sx + gpu_state.clip_x1; - float screenY = pnt->p3_sy + gpu_state.clip_y1; - - // normalize - float oOW = 1.0f / view[3]; - view[0] *= oOW; - view[1] *= oOW; - view[2] *= oOW; - - oOW *= 1.0f; - } - //////////////////////////////////////////// - - if (gpu_state.cur_alpha_type & ATF_VERTEX) { - alpha = pnt->p3_a * gpu_Alpha_multiplier * gpu_Alpha_factor; - } - - // If we have a lighting model, apply the correct lighting! - if (gpu_state.cur_light_state != LS_NONE) { - if (gpu_state.cur_light_state == LS_FLAT_GOURAUD) { - vData->color.r = fr; - vData->color.g = fg; - vData->color.b = fb; - vData->color.a = alpha; - } else { - // Do lighting based on intesity (MONO) or colored (RGB) - if (gpu_state.cur_color_model == CM_MONO) { - vData->color.r = pnt->p3_l; - vData->color.g = pnt->p3_l; - vData->color.b = pnt->p3_l; - vData->color.a = alpha; - } else { - vData->color.r = pnt->p3_r; - vData->color.g = pnt->p3_g; - vData->color.b = pnt->p3_b; - vData->color.a = alpha; - } - } - } else { - vData->color.r = 1; - vData->color.g = 1; - vData->color.b = 1; - vData->color.a = alpha; - } - - vData->uv.s = pnt->p3_u; - vData->uv.t = pnt->p3_v; - vData->uv.r = 0.0f; - vData->uv.w = 1.0f; - - // Finally, specify a vertex - vData->pos = pnt->p3_vecPreRot; - } - - // And draw! - gpu_RenderPolygon(&vArray[0], nv); - - // If there is a lightmap to draw, draw it as well - if (gpu_Overlay_type != OT_NONE) { - return; // Temp fix until I figure out whats going on - Int3(); // Shouldn't reach here - } -} - -#endif // DEDICATED_ONLY - -// Takes nv vertices and draws the polygon defined by those vertices. Uses bitmap "handle" -// as a texture -void rend_DrawMultitexturePolygon3D(int handle, g3Point **p, int nv, int map_type) { - g3Point *pnt; - int i, fr, fg, fb; - float alpha; - - float one_over_square_res = 1.0 / GameLightmaps[gpu_Overlay_map].square_res; - float xscalar = (float)GameLightmaps[gpu_Overlay_map].width * one_over_square_res; - float yscalar = (float)GameLightmaps[gpu_Overlay_map].height * one_over_square_res; - - ASSERT(nv < 100); - - if (gpu_state.cur_light_state == LS_NONE) { - fr = GR_COLOR_RED(gpu_state.cur_color); - fg = GR_COLOR_GREEN(gpu_state.cur_color); - fb = GR_COLOR_BLUE(gpu_state.cur_color); - } - - alpha = gpu_Alpha_multiplier * gpu_Alpha_factor; - - PosColorUV2Vertex *vData = &vArray2[0]; - - // Specify our coordinates - for (i = 0; i < nv; i++, vData++) { - pnt = p[i]; - ASSERT(pnt->p3_flags & PF_ORIGPOINT); - - if (gpu_state.cur_alpha_type & ATF_VERTEX) - alpha = pnt->p3_a * gpu_Alpha_multiplier * gpu_Alpha_factor; - - // If we have a lighting model, apply the correct lighting! - if (gpu_state.cur_light_state != LS_NONE) { - // Do lighting based on intesity (MONO) or colored (RGB) - if (gpu_state.cur_color_model == CM_MONO) { - vData->color.r = pnt->p3_l; - vData->color.g = pnt->p3_l; - vData->color.b = pnt->p3_l; - vData->color.a = alpha; - } else { - vData->color.r = pnt->p3_r; - vData->color.g = pnt->p3_g; - vData->color.b = pnt->p3_b; - vData->color.a = alpha; - } - } else { - vData->color.r = 1; - vData->color.g = 1; - vData->color.b = 1; - vData->color.a = alpha; - } - - /* - // Texture this polygon! - float texw=1.0/(pnt->p3_z+Z_bias); - vData->uv0.s=pnt->p3_u*texw; - vData->uv0.t=pnt->p3_v*texw; - vData->uv0.r=0; - vData->uv0.w=texw; - - vData->uv1.s=pnt->p3_u2*xscalar*texw; - vData->uv1.t=pnt->p3_v2*yscalar*texw; - vData->uv1.r=0; - vData->uv1.w=texw; - */ - vData->uv0.s = pnt->p3_u; - vData->uv0.t = pnt->p3_v; - vData->uv0.r = 0.0f; - vData->uv0.w = 1.0f; - - vData->uv1.s = pnt->p3_u2 * xscalar; - vData->uv1.t = pnt->p3_v2 * yscalar; - vData->uv1.r = 0.0f; - vData->uv1.w = 1.0f; - - // Finally, specify a vertex - /* - vData->pos.x=pnt->p3_sx+x_add; - vData->pos.y=pnt->p3_sy+y_add; - vData->pos.z = -std::max(0,std::min(1.0,1.0-(1.0/(pnt->p3_z+Z_bias)))); - */ - vData->pos = pnt->p3_vecPreRot; - } - - // make sure our bitmap is ready to be drawn - gpu_BindTexture(handle, map_type, 0); - - // make sure our bitmap is ready to be drawn - gpu_BindTexture(gpu_Overlay_map, MAP_TYPE_LIGHTMAP, 1); - - gpu_SetMultitextureBlendMode(true); - - gpu_RenderPolygonUV2(&vArray2[0], nv); -} diff --git a/renderer/HardwareClipper.cpp b/renderer/HardwareClipper.cpp deleted file mode 100644 index ec956c3cd..000000000 --- a/renderer/HardwareClipper.cpp +++ /dev/null @@ -1,388 +0,0 @@ -/* -* Descent 3 -* Copyright (C) 2024 Parallax Software -* -* This program is free software: you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation, either version 3 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program. If not, see . -*/ - -#include "pserror.h" -#include "3d.h" -#include "HardwareInternal.h" - -static int free_point_num = -1; -static g3Point temp_points[MAX_POINTS_IN_POLY]; -static g3Point *free_points[MAX_POINTS_IN_POLY]; -vector Clip_plane_point; - -void InitFreePoints(void) { - int i; - - for (i = 0; i < MAX_POINTS_IN_POLY; i++) { - free_points[i] = &temp_points[i]; - } - free_point_num = 0; -} - -g3Point *GetTempPoint(void) { - ASSERT(free_point_num < MAX_POINTS_IN_POLY); - - g3Point *p = free_points[free_point_num++]; - p->p3_flags = PF_TEMP_POINT; - return p; -} - -void FreeTempPoint(g3Point *p) { - if (free_point_num < 1) { - mprintf(1, "clipper: no temp points to free\n"); - free_point_num = 1; - Int3(); - } - ASSERT(p->p3_flags & PF_TEMP_POINT); - - free_points[--free_point_num] = p; - - p->p3_flags &= ~PF_TEMP_POINT; -} - -// Verify that all the temp points are free, and free them it they are not. -#ifdef _DEBUG -void CheckTempPoints(void) { - if (free_point_num) { - Int3(); - InitFreePoints(); - } -} -#endif - -// Free up any temp points (created by the clipper) in the given pointlist -// Parameters: pointlist - pointer to list of pointers to points, returned by g3_ClipPolygon() -// nv - the number of points in pointlist -void g3_FreeTempPoints(g3Point **pointlist, int nv) { - // Go through list - int i; - for (i = 0; i < nv; i++) { - if (pointlist[i]->p3_flags & PF_TEMP_POINT) { - FreeTempPoint(pointlist[i]); - } - } - - // Make sure all temp points are freed - CheckTempPoints(); -} - -// Clips an edge against the far plane -g3Point *ClipFarEdge(g3Point *on_pnt, g3Point *off_pnt) { - float z_on = on_pnt->p3_z; - float z_off = off_pnt->p3_z; - - float k = 1.0f - ((z_off - Far_clip_z) / (z_off - z_on)); - - g3Point *tmp = GetTempPoint(); - tmp->p3_z = on_pnt->p3_z + ((off_pnt->p3_z - on_pnt->p3_z) * k); - tmp->p3_x = on_pnt->p3_x + ((off_pnt->p3_x - on_pnt->p3_x) * k); - tmp->p3_y = on_pnt->p3_y + ((off_pnt->p3_y - on_pnt->p3_y) * k); - - if (on_pnt->p3_flags & PF_UV) { - tmp->p3_u = on_pnt->p3_u + ((off_pnt->p3_u - on_pnt->p3_u) * k); - tmp->p3_v = on_pnt->p3_v + ((off_pnt->p3_v - on_pnt->p3_v) * k); - tmp->p3_flags |= PF_UV; - } - - if (on_pnt->p3_flags & PF_UV2) { - tmp->p3_u2 = on_pnt->p3_u2 + ((off_pnt->p3_u2 - on_pnt->p3_u2) * k); - tmp->p3_v2 = on_pnt->p3_v2 + ((off_pnt->p3_v2 - on_pnt->p3_v2) * k); - tmp->p3_flags |= PF_UV2; - } - - if (on_pnt->p3_flags & PF_L) { - tmp->p3_l = on_pnt->p3_l + ((off_pnt->p3_l - on_pnt->p3_l) * k); - tmp->p3_flags |= PF_L; - } - - if (on_pnt->p3_flags & PF_RGBA) { - tmp->p3_r = on_pnt->p3_r + ((off_pnt->p3_r - on_pnt->p3_r) * k); - tmp->p3_g = on_pnt->p3_g + ((off_pnt->p3_g - on_pnt->p3_g) * k); - tmp->p3_b = on_pnt->p3_b + ((off_pnt->p3_b - on_pnt->p3_b) * k); - tmp->p3_a = on_pnt->p3_a + ((off_pnt->p3_a - on_pnt->p3_a) * k); - tmp->p3_flags |= PF_RGBA; - } - - g3_CodePoint(tmp); - return tmp; -} - -// Clips an edge against the far plane -g3Point *ClipCustomEdge(g3Point *on_pnt, g3Point *off_pnt) { - g3Point *tmp = GetTempPoint(); - - vector ray_direction = off_pnt->p3_vec - on_pnt->p3_vec; - ray_direction.x /= Matrix_scale.x; - ray_direction.y /= Matrix_scale.y; - ray_direction.z /= Matrix_scale.z; - - vector w = on_pnt->p3_vec - Clip_plane_point; - w.x /= Matrix_scale.x; - w.y /= Matrix_scale.y; - w.z /= Matrix_scale.z; - - float k, den = -(Clip_plane * ray_direction); - if (den == 0.0f) { - k = 1.0f; - } else { - float num = Clip_plane * w; - k = num / den; - } - - tmp->p3_vec = on_pnt->p3_vec + ((off_pnt->p3_vec - on_pnt->p3_vec) * k); - - if (on_pnt->p3_flags & PF_UV) { - tmp->p3_u = on_pnt->p3_u + ((off_pnt->p3_u - on_pnt->p3_u) * k); - tmp->p3_v = on_pnt->p3_v + ((off_pnt->p3_v - on_pnt->p3_v) * k); - tmp->p3_flags |= PF_UV; - } - - if (on_pnt->p3_flags & PF_UV2) { - tmp->p3_u2 = on_pnt->p3_u2 + ((off_pnt->p3_u2 - on_pnt->p3_u2) * k); - tmp->p3_v2 = on_pnt->p3_v2 + ((off_pnt->p3_v2 - on_pnt->p3_v2) * k); - tmp->p3_flags |= PF_UV2; - } - - if (on_pnt->p3_flags & PF_L) { - tmp->p3_l = on_pnt->p3_l + ((off_pnt->p3_l - on_pnt->p3_l) * k); - tmp->p3_flags |= PF_L; - } - - if (on_pnt->p3_flags & PF_RGBA) { - tmp->p3_r = on_pnt->p3_r + ((off_pnt->p3_r - on_pnt->p3_r) * k); - tmp->p3_g = on_pnt->p3_g + ((off_pnt->p3_g - on_pnt->p3_g) * k); - tmp->p3_b = on_pnt->p3_b + ((off_pnt->p3_b - on_pnt->p3_b) * k); - tmp->p3_a = on_pnt->p3_a + ((off_pnt->p3_a - on_pnt->p3_a) * k); - tmp->p3_flags |= PF_RGBA; - } - - g3_CodePoint(tmp); - return tmp; -} - -// clips an edge against one plane. -g3Point *ClipEdge(int plane_flag, g3Point *on_pnt, g3Point *off_pnt) { - float a, b, k; - g3Point *tmp; - - // compute clipping value k = (xs-zs) / (xs-xe-zs+ze) - // use x or y as appropriate, and negate x/y value as appropriate - - if (plane_flag & CC_OFF_FAR) { - return ClipFarEdge(on_pnt, off_pnt); - } - - if ((plane_flag & CC_OFF_CUSTOM) && Clip_custom) { - return ClipCustomEdge(on_pnt, off_pnt); - } - - if (plane_flag & (CC_OFF_RIGHT | CC_OFF_LEFT)) { - a = on_pnt->p3_x; - b = off_pnt->p3_x; - } else { - a = on_pnt->p3_y; - b = off_pnt->p3_y; - } - - if (plane_flag & (CC_OFF_LEFT | CC_OFF_BOT)) { - a = -a; - b = -b; - } - - k = (a - on_pnt->p3_z) / ((a - on_pnt->p3_z) - b + off_pnt->p3_z); //(xs-zs) / (xs-zs-xe+ze) - - tmp = GetTempPoint(); - - tmp->p3_x = on_pnt->p3_x + ((off_pnt->p3_x - on_pnt->p3_x) * k); - tmp->p3_y = on_pnt->p3_y + ((off_pnt->p3_y - on_pnt->p3_y) * k); - - if (plane_flag & (CC_OFF_TOP | CC_OFF_BOT)) { - tmp->p3_z = tmp->p3_y; - } else { - tmp->p3_z = tmp->p3_x; - } - - if (plane_flag & (CC_OFF_LEFT | CC_OFF_BOT)) { - tmp->p3_z = -tmp->p3_z; - } - - if (on_pnt->p3_flags & PF_UV) { - tmp->p3_u = on_pnt->p3_u + ((off_pnt->p3_u - on_pnt->p3_u) * k); - tmp->p3_v = on_pnt->p3_v + ((off_pnt->p3_v - on_pnt->p3_v) * k); - - tmp->p3_flags |= PF_UV; - } - - if (on_pnt->p3_flags & PF_UV2) { - tmp->p3_u2 = on_pnt->p3_u2 + ((off_pnt->p3_u2 - on_pnt->p3_u2) * k); - tmp->p3_v2 = on_pnt->p3_v2 + ((off_pnt->p3_v2 - on_pnt->p3_v2) * k); - - tmp->p3_flags |= PF_UV2; - } - - if (on_pnt->p3_flags & PF_L) { - tmp->p3_l = on_pnt->p3_l + ((off_pnt->p3_l - on_pnt->p3_l) * k); - tmp->p3_flags |= PF_L; - } - - if (on_pnt->p3_flags & PF_RGBA) { - tmp->p3_r = on_pnt->p3_r + ((off_pnt->p3_r - on_pnt->p3_r) * k); - tmp->p3_g = on_pnt->p3_g + ((off_pnt->p3_g - on_pnt->p3_g) * k); - tmp->p3_b = on_pnt->p3_b + ((off_pnt->p3_b - on_pnt->p3_b) * k); - tmp->p3_a = on_pnt->p3_a + ((off_pnt->p3_a - on_pnt->p3_a) * k); - tmp->p3_flags |= PF_RGBA; - } - - g3_CodePoint(tmp); - - return tmp; -} - -// clips a line to the viewing pyramid. -void ClipLine(g3Point **p0, g3Point **p1, uint8_t codes_or) { - int plane_flag; - g3Point *old_p1; - - // might have these left over - //(*p0)->p3_flags &= ~(PF_UV|PF_L|PF_RGBA|PF_UV2); - //(*p1)->p3_flags &= ~(PF_UV|PF_L|PF_RGBA|PF_UV2); - - for (plane_flag = 1; plane_flag <= 32; plane_flag <<= 1) { - if (codes_or & plane_flag) { - if ((*p0)->p3_codes & plane_flag) { - // swap! - g3Point *t = *p0; - *p0 = *p1; - *p1 = t; - } - - old_p1 = *p1; - - *p1 = ClipEdge(plane_flag, *p0, *p1); - - codes_or = (*p0)->p3_codes | (*p1)->p3_codes; // get new codes - - if (old_p1->p3_flags & PF_TEMP_POINT) { - FreeTempPoint(old_p1); - } - } - } -} - -int ClipPlane(int plane_flag, g3Point **src, g3Point **dest, int *nv, g3Codes *cc) { - int i, prev, next; - g3Point **save_dest = dest; - - // Init codes - cc->cc_and = 0xff; - cc->cc_or = 0; - - for (i = 0, prev = *nv - 1, next = 1; i < *nv; i++) { - if (src[i]->p3_codes & plane_flag) { - // cur point off? - if (!(src[prev]->p3_codes & plane_flag)) { - // prev not off? - *dest = ClipEdge(plane_flag, src[prev], src[i]); - cc->cc_or |= (*dest)->p3_codes; - cc->cc_and &= (*dest)->p3_codes; - dest++; - } - - if (!(src[next]->p3_codes & plane_flag)) { - *dest = ClipEdge(plane_flag, src[next], src[i]); - cc->cc_or |= (*dest)->p3_codes; - cc->cc_and &= (*dest)->p3_codes; - dest++; - } - - // see if must free discarded point - if (src[i]->p3_flags & PF_TEMP_POINT) { - FreeTempPoint(src[i]); - } - } else { - // cur not off, copy to dest buffer - *dest++ = src[i]; - - cc->cc_or |= src[i]->p3_codes; - cc->cc_and &= src[i]->p3_codes; - } - - prev = i; - if (++next == *nv) { - next = 0; - } - } - - return (dest - save_dest); -} - -// temp buffers for clipping -static g3Point *Vbuf0[MAX_POINTS_IN_POLY]; -static g3Point *Vbuf1[MAX_POINTS_IN_POLY]; - -// Clips a polygon -// Parameters: pointlist - pointer to a list of pointers to points -// nv - the number of points in the polygon -// cc - the clip codes for this polygon -// Returns: a pointer to a list of pointer of points in the clipped polygon -// NOTE: You MUST call g3_FreeTempPoints() when you're done with the clipped polygon -g3Point **g3_ClipPolygon(g3Point **pointlist, int *nv, g3Codes *cc) { - int plane_flag; - g3Point **dest; - - dest = Vbuf0; - - //& ASSERT(free_point_num == 0); //DAJ UTB CMO - if (free_point_num != 0) { - mprintf(1, "clipper: leftover temp point\n"); - free_point_num = 0; - Int3(); - } - - for (plane_flag = 1; plane_flag <= 32; plane_flag <<= 1) { - if (cc->cc_or & plane_flag) { - - *nv = ClipPlane(plane_flag, pointlist, dest, nv, cc); - - if (cc->cc_and) // clipped away - return dest; - - pointlist = dest; - dest = (pointlist == Vbuf0) ? Vbuf1 : Vbuf0; - } - } - return pointlist; // we swapped after we copied -} - -// sets the z distance of the far clipping plane -void g3_SetFarClipZ(float z) { Far_clip_z = z; } - -// Sets up a custom clipping plane - g3_StartFrame must be called before this is called -void g3_SetCustomClipPlane(uint8_t state, vector *pnt, vector *normal) { - Clip_custom = state; - if (state) { - vector tempv; - vector norm = *normal; - - tempv = *pnt - View_position; - Clip_plane_point = tempv * View_matrix; - - Clip_plane = norm * Unscaled_matrix; // View_matrix; - vm_NormalizeVector(&Clip_plane); - } -} diff --git a/renderer/HardwareDraw.cpp b/renderer/HardwareDraw.cpp deleted file mode 100644 index 4daa329d3..000000000 --- a/renderer/HardwareDraw.cpp +++ /dev/null @@ -1,434 +0,0 @@ -/* -* Descent 3 -* Copyright (C) 2024 Parallax Software -* -* This program is free software: you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation, either version 3 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program. If not, see . -*/ - -#include "3d.h" -#include "HardwareInternal.h" -#include "renderer.h" - -#define round(v) ((int)(((v) + 0.5f))) - -// draws a line. takes two points. returns true if drew -void g3_DrawLine(ddgr_color color, g3Point *p0, g3Point *p1) { - uint8_t codes_or; - bool was_clipped = 0; - - if (p0->p3_codes & p1->p3_codes) - return; - - codes_or = p0->p3_codes | p1->p3_codes; - - if (codes_or) { - ClipLine(&p0, &p1, codes_or); - was_clipped = 1; - } - - if (!(p0->p3_flags & PF_PROJECTED)) { - g3_ProjectPoint(p0); - } - - if (!(p1->p3_flags & PF_PROJECTED)) { - g3_ProjectPoint(p1); - } - - rend_SetFlatColor(color); - rend_DrawLine(round(p0->p3_sx), round(p0->p3_sy), round(p1->p3_sx), round(p1->p3_sy)); - - // If was clipped, free temp points - if (was_clipped) { - if (p0->p3_flags & PF_TEMP_POINT) { - FreeTempPoint(p0); - } - - if (p1->p3_flags & PF_TEMP_POINT) { - FreeTempPoint(p1); - } - - // Make sure all temp points have been freed - CheckTempPoints(); - } -} - -// draws a line based on the current setting of render states. takes two points. returns true if drew -void g3_DrawSpecialLine(g3Point *p0, g3Point *p1) { - uint8_t codes_or; - bool was_clipped = 0; - - if (p0->p3_codes & p1->p3_codes) - return; - - codes_or = p0->p3_codes | p1->p3_codes; - - if (codes_or) { - - ClipLine(&p0, &p1, codes_or); - - was_clipped = 1; - } - - if (!(p0->p3_flags & PF_PROJECTED)) - g3_ProjectPoint(p0); - - if (!(p1->p3_flags & PF_PROJECTED)) - g3_ProjectPoint(p1); - - rend_DrawSpecialLine(p0, p1); - - // If was clipped, free temp points - if (was_clipped) { - if (p0->p3_flags & PF_TEMP_POINT) - FreeTempPoint(p0); - - if (p1->p3_flags & PF_TEMP_POINT) - FreeTempPoint(p1); - - // Make sure all temp points have been freed - CheckTempPoints(); - } -} - -// returns true if a plane is facing the viewer. takes the unrotated surface -// normal of the plane, and a point on it. The normal need not be normalized -bool g3_CheckNormalFacing(vector *v, vector *norm) { - vector tempv; - - tempv = View_position - *v; - - return ((tempv * *norm) > 0); -} - -bool DoFacingCheck(vector *norm, g3Point **vertlist, vector *p) { - if (norm) { - // have normal - ASSERT(norm->x || norm->y || norm->z); - return g3_CheckNormalFacing(p, norm); - } else { - // normal not specified, so must compute - vector tempv; - // get three points (rotated) and compute normal - vm_GetPerp(&tempv, &vertlist[0]->p3_vec, &vertlist[1]->p3_vec, &vertlist[2]->p3_vec); - return ((tempv * vertlist[1]->p3_vec) < 0); - } -} - -// like g3_DrawPoly(), but checks to see if facing. If surface normal is -// NULL, this routine must compute it, which will be slow. It is better to -// pre-compute the normal, and pass it to this function. When the normal -// is passed, this function works like g3_CheckNormalFacing() plus -// g3_DrawPoly(). -void g3_CheckAndDrawPoly(int nv, g3Point **pointlist, int bm, vector *norm, vector *pnt) { - if (DoFacingCheck(norm, pointlist, pnt)) - g3_DrawPoly(nv, pointlist, bm); -} - -int Triangulate_test = 0; - -// draw a polygon -// Parameters: nv - the number of verts in the poly -// pointlist - a pointer to a list of pointers to points -// bm - the bitmap handle if texturing. ignored if flat shading -// Returns 0 if clipped away -int g3_DrawPoly(int nv, g3Point **pointlist, int bm, int map_type, g3Codes *clip_codes) { - rend_DrawPolygon3D(bm, pointlist, nv, map_type); - return 1; - - /* - int i; - g3Codes cc; - bool was_clipped=0; - - if( Triangulate_test && (nv > 3) ) - { - g3Point *tripoints[3]; - int sum=0; - - for (i=0;ip3_codes; - cc.cc_and &= c; - cc.cc_or |= c; - } - } - - //All points off screen? - if( cc.cc_and ) - return 0; - - //One or more point off screen, so clip - if( cc.cc_or ) - { - //Clip the polygon, getting pointer to new buffer - pointlist = g3_ClipPolygon( pointlist, &nv, &cc ); - - //Flag as clipped so temp points will be freed - was_clipped = 1; - - //Check for polygon clipped away, or clip otherwise failed - if( (nv==0) || (cc.cc_or&CC_BEHIND) || cc.cc_and ) - goto free_points; - } - - //Make list of 2d coords (& check for overflow) - for( i = 0; i < nv; ++i ) - { - g3Point *p = pointlist[i]; - - //Project if needed - if( !(p->p3_flags&PF_PROJECTED) ) - { - g3_ProjectPoint(p); - } - } - - //Draw! - rend_DrawPolygon3D( bm, pointlist, nv, map_type ); - -free_points:; - - //If was clipped, free temp points - if( was_clipped ) - { - g3_FreeTempPoints( pointlist, nv ); - } - - return 1; - */ -} - -// draw a sortof sphere - i.e., the 2d radius is proportional to the 3d -// radius, but not to the distance from the eye -void g3_DrawSphere(ddgr_color color, g3Point *pnt, float rad) { - if (!(pnt->p3_codes & CC_BEHIND)) { - if (!(pnt->p3_flags & PF_PROJECTED)) - g3_ProjectPoint(pnt); - - rend_FillCircle(color, pnt->p3_sx, pnt->p3_sy, (rad * Matrix_scale.x * Window_w2 / pnt->p3_z)); - } -} - -// draws a bitmap with the specified 3d width & height -// If offsets are not -1, then the blitter draws not from the upper left hand -// corner of the bitmap, but from size*offsetx,size*offsety -// See Jason for explaination -void g3_DrawBitmap(vector *pos, float width, float height, int bm, int color) { - // get the view orientation - matrix viewOrient; - g3_GetUnscaledMatrix(&viewOrient); - - // break down the color into components - float r, g, b; - if (color != -1) { - float scale = 1.0f / 255.0f; - r = GR_COLOR_RED(color) * scale; - g = GR_COLOR_GREEN(color) * scale; - b = GR_COLOR_BLUE(color) * scale; - } - - // calculate the four corners - g3Point corners[4], *pts[4]; - int i; - for (i = 0; i < 4; ++i) { - pts[i] = &corners[i]; - - // calculate the offset for this corner - float cornerScaleU = ((i & 1) ^ ((i & 2) >> 1)) ? 1.0f : -1.0f; - float cornerScaleV = (i & 2) ? 1.0f : -1.0f; - - // find the point (parallel to the view frame) - vector cornerPos = *pos + (viewOrient.uvec * (height * -cornerScaleV)) + (viewOrient.rvec * (width * cornerScaleU)); - corners[i].p3_codes = 0; - g3_RotatePoint(pts[i], &cornerPos); - - // setup the flags, UVs and colors - corners[i].p3_flags |= PF_UV; - corners[i].p3_uvl.u = (cornerScaleU * 0.5f) + 0.5f; - corners[i].p3_uvl.v = (cornerScaleV * 0.5f) + 0.5f; - if (color == -1) { - corners[i].p3_flags |= PF_L; - corners[i].p3_uvl.l = 1.0f; - } else { - corners[i].p3_flags |= PF_RGBA; - corners[i].p3_uvl.r = r; - corners[i].p3_uvl.g = g; - corners[i].p3_uvl.b = b; - } - corners[i].p3_uvl.a = 1.0f; - } - - rend_SetTextureType(TT_LINEAR); - rend_DrawPolygon3D(bm, pts, 4); -} - -// Draws a bitmap that has been rotated about its center. Angle of rotation is passed as 'rot_angle' -void g3_DrawRotatedBitmap(vector *pos, angle rot_angle, float width, float height, int bm, int color) { - // get the view orientation - matrix viewOrient; - g3_GetUnscaledMatrix(&viewOrient); - - matrix rot_matrix; - vm_AnglesToMatrix(&rot_matrix, 0, 0, rot_angle); - - float w = width; - float h = height; - - vector rot_vectors[4]; - rot_vectors[0].x = -w; - rot_vectors[0].y = h; - - rot_vectors[1].x = w; - rot_vectors[1].y = h; - - rot_vectors[2].x = w; - rot_vectors[2].y = -h; - - rot_vectors[3].x = -w; - rot_vectors[3].y = -h; - - g3Point rot_points[8], *pntlist[8]; - int i; - for (i = 0; i < 4; ++i) { - vector offset; - rot_vectors[i].z = 0.0f; - vm_MatrixMulVector(&offset, &rot_vectors[i], &rot_matrix); - - vector cornerPos = *pos + (viewOrient.uvec * offset.y) + (viewOrient.rvec * offset.x); - rot_points[i].p3_codes = 0; - g3_RotatePoint(&rot_points[i], &cornerPos); - - rot_points[i].p3_flags |= PF_UV | PF_RGBA; - rot_points[i].p3_l = 1.0f; - rot_points[i].p3_uvl.u = ((i & 1) ^ ((i & 2) >> 1)) ? 1.0f : 0.0f; - rot_points[i].p3_uvl.v = (i & 2) ? 1.0f : 0.0f; - - pntlist[i] = &rot_points[i]; - } - - // And draw!! - rend_SetTextureType(TT_LINEAR); - - if (color != -1) { - rend_SetLighting(LS_FLAT_GOURAUD); - rend_SetFlatColor(color); - } - - g3_DrawPoly(4, pntlist, bm); -} - -// Draws a bitmap on a specific plane. Also does rotation. Angle of rotation is passed as 'rot_angle' -void g3_DrawPlanarRotatedBitmap(vector *pos, vector *norm, angle rot_angle, float width, float height, int bm) { - matrix rot_matrix; - vm_VectorToMatrix(&rot_matrix, norm, NULL, NULL); - vm_TransposeMatrix(&rot_matrix); - - matrix twist_matrix; - vm_AnglesToMatrix(&twist_matrix, 0, 0, rot_angle); - - float w = width; - float h = height; - - vector rot_vectors[4]; - rot_vectors[0] = (twist_matrix.rvec * -w); - rot_vectors[0] += (twist_matrix.uvec * h); - - rot_vectors[1] = (twist_matrix.rvec * w); - rot_vectors[1] += (twist_matrix.uvec * h); - - rot_vectors[2] = (twist_matrix.rvec * w); - rot_vectors[2] -= (twist_matrix.uvec * h); - - rot_vectors[3] = (twist_matrix.rvec * -w); - rot_vectors[3] -= (twist_matrix.uvec * h); - - int i; - for (i = 0; i < 4; ++i) { - vector temp_vec = rot_vectors[i]; - vm_MatrixMulVector(&rot_vectors[i], &temp_vec, &rot_matrix); - } - - g3Point rot_points[8], *pntlist[8]; - for (i = 0; i < 4; ++i) { - rot_vectors[i] += *pos; - - g3_RotatePoint(&rot_points[i], &rot_vectors[i]); - rot_points[i].p3_flags |= PF_UV | PF_L; - rot_points[i].p3_l = 1.0f; - - pntlist[i] = &rot_points[i]; - } - - rot_points[0].p3_u = 0.0f; - rot_points[0].p3_v = 0.0f; - - rot_points[1].p3_u = 1.0f; - rot_points[1].p3_v = 0.0f; - - rot_points[2].p3_u = 1.0f; - rot_points[2].p3_v = 1.0f; - - rot_points[3].p3_u = 0.0f; - rot_points[3].p3_v = 1.0f; - - // And draw!! - rend_SetTextureType(TT_LINEAR); - g3_DrawPoly(4, pntlist, bm); -} - -// Draw a wireframe box aligned with the screen. Used for the editor. -// Parameters: color - the color to draw the lines -// pnt - the center point -// rad - specifies the width/2 & height/2 of the box -void g3_DrawBox(ddgr_color color, g3Point *pnt, float rad) { - if (!(pnt->p3_codes & CC_BEHIND)) { - if (!(pnt->p3_flags & PF_PROJECTED)) - g3_ProjectPoint(pnt); - - float w, h; - - w = rad * Matrix_scale.x * Window_w2 / pnt->p3_z; - h = rad * Matrix_scale.y * Window_h2 / pnt->p3_z; - - rend_DrawLine(round(pnt->p3_sx - w), round(pnt->p3_sy - h), round(pnt->p3_sx + w), round(pnt->p3_sy - h)); - rend_DrawLine(round(pnt->p3_sx + w), round(pnt->p3_sy - h), round(pnt->p3_sx + w), round(pnt->p3_sy + h)); - rend_DrawLine(round(pnt->p3_sx + w), round(pnt->p3_sy + h), round(pnt->p3_sx - w), round(pnt->p3_sy + h)); - rend_DrawLine(round(pnt->p3_sx - w), round(pnt->p3_sy + h), round(pnt->p3_sx - w), round(pnt->p3_sy - h)); - } -} - -// Sets the triangulation test to on or off -void g3_SetTriangulationTest(int state) { Triangulate_test = state; } diff --git a/renderer/HardwareInstance.cpp b/renderer/HardwareInstance.cpp deleted file mode 100644 index 487a184f1..000000000 --- a/renderer/HardwareInstance.cpp +++ /dev/null @@ -1,90 +0,0 @@ -/* -* Descent 3 -* Copyright (C) 2024 Parallax Software -* -* This program is free software: you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation, either version 3 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program. If not, see . -*/ - -#include "3d.h" -#include "HardwareInternal.h" -#include - -struct InstanceContext { - matrix m_viewMatrix; // matrix - matrix m_unscaledMatrix; // unscaled matrix - vector m_viewPosition; // position - float m_modelView[4][4]; // model/view transform -}; - -#define MAX_INSTANCE_DEPTH 30 -static InstanceContext sInstanceStack[MAX_INSTANCE_DEPTH]; -static int sInstanceDepth = 0; - -// instance at specified point with specified orientation -void g3_StartInstanceMatrix(vector *pos, matrix *orient) { - ASSERT(orient != NULL); - ASSERT(sInstanceDepth < MAX_INSTANCE_DEPTH); - - sInstanceStack[sInstanceDepth].m_viewMatrix = View_matrix; - sInstanceStack[sInstanceDepth].m_viewPosition = View_position; - sInstanceStack[sInstanceDepth].m_unscaledMatrix = Unscaled_matrix; - memcpy(sInstanceStack[sInstanceDepth].m_modelView, gTransformModelView, sizeof(gTransformModelView)); - ++sInstanceDepth; - - // step 1: subtract object position from view position - vector tempv = View_position - *pos; - - // step 2: rotate view vector through object matrix - View_position = tempv * *orient; - - // step 3: rotate object matrix through view_matrix (vm = ob * vm) - matrix tempm, tempm2 = ~*orient; - - tempm = tempm2 * View_matrix; - View_matrix = tempm; - - tempm = tempm2 * Unscaled_matrix; - Unscaled_matrix = tempm; - - // transform the model/view matrix - g3_GetModelViewMatrix(&View_position, &Unscaled_matrix, (float *)gTransformModelView); - g3_UpdateFullTransform(); -} - -// instance at specified point with specified orientation -void g3_StartInstanceAngles(vector *pos, angvec *angles) { - if (angles == NULL) { - matrix ident; - vm_MakeIdentity(&ident); - g3_StartInstanceMatrix(pos, &ident); - return; - } - - matrix tm; - vm_AnglesToMatrix(&tm, angles->p, angles->h, angles->b); - - g3_StartInstanceMatrix(pos, &tm); -} - -// pops the old context -void g3_DoneInstance() { - --sInstanceDepth; - ASSERT(sInstanceDepth >= 0); - - View_position = sInstanceStack[sInstanceDepth].m_viewPosition; - View_matrix = sInstanceStack[sInstanceDepth].m_viewMatrix; - Unscaled_matrix = sInstanceStack[sInstanceDepth].m_unscaledMatrix; - memcpy(gTransformModelView, sInstanceStack[sInstanceDepth].m_modelView, sizeof(gTransformModelView)); - g3_UpdateFullTransform(); -} diff --git a/renderer/HardwareInternal.h b/renderer/HardwareInternal.h index f625f9cc3..a19378fc6 100644 --- a/renderer/HardwareInternal.h +++ b/renderer/HardwareInternal.h @@ -1,4 +1,4 @@ -/* +/* * Descent 3 * Copyright (C) 2024 Parallax Software * @@ -15,7 +15,6 @@ * You should have received a copy of the GNU General Public License * along with this program. If not, see . */ - #ifndef __HARDWARE_INTERNAL_H__ #define __HARDWARE_INTERNAL_H__ @@ -23,45 +22,23 @@ #define MAX_POINTS_IN_POLY 100 -// These structs are for drawing with vertex arrays -// Useful for fast indexing -struct color_array { - float r, g, b, a; -}; - -struct tex_array { - float s, t, r, w; -}; - -struct PosColorUVVertex { - vector pos; - color_array color; - tex_array uv; -}; - -struct PosColorUV2Vertex { - vector pos; - color_array color; - tex_array uv0; - tex_array uv1; -}; - void FreeTempPoint(g3Point *p); void InitFreePoints(void); -void ClipLine(g3Point **p0, g3Point **p1, uint8_t codes_or); +void ClipLine(g3Point **p0,g3Point **p1,uint8_t codes_or); -// Verify that all the temp points are free, and free them it they are not. +//Verify that all the temp points are free, and free them it they are not. #ifdef _DEBUG void CheckTempPoints(); #else #define CheckTempPoints() #endif -extern int Window_width, Window_height; // the actual integer width & height -extern float Window_w2, Window_h2; // width,height/2 + +extern int Window_width,Window_height; //the actual integer width & height +extern float Window_w2,Window_h2; //width,height/2 extern float View_zoom; -extern vector View_position, Matrix_scale; -extern matrix View_matrix, Unscaled_matrix; +extern vector View_position,Matrix_scale; +extern matrix View_matrix,Unscaled_matrix; extern float Far_clip_z; // For custom clipping plane @@ -77,18 +54,8 @@ void g3_UpdateFullTransform(); void g3_ForceTransformRefresh(void); void rend_TransformSetToPassthru(void); -void rend_TransformSetViewport(int lx, int ty, int width, int height); -void rend_TransformSetProjection(float trans[4][4]); -void rend_TransformSetModelView(float trans[4][4]); - -int rend_ReInit(); -float rend_GetAlphaMultiplier(); - -void gpu_SetMultitextureBlendMode(bool state); -void gpu_BindTexture(int handle, int map_type, int slot); -void gpu_RenderPolygon(PosColorUVVertex *vData, uint32_t nv); -void gpu_RenderPolygonUV2(PosColorUV2Vertex *vData, uint32_t nv); -void gpu_DrawFlatPolygon3D(g3Point **p, int nv); -void rend_DrawMultitexturePolygon3D(int handle, g3Point **p, int nv, int map_type); +void rend_TransformSetViewport( int lx, int ty, int width, int height ); +void rend_TransformSetProjection( float trans[4][4] ); +void rend_TransformSetModelView( float trans[4][4] ); #endif diff --git a/renderer/HardwareOpenGL.cpp b/renderer/HardwareOpenGL.cpp deleted file mode 100644 index 259c0ac33..000000000 --- a/renderer/HardwareOpenGL.cpp +++ /dev/null @@ -1,2463 +0,0 @@ -/* -* Descent 3 -* Copyright (C) 2024 Parallax Software -* -* This program is free software: you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation, either version 3 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program. If not, see . -*/ - -#include "byteswap.h" -#if defined(WIN32) -#include -#elif defined(__LINUX__) -#include "lnxscreenmode.h" -#else -#endif - -#include "pserror.h" -#include "mono.h" -#include "3d.h" -#include "renderer.h" -#include "application.h" -#include "bitmap.h" -#include "lightmap.h" -#include "rend_opengl.h" -#include "grdefs.h" -#include "mem.h" -#include "config.h" -#include "rtperformance.h" -#include -#include -#include -#include "HardwareInternal.h" -#include "../Descent3/args.h" - -#include - -#define DECLARE_OPENGL -#include "dyna_gl.h" - -#if defined(WIN32) -#include "win/arb_extensions.h" -#endif - -#include - -int FindArg(const char *); -void rend_SetLightingState(light_state state); - -#define CHANGE_RESOLUTION_IN_FULLSCREEN - -// General renderer states -extern int gpu_Overlay_map; -int Bump_map = 0; -int Bumpmap_ready = 0; -extern uint8_t gpu_Overlay_type; -float Z_bias = 0.0f; -uint8_t Renderer_close_flag = 0; -extern uint8_t Renderer_initted; -renderer_type Renderer_type = RENDERER_OPENGL; -int WindowGL = 0; - -extern matrix Unscaled_matrix; -extern vector View_position; - -#ifndef GL_UNSIGNED_SHORT_5_5_5_1 -#define GL_UNSIGNED_SHORT_5_5_5_1 0x8034 -#endif - -#ifndef GL_UNSIGNED_SHORT_4_4_4_4 -#define GL_UNSIGNED_SHORT_4_4_4_4 0x8033 -#endif - -#define CHECK_ERROR(x) - -#if defined(WIN32) -// Moved from DDGR library -static HWND hOpenGLWnd = NULL; -static HDC hOpenGLDC = NULL; -HGLRC ResourceContext; -static WORD Saved_gamma_values[256 * 3]; -#elif defined(__LINUX__) -SDL_Window *GSDLWindow = NULL; -SDL_GLContext GSDLGLContext = NULL; -char loadedLibrary[_MAX_PATH]; -#else -#endif - -#define GET_WRAP_STATE(x) (x >> 4) -#define GET_FILTER_STATE(x) (x & 0x0f) - -#define SET_WRAP_STATE(x, s) \ - { \ - x &= 0x0F; \ - x |= (s << 4); \ - } -#define SET_FILTER_STATE(x, s) \ - { \ - x &= 0xF0; \ - x |= (s); \ - } - -// OpenGL Stuff -static int OpenGL_window_initted = 0; -static int OpenGL_polys_drawn = 0; -static int OpenGL_verts_processed = 0; -static int OpenGL_uploads = 0; -static int OpenGL_sets_this_frame[10]; -static int OpenGL_packed_pixels = 0; -static int Cur_texture_object_num = 1; -static int OpenGL_cache_initted = 0; -static int OpenGL_last_bound[2]; -static int Last_texel_unit_set = -1; - -extern int gpu_last_frame_polys_drawn; -extern int gpu_last_frame_verts_processed; -extern int gpu_last_uploaded; - -extern float gpu_Alpha_factor; -extern float gpu_Alpha_multiplier; - -#if defined(_USE_OGL_ACTIVE_TEXTURES) -PFNGLACTIVETEXTUREARBPROC oglActiveTextureARB = NULL; -PFNGLCLIENTACTIVETEXTUREARBPROC oglClientActiveTextureARB = NULL; -PFNGLMULTITEXCOORD4FARBPROC oglMultiTexCoord4f = NULL; -#endif - -uint16_t *OpenGL_bitmap_remap = NULL; -uint16_t *OpenGL_lightmap_remap = NULL; -uint8_t *OpenGL_bitmap_states = NULL; -uint8_t *OpenGL_lightmap_states = NULL; - -uint32_t *opengl_Upload_data = NULL; -uint32_t *opengl_Translate_table = NULL; -uint32_t *opengl_4444_translate_table = NULL; - -uint16_t *opengl_packed_Upload_data = NULL; -uint16_t *opengl_packed_Translate_table = NULL; -uint16_t *opengl_packed_4444_translate_table = NULL; - -extern rendering_state gpu_state; -extern renderer_preferred_state gpu_preferred_state; - -bool OpenGL_multitexture_state = false; -module *OpenGLDLLHandle = NULL; -int Already_loaded = 0; -bool opengl_Blending_on = 0; - -static oeApplication *ParentApplication = NULL; - -/* framebuffer object for backbuffer, scale to window size without changing resolution. --ryan, 2019. */ -#define GL_DEPTH_COMPONENT16_EXT 0x81A5 -#define GL_READ_FRAMEBUFFER_EXT 0x8CA8 -#define GL_DRAW_FRAMEBUFFER_EXT 0x8CA9 -#define GL_FRAMEBUFFER_COMPLETE_EXT 0x8CD5 -#define GL_COLOR_ATTACHMENT0_EXT 0x8CE0 -#define GL_DEPTH_ATTACHMENT_EXT 0x8D00 -#define GL_STENCIL_ATTACHMENT_EXT 0x8D20 -#define GL_FRAMEBUFFER_EXT 0x8D40 -#define GL_RENDERBUFFER_EXT 0x8D41 -static GLuint GOpenGLFBO = 0; -static GLuint GOpenGLRBOColor = 0; -static GLuint GOpenGLRBODepth = 0; -static GLuint GOpenGLFBOWidth = 0; -static GLuint GOpenGLFBOHeight = 0; - - -#if 0 -int checkForGLErrors( const char *file, int line ) -{ - /* - int errors = 0 ; - int counter = 0 ; - static int errcnt = 0; - if(!dglGetError) - return 0; - while ( counter < 1000 ) - { - GLenum x = dglGetError() ; - - if ( x == GL_NO_ERROR ) - return errors ; - - printf( "%s:%d OpenGL error: %s [%08x]\n", file,line, gluErrorString ( x ), errcnt++ ) ; - errors++ ; - counter++ ; - } - */ - const char *sdlp = SDL_GetError(); - if(sdlp && *sdlp) - mprintf(0,"SDL: %s",sdlp); - return 1; -} -#endif - -// Sets up multi-texturing using ARB extensions -void opengl_GetDLLFunctions(void) { -#if defined(WIN32) - oglActiveTextureARB = (PFNGLACTIVETEXTUREARBPROC)dwglGetProcAddress("glActiveTextureARB"); - if (!oglActiveTextureARB) - goto dll_error; - - oglClientActiveTextureARB = (PFNGLCLIENTACTIVETEXTUREARBPROC)dwglGetProcAddress("glClientActiveTextureARB"); - if (!oglClientActiveTextureARB) - goto dll_error; - - oglMultiTexCoord4f = (PFNGLMULTITEXCOORD4FARBPROC)dwglGetProcAddress("glMultiTexCoord4f"); - if (!oglMultiTexCoord4f) - goto dll_error; -#else -#define mod_GetSymbol(x, funcStr, y) __SDL_mod_GetSymbol(funcStr) - - oglActiveTextureARB = (PFNGLACTIVETEXTUREARBPROC)mod_GetSymbol(OpenGLDLLHandle, "glActiveTextureARB", 255); - oglClientActiveTextureARB = - (PFNGLCLIENTACTIVETEXTUREARBPROC)mod_GetSymbol(OpenGLDLLHandle, "glClientActiveTextureARB", 255); - oglMultiTexCoord4f = (PFNGLMULTITEXCOORD4FARBPROC)mod_GetSymbol(OpenGLDLLHandle, "glMultiTexCoord4f", 255); - if (!oglMultiTexCoord4f) { - oglMultiTexCoord4f = (PFNGLMULTITEXCOORD4FARBPROC)mod_GetSymbol(OpenGLDLLHandle, "glMultiTexCoord4fARB", 255); - } - if (oglActiveTextureARB == NULL || oglClientActiveTextureARB == NULL || oglMultiTexCoord4f == NULL) { - goto dll_error; - } - -#undef mod_GetSymbol -#endif - - UseMultitexture = true; - return; - -dll_error: - oglActiveTextureARB = NULL; - oglClientActiveTextureARB = NULL; - oglMultiTexCoord4f = NULL; - UseMultitexture = false; -} - -// returns true if the passed in extension name is supported -bool opengl_CheckExtension(const char *extName) { - const char *p = (const char *)dglGetString(GL_EXTENSIONS); - int extNameLen = strlen(extName); - const char *end = p + strlen(p); - - while (p < end) { - int n = strcspn(p, " "); - if ((extNameLen == n) && (strncmp(extName, p, n) == 0)) - return true; - - p += (n + 1); - } - - return false; -} - -// Gets some specific information about this particular flavor of opengl -void opengl_GetInformation() { - mprintf(0, "OpenGL Vendor: %s\n", dglGetString(GL_VENDOR)); - mprintf(0, "OpenGL Renderer: %s\n", dglGetString(GL_RENDERER)); - mprintf(0, "OpenGL Version: %s\n", dglGetString(GL_VERSION)); - mprintf(0, "OpenGL Extensions: %s\n", dglGetString(GL_EXTENSIONS)); -} - -int opengl_MakeTextureObject(int tn) { - int num = Cur_texture_object_num; - - Cur_texture_object_num++; - - if (UseMultitexture && Last_texel_unit_set != tn) { -#if (defined(_USE_OGL_ACTIVE_TEXTURES)) - oglActiveTextureARB(GL_TEXTURE0_ARB + tn); - Last_texel_unit_set = tn; -#endif - } - - dglBindTexture(GL_TEXTURE_2D, num); - dglPixelStorei(GL_UNPACK_ALIGNMENT, 2); - - dglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); - dglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); - - dglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); - dglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); - - // glTexEnvf (GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_MODULATE); - - CHECK_ERROR(2) - - return num; -} - -int opengl_InitCache(void) { - - OpenGL_bitmap_remap = (uint16_t *)mem_malloc(MAX_BITMAPS * 2); - ASSERT(OpenGL_bitmap_remap); - OpenGL_lightmap_remap = (uint16_t *)mem_malloc(MAX_LIGHTMAPS * 2); - ASSERT(OpenGL_lightmap_remap); - - OpenGL_bitmap_states = (uint8_t *)mem_malloc(MAX_BITMAPS); - ASSERT(OpenGL_bitmap_states); - OpenGL_lightmap_states = (uint8_t *)mem_malloc(MAX_LIGHTMAPS); - ASSERT(OpenGL_lightmap_states); - - Cur_texture_object_num = 1; - - // Setup textures and cacheing - int i; - for (i = 0; i < MAX_BITMAPS; i++) { - OpenGL_bitmap_remap[i] = 65535; - OpenGL_bitmap_states[i] = 255; - GameBitmaps[i].flags |= BF_CHANGED | BF_BRAND_NEW; - } - - for (i = 0; i < MAX_LIGHTMAPS; i++) { - OpenGL_lightmap_remap[i] = 65535; - OpenGL_lightmap_states[i] = 255; - GameLightmaps[i].flags |= LF_CHANGED | LF_BRAND_NEW; - } - - dglTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); - - if (UseMultitexture) { -#if (defined(_USE_OGL_ACTIVE_TEXTURES)) - oglActiveTextureARB(GL_TEXTURE0_ARB + 1); - dglTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); - oglActiveTextureARB(GL_TEXTURE0_ARB + 0); -#endif - } - - CHECK_ERROR(3) - - OpenGL_cache_initted = 1; - return 1; -} - -// Sets default states for our renderer -void opengl_SetDefaults() { - mprintf(0, "Setting states\n"); - - gpu_state.cur_color = 0x00FFFFFF; - gpu_state.cur_bilinear_state = -1; - gpu_state.cur_zbuffer_state = -1; - gpu_state.cur_texture_quality = -1; - gpu_state.cur_light_state = LS_GOURAUD; - gpu_state.cur_color_model = CM_MONO; - gpu_state.cur_bilinear_state = -1; - gpu_state.cur_alpha_type = AT_TEXTURE; - - // Enable some states - dglAlphaFunc(GL_GREATER, 0); - dglEnable(GL_ALPHA_TEST); - dglEnable(GL_BLEND); - dglEnable(GL_DITHER); - opengl_Blending_on = true; - - rend_SetAlphaType(AT_ALWAYS); - rend_SetAlphaValue(255); - rend_SetFiltering(1); - rend_SetLightingState(LS_NONE); - rend_SetTextureType(TT_FLAT); - rend_SetColorModel(CM_RGB); - rend_SetZBufferState(1); - rend_SetZValues(0, 3000); - rend_SetGammaValue(gpu_preferred_state.gamma); - OpenGL_last_bound[0] = 9999999; - OpenGL_last_bound[1] = 9999999; - Last_texel_unit_set = -1; - OpenGL_multitexture_state = false; - - dglEnableClientState(GL_VERTEX_ARRAY); - dglEnableClientState(GL_COLOR_ARRAY); - dglEnableClientState(GL_TEXTURE_COORD_ARRAY); - - dglHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); - dglHint(GL_FOG_HINT, GL_NICEST); - dglEnable(GL_SCISSOR_TEST); - dglScissor(0, 0, gpu_state.screen_width, gpu_state.screen_height); - dglDisable(GL_SCISSOR_TEST); - dglDepthRange(0.0f, 1.0f); - - if (UseMultitexture) { -#if (defined(_USE_OGL_ACTIVE_TEXTURES)) - oglActiveTextureARB(GL_TEXTURE0_ARB + 1); - oglClientActiveTextureARB(GL_TEXTURE0_ARB + 1); - dglEnableClientState(GL_TEXTURE_COORD_ARRAY); - dglHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); - dglHint(GL_FOG_HINT, GL_NICEST); - - oglClientActiveTextureARB(GL_TEXTURE0_ARB + 0); - - dglDisable(GL_TEXTURE_2D); - dglAlphaFunc(GL_GREATER, 0); - dglEnable(GL_ALPHA_TEST); - dglEnable(GL_BLEND); - dglEnable(GL_DITHER); - dglBlendFunc(GL_DST_COLOR, GL_ZERO); - oglActiveTextureARB(GL_TEXTURE0_ARB + 0); -#endif - } -} - -#if defined(WIN32) -// Check for OpenGL support, -int opengl_Setup(HDC glhdc) { - if (!Already_loaded) { - if (!(OpenGLDLLHandle = LoadOpenGLDLL("opengl32.dll"))) { - rend_SetErrorMessage("Failed to load opengl dll!\n"); - Int3(); - return 0; - } - } - - // Finds an acceptable pixel format to render to - PIXELFORMATDESCRIPTOR pfd, pfd_copy; - int pf; - - memset(&pfd, 0, sizeof(pfd)); - pfd.nSize = sizeof(pfd); - pfd.nVersion = 1; - pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER | PFD_GENERIC_ACCELERATED; - pfd.iPixelType = PFD_TYPE_RGBA; - - /*if (!WindowGL) - { - if (gpu_preferred_state.bit_depth==32) - { - pfd.cColorBits = 32; - pfd.cDepthBits = 32; - } - else - { - pfd.cColorBits = gpu_preferred_state.bit_depth; - pfd.cDepthBits =gpu_preferred_state.bit_depth; - } - - pfd.cColorBits = 16; - pfd.cDepthBits =16; - - } - else - { - pfd.cColorBits = 16; - pfd.cDepthBits =16; - }*/ - - // Find the user's "best match" PFD - pf = ChoosePixelFormat(glhdc, &pfd); - if (pf == 0) { - Int3(); - // FreeLibrary(opengl_dll_handle); - return NULL; - } - - mprintf(0, "Choose pixel format successful!\n"); - - // Try and set the new PFD - if (SetPixelFormat(glhdc, pf, &pfd) == FALSE) { - DWORD ret = GetLastError(); - Int3(); - // FreeLibrary(opengl_dll_handle); - return NULL; - } - - mprintf(0, "SetPixelFormat successful!\n"); - - // Get a copy of the newly set PFD - if (DescribePixelFormat(glhdc, pf, sizeof(PIXELFORMATDESCRIPTOR), &pfd_copy) == 0) { - Int3(); - // FreeLibrary(opengl_dll_handle); - return NULL; - } - - // Check the returned PFD to see if it is hardware accelerated - if ((pfd_copy.dwFlags & PFD_GENERIC_ACCELERATED) == 0 && (pfd_copy.dwFlags & PFD_GENERIC_FORMAT) != 0) { - Int3(); - // FreeLibrary(opengl_dll_handle); - return NULL; - } - - // Create an OpenGL context, and make it the current context - ResourceContext = dwglCreateContext((HDC)glhdc); - if (ResourceContext == NULL) { - DWORD ret = GetLastError(); - // FreeLibrary(opengl_dll_handle); - Int3(); - return NULL; - } - - ASSERT(ResourceContext != NULL); - mprintf(0, "Making context current\n"); - dwglMakeCurrent((HDC)glhdc, ResourceContext); - - Already_loaded = 1; - - return 1; -} -#elif defined(__LINUX__) - -extern bool linux_permit_gamma; -extern renderer_preferred_state Render_preferred_state; -extern bool ddio_mouseGrabbed; -int SDLCALL d3SDLEventFilter(void *userdata, SDL_Event *event); - -int opengl_Setup(oeApplication *app, int *width, int *height) { - int winw = Video_res_list[Game_video_resolution].width; - int winh = Video_res_list[Game_video_resolution].height; - - // rcg09182000 don't need to quitsubsystem anymore... - // SDL_QuitSubSystem(SDL_INIT_VIDEO); // here goes nothing... - // Already_loaded = false; - SDL_ClearError(); - if (!SDL_WasInit(SDL_INIT_VIDEO)) { - const int rc = SDL_Init(SDL_INIT_VIDEO); - if (rc != 0) { - char buffer[512]; - snprintf(buffer, sizeof(buffer), "SDL_GetError() reports \"%s\".\n", SDL_GetError()); - fprintf(stderr, "SDL: SDL_Init() failed! rc == (%d).\n", rc); - fprintf(stderr, "%s", buffer); - rend_SetErrorMessage(buffer); - return (0); - } - } - - SDL_SetEventFilter(d3SDLEventFilter, NULL); - - bool fullscreen = true; - - if (FindArgChar("-fullscreen", 'f')) { - fullscreen = true; - } else if (FindArgChar("-windowed", 'w')) { - fullscreen = false; - } - - if (!Already_loaded) { -#define MAX_ARGS 30 -#define MAX_CHARS_PER_ARG 100 - extern char GameArgs[MAX_ARGS][MAX_CHARS_PER_ARG]; - - char gl_library[256]; - int arg; - arg = FindArgChar("-gllibrary", 'g'); - if (arg != 0) { - strcpy(gl_library, GameArgs[arg + 1]); - } else { - gl_library[0] = 0; - } - - mprintf(0, "OpenGL: Attempting to use \"%s\" for OpenGL\n", gl_library[0] ? gl_library : "[system default library]"); - - // ryan's adds. 04/18/2000...SDL stuff on 04/25/2000 - bool success = true; - - OpenGLDLLHandle = LoadOpenGLDLL(gl_library); - if (!(OpenGLDLLHandle)) { - // rcg07072000 last ditch effort... - OpenGLDLLHandle = LoadOpenGLDLL("libGL.so.1"); - if (!(OpenGLDLLHandle)) { - success = false; - } - } // if - - if (success == false) { - char buffer[512]; - snprintf(buffer, sizeof(buffer), "Failed to load library [%s].\n", gl_library); - fprintf(stderr, "%s", buffer); - rend_SetErrorMessage(buffer); - return 0; - } // if - } - -#ifdef __PERMIT_GL_LOGGING - if (FindArg("-gllogging")) { - printf("\n" - "************************************************************\n" - "************************************************************\n" - "************************************************************\n" - "************************************************************\n" - "************************************************************\n" - "******** GL LOGGING ENABLED. ***************************\n" - "************************************************************\n" - "************************************************************\n" - "************************************************************\n" - "************************************************************\n" - "************************************************************\n" - "\n"); - DGL_EnableLogging(1); - __glLog = true; - } // if -#endif - - SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8 ); - SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8); - SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8); - SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 16); - SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1); - Uint32 flags = SDL_WINDOW_OPENGL; - - if (fullscreen) { - flags |= SDL_WINDOW_FULLSCREEN_DESKTOP; - } - - if (!GSDLWindow) { - GSDLWindow = SDL_CreateWindow("Descent 3", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, winw, winh, flags); - if (!GSDLWindow) { - mprintf(0, "OpenGL: SDL window creation failed: %s", SDL_GetError()); - return 0; - } - } else { - SDL_SetWindowSize(GSDLWindow, winw, winh); - SDL_SetWindowFullscreen(GSDLWindow, flags); - } - - if (!GSDLGLContext) { - GSDLGLContext = SDL_GL_CreateContext(GSDLWindow); - if (!GSDLGLContext) { - mprintf(0, "OpenGL: OpenGL context creation failed: %s", SDL_GetError()); - SDL_DestroyWindow(GSDLWindow); - GSDLWindow = NULL; - return 0; - } - } - - // clear the window framebuffer to start. - dglClearColor(0.0f, 0.0f, 0.0f, 1.0f); - dglClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); - SDL_GL_SwapWindow(GSDLWindow); - - bool fbo_available = true; - if (!SDL_GL_ExtensionSupported("GL_EXT_framebuffer_object")) { - mprintf(0, "OpenGL: GL_EXT_framebuffer_object extension is not available"); - fbo_available = false; - } - - if (!SDL_GL_ExtensionSupported("GL_EXT_framebuffer_blit")) { - mprintf(0, "OpenGL: GL_EXT_framebuffer_blit extension is not available"); - fbo_available = false; - } - - if (fbo_available) { - #define LOOKUP_GL_SYM(x) \ - dgl##x = (gl##x##_fp) SDL_GL_GetProcAddress("gl" #x); \ - if (dgl##x == NULL) { \ - mprintf(0, "OpenGL: gl%s function not found!", #x); \ - fbo_available = false; \ - } - LOOKUP_GL_SYM(GenFramebuffersEXT); - LOOKUP_GL_SYM(GenRenderbuffersEXT); - LOOKUP_GL_SYM(BindFramebufferEXT); - LOOKUP_GL_SYM(BindRenderbufferEXT); - LOOKUP_GL_SYM(RenderbufferStorageEXT); - LOOKUP_GL_SYM(FramebufferRenderbufferEXT); - LOOKUP_GL_SYM(CheckFramebufferStatusEXT); - LOOKUP_GL_SYM(DeleteFramebuffersEXT); - LOOKUP_GL_SYM(DeleteRenderbuffersEXT); - LOOKUP_GL_SYM(BlitFramebufferEXT); - } - - if (!fbo_available) { - mprintf(0, "OpenGL: We need missing Framebuffer Object support, giving up"); - SDL_GL_DeleteContext(GSDLGLContext); - SDL_DestroyWindow(GSDLWindow); - GSDLGLContext = NULL; - GSDLWindow = NULL; - return 0; - } - - /* Tear down the backbuffer and rebuild at new dimensions... */ - if (GOpenGLFBO) { - dglBindFramebufferEXT(GL_FRAMEBUFFER_EXT, GOpenGLFBO); - dglFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_RENDERBUFFER_EXT, 0); - dglFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, 0); - dglBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0); - dglBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); - dglDeleteFramebuffersEXT(1, &GOpenGLFBO); - dglDeleteRenderbuffersEXT(1, &GOpenGLRBOColor); - dglDeleteRenderbuffersEXT(1, &GOpenGLRBODepth); - GOpenGLFBOWidth = GOpenGLFBOHeight = GOpenGLFBO = GOpenGLRBOColor = GOpenGLRBODepth = 0; - } - - const GLsizei w = (GLsizei) *width; - const GLsizei h = (GLsizei) *height; - - GOpenGLFBOWidth = w; - GOpenGLFBOHeight = h; - - dglGenFramebuffersEXT(1, &GOpenGLFBO); - dglBindFramebufferEXT(GL_FRAMEBUFFER_EXT, GOpenGLFBO); - - dglGenRenderbuffersEXT(1, &GOpenGLRBOColor); - dglBindRenderbufferEXT(GL_RENDERBUFFER_EXT, GOpenGLRBOColor); - dglRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_RGB, w, h); - dglFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_RENDERBUFFER_EXT, GOpenGLRBOColor); - - dglGenRenderbuffersEXT(1, &GOpenGLRBODepth); - dglBindRenderbufferEXT(GL_RENDERBUFFER_EXT, GOpenGLRBODepth); - dglRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT16_EXT, w, h); - dglFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, GOpenGLRBODepth); - - if (dglCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT) != GL_FRAMEBUFFER_COMPLETE_EXT) { - mprintf(0, "OpenGL: our framebuffer object is incomplete, giving up"); - dglFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_RENDERBUFFER_EXT, 0); - dglFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, 0); - dglBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0); - dglBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); - dglDeleteFramebuffersEXT(1, &GOpenGLFBO); - dglDeleteRenderbuffersEXT(1, &GOpenGLRBOColor); - dglDeleteRenderbuffersEXT(1, &GOpenGLRBODepth); - GOpenGLFBO = GOpenGLRBOColor = GOpenGLRBODepth = 0; - SDL_GL_DeleteContext(GSDLGLContext); - SDL_DestroyWindow(GSDLWindow); - GSDLGLContext = NULL; - GSDLWindow = NULL; - return 0; - } - - if (!FindArg("-nomousegrab")) { - ddio_mouseGrabbed = true; - } - - SDL_SetRelativeMouseMode(ddio_mouseGrabbed ? SDL_TRUE : SDL_FALSE); - - // rcg09182000 gamma fun. - // rcg01112000 --nogamma fun. - if (FindArgChar("-nogamma", 'M')) { - linux_permit_gamma = false; - } else { - Uint16 ramp[256]; - SDL_CalculateGammaRamp(Render_preferred_state.gamma, ramp); - linux_permit_gamma = (SDL_SetWindowGammaRamp(GSDLWindow, ramp, ramp, ramp) == 0); - } // else - - if (ParentApplication) { - reinterpret_cast(ParentApplication)->set_sizepos(0, 0, *width, *height); - } - - Already_loaded = 1; - return 1; -} -#endif - -// Sets up our OpenGL rendering context -// Returns 1 if ok, 0 if something bad -int opengl_Init(oeApplication *app, renderer_preferred_state *pref_state) { - int width, height; - int retval = 1; - int i; - - mprintf(0, "Setting up opengl mode!\n"); - - if (pref_state) { - gpu_preferred_state = *pref_state; - } - - if (app != NULL) { - ParentApplication = app; - } - - int windowX = 0, windowY = 0; -#if defined(WIN32) - /*********************************************************** - * WINDOWS OPENGL - *********************************************************** - */ - static HWnd hwnd = NULL; - if (ParentApplication != NULL) { - hwnd = static_cast(reinterpret_cast(ParentApplication)->m_hWnd); - } - - if (!WindowGL) { - // First set our display mode - // Create direct draw surface - - DEVMODE devmode; - - devmode.dmSize = sizeof(devmode); - devmode.dmBitsPerPel = 32; - // devmode.dmBitsPerPel=gpu_preferred_state.bit_depth; - devmode.dmPelsWidth = gpu_preferred_state.width; - devmode.dmPelsHeight = gpu_preferred_state.height; - devmode.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT; - -#ifdef CHANGE_RESOLUTION_IN_FULLSCREEN - int retval = ChangeDisplaySettings(&devmode, 0); -#else - int retval = DISP_CHANGE_SUCCESSFUL; -#endif - if (retval != DISP_CHANGE_SUCCESSFUL) { - mprintf(0, "Display mode change failed (err=%d), trying default!\n", retval); - retval = -1; - devmode.dmBitsPerPel = 32; - devmode.dmPelsWidth = 640; - devmode.dmPelsHeight = 480; - devmode.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT; - - retval = ChangeDisplaySettings(&devmode, 0); - if (retval != DISP_CHANGE_SUCCESSFUL) { - mprintf(0, "OpenGL_INIT:Change display setting failed failed!\n"); - rend_SetErrorMessage("OGL: ChangeDisplaySettings failed. Make sure your desktop is set to 16bit mode!"); - ChangeDisplaySettings(NULL, 0); - opengl_Close(); - return 0; - } else { - gpu_preferred_state.bit_depth = 32; - gpu_preferred_state.width = 640; - gpu_preferred_state.height = 480; - } - } else { - mprintf(0, "Setdisplaymode to %d x %d (%d bits) is successful!\n", gpu_preferred_state.width, - gpu_preferred_state.height, gpu_preferred_state.bit_depth); - } - } - - memset(&gpu_state, 0, sizeof(rendering_state)); - - // These values are set here - samir - if (app != NULL) { - hOpenGLWnd = (HWND)((oeWin32Application *)app)->m_hWnd; - } - - hOpenGLDC = GetDC(hOpenGLWnd); - - if (WindowGL) { - RECT rect; - POINT topLeft; - GetClientRect((HWND)hOpenGLWnd, &rect); - - topLeft.x = rect.left; - topLeft.y = rect.top; - ClientToScreen((HWND)hOpenGLWnd, &topLeft); - - width = rect.right - rect.left + 1; - height = rect.bottom - rect.top + 1; - windowX = topLeft.x; - windowY = topLeft.y; - } else { - SetWindowPos(hOpenGLWnd, HWND_TOPMOST, 0, 0, gpu_preferred_state.width, gpu_preferred_state.height, - SWP_FRAMECHANGED); - width = gpu_preferred_state.width; - height = gpu_preferred_state.height; - RECT rect; - GetWindowRect((HWND)hOpenGLWnd, &rect); - mprintf(0, "rect=%d %d %d %d\n", rect.top, rect.right, rect.bottom, rect.left); - } - - gpu_state.screen_width = width; - gpu_state.screen_height = height; - - if (!opengl_Setup(hOpenGLDC)) { - opengl_Close(); - return 0; - } - - // Save gamma values for later - GetDeviceGammaRamp(hOpenGLDC, (LPVOID)Saved_gamma_values); - -#elif defined(__LINUX__) - /*********************************************************** - * LINUX OPENGL - *********************************************************** - */ - // Setup gpu_state.screen_width & gpu_state.screen_height & width & height - width = gpu_preferred_state.width; - height = gpu_preferred_state.height; - - if (!opengl_Setup(app, &width, &height)) { - opengl_Close(); - return 0; - } - - memset(&gpu_state, 0, sizeof(rendering_state)); - gpu_state.screen_width = width; - gpu_state.screen_height = height; -#else - // Setup gpu_state.screen_width & gpu_state.screen_height & width & height - -#endif - // Get some info - opengl_GetInformation(); - - mprintf(0, "Setting up multitexture...\n"); - - // Determine if Multitexture is supported - bool supportsMultiTexture = opengl_CheckExtension("GL_ARB_multitexture"); - if (!supportsMultiTexture) { - supportsMultiTexture = opengl_CheckExtension("GL_SGIS_multitexture"); - } - - if (FindArg("-NoMultitexture")) { - supportsMultiTexture = false; - } - - if (supportsMultiTexture) { - // attempt to grab Multitexture functions - opengl_GetDLLFunctions(); - } else { - // No multitexture at all - UseMultitexture = false; - } - - // Do we have packed pixel formats? - OpenGL_packed_pixels = opengl_CheckExtension("GL_EXT_packed_pixels"); - - opengl_InitCache(); - - if (UseMultitexture) { - mprintf(0, "Using multitexture."); - } else { - mprintf(0, "Not using multitexture."); - } - - if (OpenGL_packed_pixels) { - opengl_packed_Upload_data = (uint16_t *)mem_malloc(2048 * 2048 * 2); - opengl_packed_Translate_table = (uint16_t *)mem_malloc(65536 * 2); - opengl_packed_4444_translate_table = (uint16_t *)mem_malloc(65536 * 2); - - ASSERT(opengl_packed_Upload_data); - ASSERT(opengl_packed_Translate_table); - ASSERT(opengl_packed_4444_translate_table); - - mprintf(0, "Building packed OpenGL translate table...\n"); - - for (i = 0; i < 65536; i++) { - int r = (i >> 10) & 0x1f; - int g = (i >> 5) & 0x1f; - int b = i & 0x1f; - -#ifdef BRIGHTNESS_HACK - r *= BRIGHTNESS_HACK; - g *= BRIGHTNESS_HACK; - b *= BRIGHTNESS_HACK; - if (r > 0x1F) - r = 0x1F; - if (g > 0x1F) - g = 0x1F; - if (b > 0x1F) - b = 0x1F; -#endif - - uint16_t pix; - - if (!(i & OPAQUE_FLAG)) { - pix = 0; - } else { - pix = (r << 11) | (g << 6) | (b << 1) | 1; - } - - opengl_packed_Translate_table[i] = INTEL_INT(pix); - - // 4444 table - int a = (i >> 12) & 0xf; - r = (i >> 8) & 0xf; - g = (i >> 4) & 0xf; - b = i & 0xf; - - pix = (r << 12) | (g << 8) | (b << 4) | a; - opengl_packed_4444_translate_table[i] = INTEL_INT(pix); - } - } else { - opengl_Upload_data = (uint32_t *)mem_malloc(2048 * 2048 * 4); - opengl_Translate_table = (uint32_t *)mem_malloc(65536 * 4); - opengl_4444_translate_table = (uint32_t *)mem_malloc(65536 * 4); - - ASSERT(opengl_Upload_data); - ASSERT(opengl_Translate_table); - ASSERT(opengl_4444_translate_table); - - mprintf(0, "Building OpenGL translate table...\n"); - - for (i = 0; i < 65536; i++) { - uint32_t pix; - int r = (i >> 10) & 0x1f; - int g = (i >> 5) & 0x1f; - int b = i & 0x1f; - -#ifdef BRIGHTNESS_HACK - r *= BRIGHTNESS_HACK; - g *= BRIGHTNESS_HACK; - b *= BRIGHTNESS_HACK; - if (r > 0x1F) - r = 0x1F; - if (g > 0x1F) - g = 0x1F; - if (b > 0x1F) - b = 0x1F; -#endif - - float fr = (float)r / 31.0f; - float fg = (float)g / 31.0f; - float fb = (float)b / 31.0f; - - r = 255 * fr; - g = 255 * fg; - b = 255 * fb; - - if (!(i & OPAQUE_FLAG)) { - pix = 0; - } else { - pix = (255 << 24) | (b << 16) | (g << 8) | (r); - } - - opengl_Translate_table[i] = INTEL_INT(pix); - - // Do 4444 - int a = (i >> 12) & 0xf; - r = (i >> 8) & 0xf; - g = (i >> 4) & 0xf; - b = i & 0xf; - - float fa = (float)a / 15.0f; - fr = (float)r / 15.0f; - fg = (float)g / 15.0f; - fb = (float)b / 15.0f; - - a = 255 * fa; - r = 255 * fr; - g = 255 * fg; - b = 255 * fb; - - pix = (a << 24) | (b << 16) | (g << 8) | (r); - - opengl_4444_translate_table[i] = INTEL_INT(pix); - } - } - - opengl_SetDefaults(); - - g3_ForceTransformRefresh(); - - CHECK_ERROR(4) - - gpu_state.initted = 1; - - mprintf(0, "OpenGL initialization at %d x %d was successful.\n", width, height); - - return retval; -} - -// Releases the rendering context -void opengl_Close(const bool just_resizing) { - CHECK_ERROR(5) - - uint32_t *delete_list = (uint32_t *)mem_malloc(Cur_texture_object_num * sizeof(int)); - ASSERT(delete_list); - for (int i = 1; i < Cur_texture_object_num; i++) - delete_list[i] = i; - - if (Cur_texture_object_num > 1) - dglDeleteTextures(Cur_texture_object_num, (const uint32_t *)delete_list); - - mem_free(delete_list); - -#if defined(WIN32) - if (dwglMakeCurrent) - dwglMakeCurrent(NULL, NULL); - - if (dwglDeleteContext) - dwglDeleteContext(ResourceContext); - - // Change our display back - if (!WindowGL) { -#ifdef CHANGE_RESOLUTION_IN_FULLSCREEN - ChangeDisplaySettings(NULL, 0); -#endif - } -#elif defined(__LINUX__) - if (GSDLGLContext) { - SDL_GL_MakeCurrent(NULL, NULL); - SDL_GL_DeleteContext(GSDLGLContext); - GSDLGLContext = NULL; - GOpenGLFBOWidth = GOpenGLFBOHeight = GOpenGLFBO = GOpenGLRBOColor = GOpenGLRBODepth = 0; - } - - if (!just_resizing && GSDLWindow) { - SDL_DestroyWindow(GSDLWindow); - GSDLWindow = NULL; - } -#else - -#endif - - if (OpenGL_packed_pixels) { - if (opengl_packed_Upload_data) { - mem_free(opengl_packed_Upload_data); - } - if (opengl_packed_Translate_table) { - mem_free(opengl_packed_Translate_table); - } - if (opengl_packed_4444_translate_table) { - mem_free(opengl_packed_4444_translate_table); - } - opengl_packed_Upload_data = NULL; - opengl_packed_Translate_table = NULL; - opengl_packed_4444_translate_table = NULL; - } else { - if (opengl_Upload_data) - mem_free(opengl_Upload_data); - if (opengl_Translate_table) - mem_free(opengl_Translate_table); - if (opengl_4444_translate_table) - mem_free(opengl_4444_translate_table); - opengl_Upload_data = NULL; - opengl_Translate_table = NULL; - opengl_4444_translate_table = NULL; - } - - if (OpenGL_cache_initted) { - mem_free(OpenGL_lightmap_remap); - mem_free(OpenGL_bitmap_remap); - mem_free(OpenGL_lightmap_states); - mem_free(OpenGL_bitmap_states); - OpenGL_cache_initted = 0; - } - -#if defined(WIN32) - // Restore gamma values - SetDeviceGammaRamp(hOpenGLDC, (LPVOID)Saved_gamma_values); - // I'm freeing the DC here - samir - ReleaseDC(hOpenGLWnd, hOpenGLDC); -#elif defined(__LINUX__) - -#else - -#endif - // mod_FreeModule (OpenGLDLLHandle); - gpu_state.initted = 0; -} - -// Takes our 16bit format and converts it into the memory scheme that OpenGL wants -void opengl_TranslateBitmapToOpenGL(int texnum, int bm_handle, int map_type, int replace, int tn) { - uint16_t *bm_ptr; - - int w, h; - int size; - - if (UseMultitexture && Last_texel_unit_set != tn) { -#if (defined(_USE_OGL_ACTIVE_TEXTURES)) - oglActiveTextureARB(GL_TEXTURE0_ARB + tn); - Last_texel_unit_set = tn; -#endif - } - - if (map_type == MAP_TYPE_LIGHTMAP) { - if (GameLightmaps[bm_handle].flags & LF_BRAND_NEW) - replace = 0; - - bm_ptr = lm_data(bm_handle); - GameLightmaps[bm_handle].flags &= ~(LF_CHANGED | LF_BRAND_NEW); - - w = lm_w(bm_handle); - h = lm_h(bm_handle); - size = GameLightmaps[bm_handle].square_res; - } else { - if (GameBitmaps[bm_handle].flags & BF_BRAND_NEW) - replace = 0; - - bm_ptr = bm_data(bm_handle, 0); - GameBitmaps[bm_handle].flags &= ~(BF_CHANGED | BF_BRAND_NEW); - w = bm_w(bm_handle, 0); - h = bm_h(bm_handle, 0); - size = w; - } - - if (OpenGL_last_bound[tn] != texnum) { - dglBindTexture(GL_TEXTURE_2D, texnum); - OpenGL_sets_this_frame[0]++; - OpenGL_last_bound[tn] = texnum; - } - - int i; - - if (OpenGL_packed_pixels) { - if (map_type == MAP_TYPE_LIGHTMAP) { - uint16_t *left_data = (uint16_t *)opengl_packed_Upload_data; - int bm_left = 0; - - for (int i = 0; i < h; i++, left_data += size, bm_left += w) { - uint16_t *dest_data = left_data; - for (int t = 0; t < w; t++) { - *dest_data++ = opengl_packed_Translate_table[bm_ptr[bm_left + t]]; - } - } - - if (replace) { - dglTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, size, size, GL_RGBA, GL_UNSIGNED_SHORT_5_5_5_1, - opengl_packed_Upload_data); - } else { - dglTexImage2D(GL_TEXTURE_2D, 0, GL_RGB5_A1, size, size, 0, GL_RGBA, GL_UNSIGNED_SHORT_5_5_5_1, - opengl_packed_Upload_data); - } - } else { - int limit = 0; - - if (bm_mipped(bm_handle)) { - limit = NUM_MIP_LEVELS + 3; - } else { - limit = 1; - } - - for (int m = 0; m < limit; m++) { - if (m < NUM_MIP_LEVELS) { - bm_ptr = bm_data(bm_handle, m); - w = bm_w(bm_handle, m); - h = bm_h(bm_handle, m); - } else { - bm_ptr = bm_data(bm_handle, NUM_MIP_LEVELS - 1); - w = bm_w(bm_handle, NUM_MIP_LEVELS - 1); - h = bm_h(bm_handle, NUM_MIP_LEVELS - 1); - - w >>= m - (NUM_MIP_LEVELS - 1); - h >>= m - (NUM_MIP_LEVELS - 1); - - if ((w < 1) || (h < 1)) - continue; - } - - if (bm_format(bm_handle) == BITMAP_FORMAT_4444) { - // Do 4444 - if (bm_mipped(bm_handle)) { - for (i = 0; i < w * h; i++) - opengl_packed_Upload_data[i] = 0xf | (opengl_packed_4444_translate_table[bm_ptr[i]]); - } else { - for (i = 0; i < w * h; i++) - opengl_packed_Upload_data[i] = opengl_packed_4444_translate_table[bm_ptr[i]]; - } - - if (replace) { - dglTexSubImage2D(GL_TEXTURE_2D, m, 0, 0, w, h, GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4, - opengl_packed_Upload_data); - } else { - dglTexImage2D(GL_TEXTURE_2D, m, GL_RGBA4, w, h, 0, GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4, - opengl_packed_Upload_data); - } - } else { - // Do 1555 - for (i = 0; i < w * h; i++) { - opengl_packed_Upload_data[i] = opengl_packed_Translate_table[bm_ptr[i]]; - } - - if (replace) { - dglTexSubImage2D(GL_TEXTURE_2D, m, 0, 0, w, h, GL_RGBA, GL_UNSIGNED_SHORT_5_5_5_1, - opengl_packed_Upload_data); - } else { - dglTexImage2D(GL_TEXTURE_2D, m, GL_RGB5_A1, w, h, 0, GL_RGBA, GL_UNSIGNED_SHORT_5_5_5_1, - opengl_packed_Upload_data); - } - } - } - } - } else { - if (map_type == MAP_TYPE_LIGHTMAP) { - uint32_t *left_data = (uint32_t *)opengl_Upload_data; - int bm_left = 0; - - for (int i = 0; i < h; i++, left_data += size, bm_left += w) { - uint32_t *dest_data = left_data; - for (int t = 0; t < w; t++) { - *dest_data++ = opengl_Translate_table[bm_ptr[bm_left + t]]; - } - } - if (size > 0) { - if (replace) { - dglTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, size, size, GL_RGBA, GL_UNSIGNED_BYTE, opengl_Upload_data); - } else { - dglTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, size, size, 0, GL_RGBA, GL_UNSIGNED_BYTE, opengl_Upload_data); - } - } - } else { - int limit = 0; - - if (bm_mipped(bm_handle)) { - limit = NUM_MIP_LEVELS + 3; // ryan added +3. - } else { - limit = 1; - } - - for (int m = 0; m < limit; m++) { - bm_ptr = bm_data(bm_handle, m); - w = bm_w(bm_handle, m); - h = bm_h(bm_handle, m); - - if (bm_format(bm_handle) == BITMAP_FORMAT_4444) { - // Do 4444 - - if (bm_mipped(bm_handle)) { - for (i = 0; i < w * h; i++) - opengl_Upload_data[i] = INTEL_INT((255 << 24)) | opengl_4444_translate_table[bm_ptr[i]]; - } else { - for (i = 0; i < w * h; i++) - opengl_Upload_data[i] = opengl_4444_translate_table[bm_ptr[i]]; - } - } else { - // Do 1555 - - for (i = 0; i < w * h; i++) - opengl_Upload_data[i] = opengl_Translate_table[bm_ptr[i]]; - } - - // rcg06262000 my if wrapper. - if ((w > 0) && (h > 0)) { - if (replace) { - dglTexSubImage2D(GL_TEXTURE_2D, m, 0, 0, w, h, GL_RGBA, GL_UNSIGNED_BYTE, opengl_Upload_data); - } else { - dglTexImage2D(GL_TEXTURE_2D, m, GL_RGBA, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, opengl_Upload_data); - } - } - } - } - } - - // mprintf(1,"Doing slow upload to opengl!\n"); - - if (map_type == MAP_TYPE_LIGHTMAP) { - GameLightmaps[bm_handle].flags &= ~LF_LIMITS; - } - - CHECK_ERROR(6) - OpenGL_uploads++; -} - -extern bool Force_one_texture; - -// Utilizes a LRU cacheing scheme to select/upload textures the opengl driver -int opengl_MakeBitmapCurrent(int handle, int map_type, int tn) { - int w, h; - int texnum; - - if (map_type == MAP_TYPE_LIGHTMAP) { - w = GameLightmaps[handle].square_res; - h = GameLightmaps[handle].square_res; - } else { - if (Force_one_texture) { - handle = 0; - } - - w = bm_w(handle, 0); - h = bm_h(handle, 0); - } - - if (w != h) { - mprintf(0, "Can't use non-square textures with OpenGL!\n"); - return 0; - } - - // See if the bitmaps is already in the cache - if (map_type == MAP_TYPE_LIGHTMAP) { - if (OpenGL_lightmap_remap[handle] == 65535) { - texnum = opengl_MakeTextureObject(tn); - SET_WRAP_STATE(OpenGL_lightmap_states[handle], 1); - SET_FILTER_STATE(OpenGL_lightmap_states[handle], 0); - OpenGL_lightmap_remap[handle] = texnum; - opengl_TranslateBitmapToOpenGL(texnum, handle, map_type, 0, tn); - } else { - texnum = OpenGL_lightmap_remap[handle]; - if (GameLightmaps[handle].flags & LF_CHANGED) - opengl_TranslateBitmapToOpenGL(texnum, handle, map_type, 1, tn); - } - } else { - if (OpenGL_bitmap_remap[handle] == 65535) { - texnum = opengl_MakeTextureObject(tn); - SET_WRAP_STATE(OpenGL_bitmap_states[handle], 1); - SET_FILTER_STATE(OpenGL_bitmap_states[handle], 0); - OpenGL_bitmap_remap[handle] = texnum; - opengl_TranslateBitmapToOpenGL(texnum, handle, map_type, 0, tn); - } else { - texnum = OpenGL_bitmap_remap[handle]; - if (GameBitmaps[handle].flags & BF_CHANGED) { - opengl_TranslateBitmapToOpenGL(texnum, handle, map_type, 1, tn); - } - } - } - - if (OpenGL_last_bound[tn] != texnum) { - if (UseMultitexture && Last_texel_unit_set != tn) { -#if (defined(_USE_OGL_ACTIVE_TEXTURES)) - oglActiveTextureARB(GL_TEXTURE0_ARB + tn); - Last_texel_unit_set = tn; -#endif - } - - dglBindTexture(GL_TEXTURE_2D, texnum); - OpenGL_last_bound[tn] = texnum; - OpenGL_sets_this_frame[0]++; - } - - CHECK_ERROR(7) - return 1; -} - -// Sets up an appropriate wrap type for the current bound texture -void opengl_MakeWrapTypeCurrent(int handle, int map_type, int tn) { - int uwrap; - wrap_type dest_wrap; - - if (tn == 1) - dest_wrap = WT_CLAMP; - else - dest_wrap = gpu_state.cur_wrap_type; - - if (map_type == MAP_TYPE_LIGHTMAP) - uwrap = GET_WRAP_STATE(OpenGL_lightmap_states[handle]); - else - uwrap = GET_WRAP_STATE(OpenGL_bitmap_states[handle]); - - if (uwrap == dest_wrap) - return; - - if (UseMultitexture && Last_texel_unit_set != tn) { -#if (defined(_USE_OGL_ACTIVE_TEXTURES)) - oglActiveTextureARB(GL_TEXTURE0_ARB + tn); - Last_texel_unit_set = tn; -#endif - } - - OpenGL_sets_this_frame[1]++; - - if (gpu_state.cur_wrap_type == WT_CLAMP) { - dglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP); - dglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP); - - } else if (gpu_state.cur_wrap_type == WT_WRAP_V) { - dglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP); - dglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); - } else { - dglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); - dglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); - } - - if (map_type == MAP_TYPE_LIGHTMAP) { - SET_WRAP_STATE(OpenGL_lightmap_states[handle], dest_wrap); - } else { - SET_WRAP_STATE(OpenGL_bitmap_states[handle], dest_wrap); - } - - CHECK_ERROR(8) -} - -// Chooses the correct filter type for the currently bound texture -void opengl_MakeFilterTypeCurrent(int handle, int map_type, int tn) { - int magf; - int8_t dest_state; - - if (map_type == MAP_TYPE_LIGHTMAP) { - magf = GET_FILTER_STATE(OpenGL_lightmap_states[handle]); - dest_state = 1; - } else { - magf = GET_FILTER_STATE(OpenGL_bitmap_states[handle]); - dest_state = gpu_preferred_state.filtering; - if (!gpu_state.cur_bilinear_state) - dest_state = 0; - } - - if (magf == dest_state) - return; -#if (defined(_USE_OGL_ACTIVE_TEXTURES)) - if (UseMultitexture && Last_texel_unit_set != tn) { - oglActiveTextureARB(GL_TEXTURE0_ARB + tn); - Last_texel_unit_set = tn; - } -#endif - - OpenGL_sets_this_frame[2]++; - - if (dest_state) { - if (map_type == MAP_TYPE_BITMAP && bm_mipped(handle)) { - dglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); - dglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST); - } else { - dglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); - dglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); - } - } else { - if (map_type == MAP_TYPE_BITMAP && bm_mipped(handle)) { - // dglTexParameteri (GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_NEAREST_MIPMAP_NEAREST); - dglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); - dglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST); - } else { - dglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); - dglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); - } - } - - if (map_type == MAP_TYPE_LIGHTMAP) { - SET_FILTER_STATE(OpenGL_lightmap_states[handle], dest_state); - } else { - SET_FILTER_STATE(OpenGL_bitmap_states[handle], dest_state); - } - - CHECK_ERROR(9) -} - -// Turns on/off multitexture blending -void gpu_SetMultitextureBlendMode(bool state) { - if (OpenGL_multitexture_state == state) - return; - OpenGL_multitexture_state = state; - -#if (defined(_USE_OGL_ACTIVE_TEXTURES)) - oglActiveTextureARB(GL_TEXTURE1_ARB); - oglClientActiveTextureARB(GL_TEXTURE1_ARB); - if (state) { - dglEnableClientState(GL_TEXTURE_COORD_ARRAY); - dglEnable(GL_TEXTURE_2D); - } else { - dglDisableClientState(GL_TEXTURE_COORD_ARRAY); - dglDisable(GL_TEXTURE_2D); - } - oglActiveTextureARB(GL_TEXTURE0_ARB); - oglClientActiveTextureARB(GL_TEXTURE0_ARB); - Last_texel_unit_set = 0; -#endif -} - -void gpu_DrawFlatPolygon3D(g3Point **p, int nv) { - float fr, fg, fb; - int i; - - if (UseMultitexture) { - gpu_SetMultitextureBlendMode(false); - } - - float alpha = gpu_Alpha_multiplier * gpu_Alpha_factor; - - fr = GR_COLOR_RED(gpu_state.cur_color); - fg = GR_COLOR_GREEN(gpu_state.cur_color); - fb = GR_COLOR_BLUE(gpu_state.cur_color); - fr /= 255.0; - fg /= 255.0; - fb /= 255.0; - - // And draw! - dglBegin(GL_POLYGON); - for (i = 0; i < nv; i++) { - g3Point *pnt = p[i]; - ASSERT(pnt->p3_flags & PF_ORIGPOINT); - - if (gpu_state.cur_alpha_type & ATF_VERTEX) - alpha = pnt->p3_a * gpu_Alpha_multiplier * gpu_Alpha_factor; - - // If we have a lighting model, apply the correct lighting! - if (gpu_state.cur_light_state != LS_NONE) { - // Do lighting based on intesity (MONO) or colored (RGB) - if (gpu_state.cur_color_model == CM_MONO) - dglColor4f(pnt->p3_l, pnt->p3_l, pnt->p3_l, alpha); - else { - dglColor4f(pnt->p3_r, pnt->p3_g, pnt->p3_b, alpha); - } - - } else { - dglColor4f(fr, fg, fb, alpha); - } - - /* - // Finally, specify a vertex - float z = std::max(0,std::min(1.0,1.0-(1.0/(pnt->p3_z+Z_bias)))); - dglVertex3f (pnt->p3_sx+x_add,pnt->p3_sy+y_add,-z); - */ - dglVertex3f(pnt->p3_vecPreRot.x, pnt->p3_vecPreRot.y, pnt->p3_vecPreRot.z); - } - - dglEnd(); - CHECK_ERROR(11) - OpenGL_polys_drawn++; - OpenGL_verts_processed += nv; -} - -// Sets the gamma correction value -void rend_SetGammaValue(float val) { - // if( WindowGL ) - // return; - - gpu_preferred_state.gamma = val; - mprintf(0, "Setting gamma to %f\n", val); - -#if defined(WIN32) - WORD rampvals[3 * 256]; - - for (int i = 0; i < 256; i++) { - float norm = (float)i / 255.0f; - - float newval = powf(norm, 1.0f / val); - - newval *= 65535; - - newval = std::min(65535, newval); - - rampvals[i] = newval; - rampvals[i + 256] = newval; - rampvals[i + 512] = newval; - } - - SetDeviceGammaRamp(hOpenGLDC, (LPVOID)rampvals); -#endif -} - -// Resets the texture cache -void opengl_ResetCache(void) { - if (OpenGL_cache_initted) { - mem_free(OpenGL_lightmap_remap); - mem_free(OpenGL_bitmap_remap); - mem_free(OpenGL_lightmap_states); - mem_free(OpenGL_bitmap_states); - OpenGL_cache_initted = 0; - } - - opengl_InitCache(); -} - -uint8_t opengl_Framebuffer_ready = 0; -chunked_bitmap opengl_Chunked_bitmap; - -void opengl_ChangeChunkedBitmap(int bm_handle, chunked_bitmap *chunk) { - int bw = bm_w(bm_handle, 0); - int bh = bm_h(bm_handle, 0); - - // determine optimal size of the square bitmaps - float fopt = 128.0f; - int iopt; - - // find the smallest dimension and base off that - int smallest = std::min(bw, bh); - - if (smallest <= 32) - fopt = 32; - else if (smallest <= 64) - fopt = 64; - else - fopt = 128; - - iopt = (int)fopt; - - // Get how many pieces we need across and down - float temp = bw / fopt; - int how_many_across = temp; - if ((temp - how_many_across) > 0) - how_many_across++; - - temp = bh / fopt; - int how_many_down = temp; - if ((temp - how_many_down) > 0) - how_many_down++; - - ASSERT(how_many_across > 0); - ASSERT(how_many_down > 0); - - // Now go through our big bitmap and partition it into pieces - uint16_t *src_data = bm_data(bm_handle, 0); - uint16_t *sdata; - uint16_t *ddata; - - int shift; - switch (iopt) { - case 32: - shift = 5; - break; - case 64: - shift = 6; - break; - case 128: - shift = 7; - break; - default: - Int3(); // Get Jeff - break; - } - int maxx, maxy; - int windex, hindex; - int s_y, s_x, d_y, d_x; - - for (hindex = 0; hindex < how_many_down; hindex++) { - for (windex = 0; windex < how_many_across; windex++) { - // loop through the chunks - // find end x and y - if (windex < how_many_across - 1) - maxx = iopt; - else - maxx = bw - (windex << shift); - if (hindex < how_many_down - 1) - maxy = iopt; - else - maxy = bh - (hindex << shift); - - // find the starting source x and y - s_x = (windex << shift); - s_y = (hindex << shift); - - // get the pointers pointing to the right spot - ddata = bm_data(chunk->bm_array[hindex * how_many_across + windex], 0); - GameBitmaps[chunk->bm_array[hindex * how_many_across + windex]].flags |= BF_CHANGED; - sdata = &src_data[s_y * bw + s_x]; - - // copy the data - for (d_y = 0; d_y < maxy; d_y++) { - for (d_x = 0; d_x < maxx; d_x++) { - ddata[d_x] = sdata[d_x]; - } // end for d_x - sdata += bw; - ddata += iopt; - } // end for d_y - - } // end for windex - } // end for hindex -} - -// Tells the software renderer whether or not to use mipping -void rend_SetMipState(int8_t mipstate) {} - -// Init our renderer -int rend_Init(renderer_type state, oeApplication *app, renderer_preferred_state *pref_state) { -#ifndef DEDICATED_ONLY - int retval = 0; - rend_SetRendererType(state); - if (!Renderer_initted) { - if (!Renderer_close_flag) { - atexit(rend_Close); - Renderer_close_flag = 1; - } - - Renderer_initted = 1; - } - - if (OpenGL_window_initted) { - rend_CloseOpenGLWindow(); - OpenGL_window_initted = 0; - } - - mprintf(0, "Renderer init is set to %d\n", Renderer_initted); - -#ifndef OEM_V3 - int flags = app->flags(); - if (flags & OEAPP_WINDOWED) { - // initialize for windowed - retval = rend_InitOpenGLWindow(app, pref_state); - } else { - // initialize for full screen - retval = opengl_Init(app, pref_state); - } -#endif - - return retval; -#else - return 0; -#endif // #ifdef DEDICATED_ONLY -} - -void rend_Close(void) { - mprintf(0, "CLOSE:Renderer init is set to %d\n", Renderer_initted); - if (!Renderer_initted) - return; - - if (OpenGL_window_initted) { - if (Renderer_type == RENDERER_OPENGL) { - rend_CloseOpenGLWindow(); - } - OpenGL_window_initted = 0; - } - - opengl_Close(); - - Renderer_initted = 0; -} - -void gpu_BindTexture(int handle, int map_type, int slot) { - opengl_MakeBitmapCurrent(handle, map_type, slot); - opengl_MakeWrapTypeCurrent(handle, map_type, slot); - opengl_MakeFilterTypeCurrent(handle, map_type, slot); -} - -void gpu_RenderPolygon(PosColorUVVertex *vData, uint32_t nv) { - dglVertexPointer(3, GL_FLOAT, sizeof(*vData), &vData->pos); - dglColorPointer(4, GL_FLOAT, sizeof(*vData), &vData->color); - oglClientActiveTextureARB(GL_TEXTURE0_ARB + 0); - dglTexCoordPointer(4, GL_FLOAT, sizeof(*vData), &vData->uv); - - if (gpu_state.cur_texture_quality == 0) { - // force disable textures - dglDisableClientState(GL_TEXTURE_COORD_ARRAY); - } - - oglClientActiveTextureARB(GL_TEXTURE0_ARB + 1); - dglDisableClientState(GL_TEXTURE_COORD_ARRAY); - - // draw the data in the arrays - dglDrawArrays(GL_POLYGON, 0, nv); - - if (gpu_state.cur_texture_quality == 0) { - // re-enable textures - oglClientActiveTextureARB(GL_TEXTURE0_ARB + 0); - dglEnableClientState(GL_TEXTURE_COORD_ARRAY); - } - - OpenGL_polys_drawn++; - OpenGL_verts_processed += nv; -} - -void gpu_RenderPolygonUV2(PosColorUV2Vertex *vData, uint32_t nv) { - dglVertexPointer(3, GL_FLOAT, sizeof(*vData), &vData->pos); - dglColorPointer(4, GL_FLOAT, sizeof(*vData), &vData->color); - oglClientActiveTextureARB(GL_TEXTURE0_ARB + 0); - dglTexCoordPointer(4, GL_FLOAT, sizeof(*vData), &vData->uv0); - oglClientActiveTextureARB(GL_TEXTURE0_ARB + 1); - dglEnableClientState(GL_TEXTURE_COORD_ARRAY); - dglTexCoordPointer(4, GL_FLOAT, sizeof(*vData), &vData->uv1); - - dglDrawArrays(GL_POLYGON, 0, nv); - OpenGL_polys_drawn++; - OpenGL_verts_processed += nv; - - CHECK_ERROR(10) -} - -void rend_SetFlatColor(ddgr_color color) { gpu_state.cur_color = color; } - -// Sets the fog state to TRUE or FALSE -void rend_SetFogState(int8_t state) { - if (state == gpu_state.cur_fog_state) - return; - - gpu_state.cur_fog_state = state; - if (state == 1) { - dglEnable(GL_FOG); - } else { - dglDisable(GL_FOG); - } -} - -// Sets the near and far plane of fog -void rend_SetFogBorders(float nearz, float farz) { - // Sets the near and far plane of fog - float fogStart = nearz; - float fogEnd = farz; - - gpu_state.cur_fog_start = fogStart; - gpu_state.cur_fog_end = fogEnd; - - dglFogi(GL_FOG_MODE, GL_LINEAR); - dglFogf(GL_FOG_START, fogStart); - dglFogf(GL_FOG_END, fogEnd); -} - -void rend_SetRendererType(renderer_type state) { - Renderer_type = state; - mprintf(0, "RendererType is set to %d.\n", state); -} - -void rend_SetLighting(light_state state) { - if (state == gpu_state.cur_light_state) - return; // No redundant state setting -#if (defined(_USE_OGL_ACTIVE_TEXTURES)) - if (UseMultitexture && Last_texel_unit_set != 0) { - oglActiveTextureARB(GL_TEXTURE0_ARB + 0); - Last_texel_unit_set = 0; - } -#endif - - OpenGL_sets_this_frame[4]++; - - switch (state) { - case LS_NONE: - dglShadeModel(GL_SMOOTH); - gpu_state.cur_light_state = LS_NONE; - break; - case LS_FLAT_GOURAUD: - dglShadeModel(GL_SMOOTH); - gpu_state.cur_light_state = LS_FLAT_GOURAUD; - break; - case LS_GOURAUD: - case LS_PHONG: - dglShadeModel(GL_SMOOTH); - gpu_state.cur_light_state = LS_GOURAUD; - break; - default: - Int3(); - break; - } - - CHECK_ERROR(13) -} - -void rend_SetColorModel(color_model state) { - switch (state) { - case CM_MONO: - gpu_state.cur_color_model = CM_MONO; - break; - case CM_RGB: - gpu_state.cur_color_model = CM_RGB; - break; - default: - Int3(); - break; - } -} - -void rend_SetTextureType(texture_type state) { - if (state == gpu_state.cur_texture_type) - return; // No redundant state setting -#if (defined(_USE_OGL_ACTIVE_TEXTURES)) - if (UseMultitexture && Last_texel_unit_set != 0) { - oglActiveTextureARB(GL_TEXTURE0_ARB + 0); - Last_texel_unit_set = 0; - } -#endif - OpenGL_sets_this_frame[3]++; - - switch (state) { - case TT_FLAT: - dglDisable(GL_TEXTURE_2D); - gpu_state.cur_texture_quality = 0; - break; - case TT_LINEAR: - case TT_LINEAR_SPECIAL: - case TT_PERSPECTIVE: - case TT_PERSPECTIVE_SPECIAL: - dglEnable(GL_TEXTURE_2D); - gpu_state.cur_texture_quality = 2; - break; - default: - Int3(); // huh? Get Jason - break; - } - - CHECK_ERROR(12) - gpu_state.cur_texture_type = state; -} - -void rend_StartFrame(int x1, int y1, int x2, int y2, int clear_flags) { - if (clear_flags & RF_CLEAR_ZBUFFER) { - dglClear(GL_DEPTH_BUFFER_BIT); - } - gpu_state.clip_x1 = x1; - gpu_state.clip_y1 = y1; - gpu_state.clip_x2 = x2; - gpu_state.clip_y2 = y2; -} - - -// Flips the screen -void rend_Flip(void) { -#ifndef RELEASE - int i; - - RTP_INCRVALUE(texture_uploads, OpenGL_uploads); - RTP_INCRVALUE(polys_drawn, OpenGL_polys_drawn); - - mprintf_at(1, 1, 0, "Uploads=%d Polys=%d Verts=%d ", OpenGL_uploads, OpenGL_polys_drawn, OpenGL_verts_processed); - mprintf_at(1, 2, 0, "Sets= 0:%d 1:%d 2:%d 3:%d ", OpenGL_sets_this_frame[0], OpenGL_sets_this_frame[1], - OpenGL_sets_this_frame[2], OpenGL_sets_this_frame[3]); - mprintf_at(1, 3, 0, "Sets= 4:%d 5:%d ", OpenGL_sets_this_frame[4], OpenGL_sets_this_frame[5]); - for (i = 0; i < 10; i++) { - OpenGL_sets_this_frame[i] = 0; - } -#endif - - gpu_last_frame_polys_drawn = OpenGL_polys_drawn; - gpu_last_frame_verts_processed = OpenGL_verts_processed; - gpu_last_uploaded = OpenGL_uploads; - - OpenGL_uploads = 0; - OpenGL_polys_drawn = 0; - OpenGL_verts_processed = 0; - - // if we're rendering to an FBO, scale to the window framebuffer! - if (GOpenGLFBO != 0) { - #if defined(WIN32) - // !!! FIXME: is this expensive? - RECT rectWindow; // rectangle for the client area of the window - GetClientRect(hOpenGLWnd, &rectWindow); - int w = (int) (rectWindow.right - rectWindow.left); - int h = (int) (rectWindow.bottom - rectWindow.top); - #else - int w, h; - SDL_GL_GetDrawableSize(GSDLWindow, &w, &h); - #endif - - int scaledHeight, scaledWidth; - if (w < h) { - scaledWidth = w; - scaledHeight = (int) (((((double)GOpenGLFBOHeight) / ((double)GOpenGLFBOWidth))) * ((double)w)); - } else { - scaledHeight = h; - scaledWidth = (int) (((((double)GOpenGLFBOWidth) / ((double)GOpenGLFBOHeight))) * ((double)h)); - } - - const int centeredX = (w - scaledWidth) / 2; - const int centeredY = (h - scaledHeight) / 2; - - dglBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, 0); - dglClearColor (0.0f, 0.0f, 0.0f, 1.0f); - dglClear(GL_COLOR_BUFFER_BIT); // in case the Steam Overlay wrote to places we don't blit over. - dglBlitFramebufferEXT(0, 0, GOpenGLFBOWidth, GOpenGLFBOHeight, - centeredX, centeredY, centeredX + scaledWidth, centeredY + scaledHeight, - GL_COLOR_BUFFER_BIT, GL_LINEAR); - dglBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); - } - -#if defined(WIN32) - SwapBuffers((HDC)hOpenGLDC); -#elif defined(__LINUX__) - SDL_GL_SwapWindow(GSDLWindow); -#endif - - // go back to drawing on the FBO until we want to blit to the window framebuffer again. - if (GOpenGLFBO != 0) { - dglBindFramebufferEXT(GL_FRAMEBUFFER_EXT, GOpenGLFBO); - dglViewport(0, 0, GOpenGLFBOWidth, GOpenGLFBOHeight); - dglScissor(0, 0, GOpenGLFBOWidth, GOpenGLFBOHeight); - } - -#ifdef __PERMIT_GL_LOGGING - if (__glLog == true) { - DGL_LogNewFrame(); - } -#endif -} - -void rend_EndFrame(void) {} - -// Sets the state of z-buffering to on or off -void rend_SetZBufferState(int8_t state) { - if (state == gpu_state.cur_zbuffer_state) - return; // No redundant state setting - - OpenGL_sets_this_frame[5]++; - gpu_state.cur_zbuffer_state = state; - - // mprintf(0,"OPENGL: Setting zbuffer state to %d.\n",state); - - if (state) { - dglEnable(GL_DEPTH_TEST); - dglDepthFunc(GL_LEQUAL); - } else { - dglDisable(GL_DEPTH_TEST); - } - - CHECK_ERROR(14) -} - -// Clears the display to a specified color -void rend_ClearScreen(ddgr_color color) { - int r = (color >> 16 & 0xFF); - int g = (color >> 8 & 0xFF); - int b = (color & 0xFF); - - dglClearColor((float)r / 255.0f, (float)g / 255.0f, (float)b / 255.0f, 0); - - dglClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); -} - -// Clears the zbuffer for the screen -void rend_ClearZBuffer(void) { dglClear(GL_DEPTH_BUFFER_BIT); } - -// Clears the zbuffer for the screen -void rend_ResetCache(void) { - mprintf(0, "Resetting texture cache!\n"); - opengl_ResetCache(); -} - -// Fills a rectangle on the display -void rend_FillRect(ddgr_color color, int x1, int y1, int x2, int y2) { - int r = GR_COLOR_RED(color); - int g = GR_COLOR_GREEN(color); - int b = GR_COLOR_BLUE(color); - - int width = x2 - x1; - int height = y2 - y1; - - x1 += gpu_state.clip_x1; - y1 += gpu_state.clip_y1; - - dglEnable(GL_SCISSOR_TEST); - dglScissor(x1, gpu_state.screen_height - (height + y1), width, height); - dglClearColor((float)r / 255.0, (float)g / 255.0, (float)b / 255.0, 0); - dglClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); - - width = gpu_state.clip_x2 - gpu_state.clip_x1; - height = gpu_state.clip_y2 - gpu_state.clip_y1; - - dglScissor(gpu_state.clip_x1, gpu_state.screen_height - (gpu_state.clip_y1 + height), width, height); - dglDisable(GL_SCISSOR_TEST); -} - -// Sets a pixel on the display -void rend_SetPixel(ddgr_color color, int x, int y) { - int r = (color >> 16 & 0xFF); - int g = (color >> 8 & 0xFF); - int b = (color & 0xFF); - - g3_RefreshTransforms(true); - - dglColor3ub(r, g, b); - - dglBegin(GL_POINTS); - dglVertex2i(x, y); - dglEnd(); -} - -// Sets a pixel on the display -ddgr_color rend_GetPixel(int x, int y) { - ddgr_color color[4]; - dglReadPixels(x, (gpu_state.screen_height - 1) - y, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, (GLvoid *)color); - return color[0]; -} - -// Draws a line -void rend_DrawLine(int x1, int y1, int x2, int y2) { - int8_t atype; - light_state ltype; - texture_type ttype; - int color = gpu_state.cur_color; - - g3_RefreshTransforms(true); - - int r = GR_COLOR_RED(color); - int g = GR_COLOR_GREEN(color); - int b = GR_COLOR_BLUE(color); - - atype = gpu_state.cur_alpha_type; - ltype = gpu_state.cur_light_state; - ttype = gpu_state.cur_texture_type; - - rend_SetAlphaType(AT_ALWAYS); - rend_SetLighting(LS_NONE); - rend_SetTextureType(TT_FLAT); - - // TODO: Generalize - dglBegin(GL_LINES); - dglColor4ub(r, g, b, 255); - dglVertex2i(x1 + gpu_state.clip_x1, y1 + gpu_state.clip_y1); - dglColor4ub(r, g, b, 255); - dglVertex2i(x2 + gpu_state.clip_x1, y2 + gpu_state.clip_y1); - dglEnd(); - - rend_SetAlphaType(atype); - rend_SetLighting(ltype); - rend_SetTextureType(ttype); -} - -// Sets the color of fog -void rend_SetFogColor(ddgr_color color) { - if (color == gpu_state.cur_fog_color) - return; - - float fc[4]; - fc[0] = GR_COLOR_RED(color); - fc[1] = GR_COLOR_GREEN(color); - fc[2] = GR_COLOR_BLUE(color); - fc[3] = 1; - - fc[0] /= 255.0f; - fc[1] /= 255.0f; - fc[2] /= 255.0f; - - dglFogfv(GL_FOG_COLOR, fc); -} - -// Sets the lighting state of opengl -void rend_SetLightingState(light_state state) { - if (state == gpu_state.cur_light_state) - return; // No redundant state setting - - if (UseMultitexture && Last_texel_unit_set != 0) { -#if (defined(_USE_OGL_ACTIVE_TEXTURES)) - oglActiveTextureARB(GL_TEXTURE0_ARB + 0); - Last_texel_unit_set = 0; -#endif - } - - OpenGL_sets_this_frame[4]++; - - switch (state) { - case LS_NONE: - dglShadeModel(GL_SMOOTH); - gpu_state.cur_light_state = LS_NONE; - break; - case LS_FLAT_GOURAUD: - dglShadeModel(GL_SMOOTH); - gpu_state.cur_light_state = LS_FLAT_GOURAUD; - break; - case LS_GOURAUD: - case LS_PHONG: - dglShadeModel(GL_SMOOTH); - gpu_state.cur_light_state = LS_GOURAUD; - break; - default: - Int3(); - break; - } - - CHECK_ERROR(13) -} - -void rend_SetAlphaType(int8_t atype) { - if (atype == gpu_state.cur_alpha_type) - return; // don't set it redundantly -#if (defined(_USE_OGL_ACTIVE_TEXTURES)) - if (UseMultitexture && Last_texel_unit_set != 0) { - oglActiveTextureARB(GL_TEXTURE0_ARB + 0); - Last_texel_unit_set = 0; - } -#endif - OpenGL_sets_this_frame[6]++; - - if (atype == AT_ALWAYS) { - if (opengl_Blending_on) { - dglDisable(GL_BLEND); - opengl_Blending_on = false; - } - } else { - if (!opengl_Blending_on) { - dglEnable(GL_BLEND); - opengl_Blending_on = true; - } - } - - switch (atype) { - case AT_ALWAYS: - case AT_TEXTURE: - rend_SetAlphaValue(255); - dglBlendFunc(GL_ONE, GL_ZERO); - break; - case AT_CONSTANT: - case AT_CONSTANT_TEXTURE: - case AT_VERTEX: - case AT_CONSTANT_TEXTURE_VERTEX: - case AT_CONSTANT_VERTEX: - case AT_TEXTURE_VERTEX: - dglBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); - break; - case AT_LIGHTMAP_BLEND: - dglBlendFunc(GL_DST_COLOR, GL_ZERO); - break; - case AT_SATURATE_TEXTURE: - case AT_LIGHTMAP_BLEND_SATURATE: - case AT_SATURATE_VERTEX: - case AT_SATURATE_CONSTANT_VERTEX: - case AT_SATURATE_TEXTURE_VERTEX: - dglBlendFunc(GL_SRC_ALPHA, GL_ONE); - break; - case AT_SPECULAR: - break; - default: - Int3(); // no type defined,get jason - break; - } - gpu_state.cur_alpha_type = atype; - gpu_Alpha_multiplier = rend_GetAlphaMultiplier(); - CHECK_ERROR(15) -} - -// Draws a line using the states of the renderer -void rend_DrawSpecialLine(g3Point *p0, g3Point *p1) { - g3_RefreshTransforms(true); - - int x_add = gpu_state.clip_x1; - int y_add = gpu_state.clip_y1; - float fr, fg, fb, alpha; - int i; - - fr = GR_COLOR_RED(gpu_state.cur_color); - fg = GR_COLOR_GREEN(gpu_state.cur_color); - fb = GR_COLOR_BLUE(gpu_state.cur_color); - - fr /= 255.0f; - fg /= 255.0f; - fb /= 255.0f; - - alpha = gpu_Alpha_multiplier * gpu_Alpha_factor; - - // And draw! - dglBegin(GL_LINES); - for (i = 0; i < 2; i++) { - g3Point *pnt = p0; - - if (i == 1) - pnt = p1; - - if (gpu_state.cur_alpha_type & ATF_VERTEX) - alpha = pnt->p3_a * gpu_Alpha_multiplier * gpu_Alpha_factor; - - // If we have a lighting model, apply the correct lighting! - if (gpu_state.cur_light_state != LS_NONE) { - if (gpu_state.cur_light_state == LS_FLAT_GOURAUD) { - dglColor4f(fr, fg, fb, alpha); - } else { - // Do lighting based on intesity (MONO) or colored (RGB) - if (gpu_state.cur_color_model == CM_MONO) - dglColor4f(pnt->p3_l, pnt->p3_l, pnt->p3_l, alpha); - else { - dglColor4f(pnt->p3_r, pnt->p3_g, pnt->p3_b, alpha); - } - } - } else { - dglColor4f(fr, fg, fb, alpha); - } - - // Finally, specify a vertex - float z = std::clamp(1.0 - (1.0 / (pnt->p3_z + Z_bias)), 0.0, 1.0); - dglVertex3f(pnt->p3_sx + x_add, pnt->p3_sy + y_add, -z); - } - - dglEnd(); -} - -// Takes a screenshot of the current frame and puts it into the handle passed -std::unique_ptr rend_Screenshot() { - uint16_t *dest_data; - uint32_t *temp_data; - - int total = gpu_state.screen_width * gpu_state.screen_height; - auto result = std::make_unique(gpu_state.screen_width, gpu_state.screen_height, PixelDataFormat::RGBA32, true); - - if (!result || result->getData() == nullptr) { - return nullptr; - } - - dglReadPixels(0, 0, gpu_state.screen_width, gpu_state.screen_height, GL_RGBA, GL_UNSIGNED_BYTE, - (GLvoid *)result->getData()); - - return result; -} - -// Takes a screenshot of the current frame and puts it into the handle passed -void rend_Screenshot(int bm_handle) { - auto screenshot = rend_Screenshot(); - auto *temp_data = reinterpret_cast(screenshot->getData()); - - uint32_t w, h; - screenshot->getSize(w, h); - - ASSERT((bm_w(bm_handle, 0)) == gpu_state.screen_width); - ASSERT((bm_h(bm_handle, 0)) == gpu_state.screen_height); - - uint16_t* dest_data = bm_data(bm_handle, 0); - - for (int i = 0; i < h; i++) { - for (int t = 0; t < w; t++) { - uint32_t spix = temp_data[i * w + t]; - - int r = spix & 0xff; - int g = (spix >> 8) & 0xff; - int b = (spix >> 16) & 0xff; - - dest_data[(((h - 1) - i) * w) + t] = GR_RGB16(r, g, b); - } - } -} - -// Enables/disables writes the depth buffer -void rend_SetZBufferWriteMask(int state) { - OpenGL_sets_this_frame[5]++; - if (state) { - dglDepthMask(GL_TRUE); - } else { - dglDepthMask(GL_FALSE); - } -} - -int rend_ReInit() { - opengl_Close(true); - return opengl_Init(NULL, &gpu_preferred_state); -} - -// Takes a bitmap and blits it to the screen using linear frame buffer stuff -// X and Y are the destination X,Y -void rend_CopyBitmapToFramebuffer(int bm_handle, int x, int y) { - ASSERT(opengl_Framebuffer_ready); - - if (opengl_Framebuffer_ready == 1) { - bm_CreateChunkedBitmap(bm_handle, &opengl_Chunked_bitmap); - opengl_Framebuffer_ready = 2; - } else { - opengl_ChangeChunkedBitmap(bm_handle, &opengl_Chunked_bitmap); - } - - rend_DrawChunkedBitmap(&opengl_Chunked_bitmap, 0, 0, 255); -} - -// Gets a renderer ready for a framebuffer copy, or stops a framebuffer copy -void rend_SetFrameBufferCopyState(bool state) { - if (state) { - ASSERT(opengl_Framebuffer_ready == 0); - opengl_Framebuffer_ready = 1; - } else { - ASSERT(opengl_Framebuffer_ready != 0); - opengl_Framebuffer_ready = 0; - - if (opengl_Framebuffer_ready == 2) { - bm_DestroyChunkedBitmap(&opengl_Chunked_bitmap); - opengl_ResetCache(); - } - } -} - -// Gets OpenGL ready to work in a window -int rend_InitOpenGLWindow(oeApplication *app, renderer_preferred_state *pref_state) { - WindowGL = 1; - return opengl_Init(app, pref_state); -} - -// Shuts down OpenGL in a window -void rend_CloseOpenGLWindow(void) { - opengl_Close(); - WindowGL = 0; - OpenGL_window_initted = 0; - mprintf(1, "SHUTTING DOWN WINDOWED OPENGL!"); -} - -// Sets the hardware bias level for coplanar polygons -// This helps reduce z buffer artifacts -void rend_SetCoplanarPolygonOffset(float factor) { - if (factor == 0.0f) { - dglDisable(GL_POLYGON_OFFSET_FILL); - } else { - dglEnable(GL_POLYGON_OFFSET_FILL); - dglPolygonOffset(-1.0f, -1.0f); - } -} - -// returns the direct draw object -void *rend_RetrieveDirectDrawObj(void **frontsurf, void **backsurf) { - *frontsurf = NULL; - *backsurf = NULL; - return NULL; -} - -void rend_TransformSetToPassthru(void) { - int width = gpu_state.screen_width; - int height = gpu_state.screen_height; - - // TODO: Generalize - // Projection - dglMatrixMode(GL_PROJECTION); - dglLoadIdentity(); - dglOrtho((GLfloat)0.0f, (GLfloat)(width), (GLfloat)(height), (GLfloat)0.0f, 0.0f, 1.0f); - - // Viewport - dglViewport(0, 0, width, height); - dglScissor(0, 0, width, height); - - // ModelView - dglMatrixMode(GL_MODELVIEW); - dglLoadIdentity(); -} - -void rend_TransformSetViewport(int lx, int ty, int width, int height) { - dglViewport(lx, gpu_state.screen_height - (ty + height - 1), width, height); -} - -void rend_TransformSetProjection(float trans[4][4]) { - dglMatrixMode(GL_PROJECTION); - dglLoadMatrixf(&trans[0][0]); -} - -void rend_TransformSetModelView(float trans[4][4]) { - dglMatrixMode(GL_MODELVIEW); - dglLoadMatrixf(&trans[0][0]); -} diff --git a/renderer/HardwarePoints.cpp b/renderer/HardwarePoints.cpp deleted file mode 100644 index 664f50c54..000000000 --- a/renderer/HardwarePoints.cpp +++ /dev/null @@ -1,148 +0,0 @@ -/* -* Descent 3 -* Copyright (C) 2024 Parallax Software -* -* This program is free software: you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation, either version 3 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program. If not, see . -*/ - -#include "3d.h" -#include "HardwareInternal.h" -#include - -extern vector Clip_plane_point; -// code a point. fills in the p3_codes field of the point, and returns the codes -uint8_t g3_CodePoint(g3Point *p) { - uint8_t cc = 0; - - if (p->p3_x > p->p3_z) - cc |= CC_OFF_RIGHT; - - if (p->p3_y > p->p3_z) - cc |= CC_OFF_TOP; - - if (p->p3_x < -p->p3_z) - cc |= CC_OFF_LEFT; - - if (p->p3_y < -p->p3_z) - cc |= CC_OFF_BOT; - - if (p->p3_z < 0) - cc |= CC_BEHIND; - - if (p->p3_z > Far_clip_z) - cc |= CC_OFF_FAR; - - // Check to see if we should be clipped to the custom plane - if (Clip_custom) { - vector vec = p->p3_vec - Clip_plane_point; - vec.x /= Matrix_scale.x; - vec.y /= Matrix_scale.y; - vec.z /= Matrix_scale.z; - - float dp = vec * Clip_plane; - if (dp < -0.005f) { - cc |= CC_OFF_CUSTOM; - } - } - - return p->p3_codes = cc; -} - -// rotates a point. returns codes. does not check if already rotated -uint8_t g3_RotatePoint(g3Point *dest, vector *src) { - // store the pre-rotated point - dest->p3_vecPreRot = *src; - - // find the point offset from the view/camera position - vector tempv = *src - View_position; - - // rotate the point by the view/camera's orientation - dest->p3_vec = tempv * View_matrix; - - // determine the flags for the point - dest->p3_flags = PF_ORIGPOINT; - return g3_CodePoint(dest); -} - -// projects a point -void g3_ProjectPoint(g3Point *p) { - if (p->p3_flags & PF_PROJECTED || p->p3_codes & CC_BEHIND) - return; - - float one_over_z = 1.0 / p->p3_z; - p->p3_sx = Window_w2 + (p->p3_x * (Window_w2 * one_over_z)); - p->p3_sy = Window_h2 - (p->p3_y * (Window_h2 * one_over_z)); - p->p3_flags |= PF_PROJECTED; -} - -// from a 2d point, compute the vector through that point -void g3_Point2Vec(vector *v, int16_t sx, int16_t sy) { - vector tempv; - matrix tempm; - - tempv.x = (((sx - Window_w2) / Window_w2) * Matrix_scale.z / Matrix_scale.x); - tempv.y = -(((sy - Window_h2) / Window_h2) * Matrix_scale.z / Matrix_scale.y); - tempv.z = 1.0f; - - vm_NormalizeVector(&tempv); - - tempm = ~Unscaled_matrix; - - *v = tempv * tempm; -} - -// delta rotation functions -vector *g3_RotateDeltaX(vector *dest, float dx) { - dest->x = View_matrix.rvec.x * dx; - dest->y = View_matrix.uvec.x * dx; - dest->z = View_matrix.fvec.x * dx; - - return dest; -} - -vector *g3_RotateDeltaY(vector *dest, float dy) { - dest->x = View_matrix.rvec.y * dy; - dest->y = View_matrix.uvec.y * dy; - dest->z = View_matrix.fvec.y * dy; - - return dest; -} - -vector *g3_RotateDeltaZ(vector *dest, float dz) { - dest->x = View_matrix.rvec.z * dz; - dest->y = View_matrix.uvec.z * dz; - dest->z = View_matrix.fvec.z * dz; - - return dest; -} - -vector *g3_RotateDeltaVec(vector *dest, vector *src) { - *dest = *src * View_matrix; - - return dest; -} - -uint8_t g3_AddDeltaVec(g3Point *dest, g3Point *src, vector *deltav) { - dest->p3_vec = src->p3_vec + *deltav; - - dest->p3_flags = 0; // not projected - - return g3_CodePoint(dest); -} - -// calculate the depth of a point - returns the z coord of the rotated point -float g3_CalcPointDepth(vector *pnt) { - return ((pnt->x - View_position.x) * View_matrix.fvec.x) + ((pnt->y - View_position.y) * View_matrix.fvec.y) + - ((pnt->z - View_position.z) * View_matrix.fvec.z); -} diff --git a/renderer/HardwareSetup.cpp b/renderer/HardwareSetup.cpp deleted file mode 100644 index c0daea47e..000000000 --- a/renderer/HardwareSetup.cpp +++ /dev/null @@ -1,163 +0,0 @@ -/* -* Descent 3 -* Copyright (C) 2024 Parallax Software -* -* This program is free software: you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation, either version 3 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program. If not, see . -*/ - -#include -#include -#include "3d.h" -#include "pserror.h" -#include "HardwareInternal.h" -#include "renderer.h" - -// User-specified aspect ratio, stored as w/h -static float sAspect = 0.0f; - -// initialize the 3d system -void g3_Init(void) { atexit(g3_Close); } - -// close down the 3d system -void g3_Close(void) {} - -// allows the user to specify an aspect ratio that overrides the renderer's -// The parameter is the w/h of the screen pixels -void g3_SetAspectRatio(float aspect) { sAspect = aspect; } -// returns the user-specified aspect ratio used to override the renderer's -float g3_GetAspectRatio() { return sAspect; } - -void g3_GetViewPortMatrix(float *viewMat) { - // extract the viewport data from the renderer - int viewportWidth, viewportHeight; - int viewportX, viewportY; - rend_GetProjectionScreenParameters(viewportX, viewportY, viewportWidth, viewportHeight); - - float viewportWidthOverTwo = ((float)viewportWidth) * 0.5f; - float viewportHeightOverTwo = ((float)viewportHeight) * 0.5f; - - // setup the matrix - memset(viewMat, 0, sizeof(float) * 16); - viewMat[0] = viewportWidthOverTwo; - viewMat[5] = -viewportHeightOverTwo; - viewMat[12] = viewportWidthOverTwo + (float)viewportX; - viewMat[13] = viewportHeightOverTwo + (float)viewportY; - viewMat[10] = viewMat[15] = 1.0f; -} - -void g3_GetProjectionMatrix(float zoom, float *projMat) { - // get window size - int viewportWidth, viewportHeight; - rend_GetProjectionParameters(&viewportWidth, &viewportHeight); - - // compute aspect ratio for this ViewPort - float screenAspect = rend_GetAspectRatio(); - if (sAspect != 0.0f) { - // check for user override - screenAspect = screenAspect * 4.0f / 3.0f / sAspect; - } - float s = screenAspect * ((float)viewportWidth) / ((float)viewportHeight); - - // setup the matrix - memset(projMat, 0, sizeof(float) * 16); - - // calculate 1/tan(fov) - float oOT = 1.0f / zoom; - - // fill in the matrix - projMat[0] = oOT; - projMat[5] = oOT * s; - projMat[10] = 1.0f; - projMat[11] = 1.0f; - projMat[14] = -1.0f; -} - -// start the frame -void g3_StartFrame(vector *view_pos, matrix *view_matrix, float zoom) { - // initialize the viewport transform - g3_GetViewPortMatrix((float *)gTransformViewPort); - g3_GetProjectionMatrix(zoom, (float *)gTransformProjection); - g3_GetModelViewMatrix(view_pos, view_matrix, (float *)gTransformModelView); - g3_UpdateFullTransform(); - - // get window size - rend_GetProjectionParameters(&Window_width, &Window_height); - - // Set vars for projection - Window_w2 = ((float)Window_width) * 0.5f; - Window_h2 = ((float)Window_height) * 0.5f; - - // Compute aspect ratio for this window - float screen_aspect = rend_GetAspectRatio(); - if (sAspect != 0.0f) { - // check for user override - screen_aspect = screen_aspect * 4.0f / 3.0f / sAspect; - } - float s = screen_aspect * (float)Window_height / (float)Window_width; - - if (s <= 0.0f) // JEFF: Should this have been 1.0f? - { - // scale x - Matrix_scale.x = s; - Matrix_scale.y = 1.0f; - } else { - Matrix_scale.y = 1.0f / s; - Matrix_scale.x = 1.0f; - } - - Matrix_scale.z = 1.0f; - - // Set the view variables - View_position = *view_pos; - View_zoom = zoom; - Unscaled_matrix = *view_matrix; - - // Compute matrix scale for zoom and aspect ratio - if (View_zoom <= 1.0f) { - // zoom in by scaling z - Matrix_scale.z = Matrix_scale.z * View_zoom; - } else { - // zoom out by scaling x and y - float oOZ = 1.0f / View_zoom; - Matrix_scale.x = Matrix_scale.x * oOZ; - Matrix_scale.y = Matrix_scale.y * oOZ; - } - - // Scale the matrix elements - View_matrix.rvec = Unscaled_matrix.rvec * Matrix_scale.x; - View_matrix.uvec = Unscaled_matrix.uvec * Matrix_scale.y; - View_matrix.fvec = Unscaled_matrix.fvec * Matrix_scale.z; - - // Reset the list of free points - InitFreePoints(); - - // Reset the far clip plane - g3_ResetFarClipZ(); -} - -// this doesn't do anything, but is here for completeness -void g3_EndFrame(void) { - // make sure temp points are free - CheckTempPoints(); -} - -// get the current view position -void g3_GetViewPosition(vector *vp) { *vp = View_position; } - -void g3_GetViewMatrix(matrix *mat) { *mat = View_matrix; } - -void g3_GetUnscaledMatrix(matrix *mat) { *mat = Unscaled_matrix; } - -// Gets the matrix scale vector -void g3_GetMatrixScale(vector *matrix_scale) { *matrix_scale = Matrix_scale; } diff --git a/renderer/HardwareTransforms.cpp b/renderer/HardwareTransforms.cpp deleted file mode 100644 index 9db7a6216..000000000 --- a/renderer/HardwareTransforms.cpp +++ /dev/null @@ -1,114 +0,0 @@ -/* -* Descent 3 -* Copyright (C) 2024 Parallax Software -* -* This program is free software: you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation, either version 3 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program. If not, see . -*/ - -#include "3d.h" -#include "pserror.h" -#include "HardwareInternal.h" -#include "renderer.h" -#include - -// Whether or not to use T&L transforms or the pass-thru ones -static int sUseTransformPassthru = -1; - -extern float Z_bias; -void g3_GetModelViewMatrix(const vector *viewPos, const matrix *viewMatrix, float *mvMat) { - matrix localOrient = (*viewMatrix); - vector localPos = -(*viewPos); - mvMat[0] = localOrient.rvec.x; - mvMat[1] = localOrient.uvec.x; - mvMat[2] = localOrient.fvec.x; - mvMat[3] = 0.0f; - mvMat[4] = localOrient.rvec.y; - mvMat[5] = localOrient.uvec.y; - mvMat[6] = localOrient.fvec.y; - mvMat[7] = 0.0f; - mvMat[8] = localOrient.rvec.z; - mvMat[9] = localOrient.uvec.z; - mvMat[10] = localOrient.fvec.z; - mvMat[11] = 0.0f; - mvMat[12] = localPos * localOrient.rvec; - mvMat[13] = localPos * localOrient.uvec; - mvMat[14] = localPos * localOrient.fvec + Z_bias; - mvMat[15] = 1.0f; -} - -void g3_TransformVert(float res[4], float pt[4], float a[4][4]) { - int y; - for (y = 0; y < 4; ++y) { - res[y] = (pt[0] * a[0][y]) + (pt[1] * a[1][y]) + (pt[2] * a[2][y]) + (pt[3] * a[3][y]); - } -} - -void g3_TransformMult(float res[4][4], float a[4][4], float b[4][4]) { - float temp[4][4]; - - int x, y; - for (y = 0; y < 4; ++y) { - for (x = 0; x < 4; ++x) { - temp[y][x] = (a[y][0] * b[0][x]) + (a[y][1] * b[1][x]) + (a[y][2] * b[2][x]) + (a[y][3] * b[3][x]); - } - } - memcpy(res, temp, 16 * sizeof(float)); -} - -void g3_TransformTrans(float res[4][4], float t[4][4]) { - float temp[4][4]; - int y; - for (y = 0; y < 4; ++y) { - int x; - for (x = 0; x < 4; ++x) { - temp[x][y] = t[y][x]; - } - } - memcpy(res, temp, 16 * sizeof(float)); -} - -void g3_UpdateFullTransform() { - // ModelView -> projection - g3_TransformMult(gTransformFull, gTransformModelView, gTransformProjection); - - // projection -> ViewPort - g3_TransformMult(gTransformFull, gTransformFull, gTransformViewPort); -} - -void g3_ForceTransformRefresh(void) { sUseTransformPassthru = -1; } - -void g3_RefreshTransforms(bool usePassthru) { - if (sUseTransformPassthru == 1 && usePassthru) { - // we don't have to do anything because we are already setup for pass-thru - return; - } - - if (usePassthru) { - // setup OpenGL to use pass-thru - rend_TransformSetToPassthru(); - } else { - // extract the viewport data from the renderer - int viewportWidth, viewportHeight, viewportX, viewportY; - rend_GetProjectionScreenParameters(viewportX, viewportY, viewportWidth, viewportHeight); - - // setup OpenGL to use full transform stack - // TODO: in the future we only need to set those that have changed - rend_TransformSetViewport(viewportX, viewportY, viewportWidth, viewportHeight); - rend_TransformSetProjection(gTransformProjection); - rend_TransformSetModelView(gTransformModelView); - } - - // store the pass-thru - sUseTransformPassthru = (usePassthru) ? 1 : 0; -} diff --git a/renderer/RendererConfig.h b/renderer/RendererConfig.h new file mode 100644 index 000000000..76c8cac27 --- /dev/null +++ b/renderer/RendererConfig.h @@ -0,0 +1,27 @@ +/* +* Descent 3 +* Copyright (C) 2024 Parallax Software +* +* This program is free software: you can redistribute it and/or modify +* it under the terms of the GNU General Public License as published by +* the Free Software Foundation, either version 3 of the License, or +* (at your option) any later version. +* +* This program is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +* GNU General Public License for more details. +* +* You should have received a copy of the GNU General Public License +* along with this program. If not, see . +*/ +#ifndef __RENDERER_CONFIG_H__ +#define __RENDERER_CONFIG_H__ + +// use this to toggle "Hardware T&L" vs. "Software" +//#define USE_SOFTWARE_TNL + +// JEFF: I PUT THIS IN TO MAKE THINGS A LITTLE BRIGHTER SO I CAN SEE WHILE TESTING +//#define BRIGHTNESS_HACK 1.6f + +#endif diff --git a/renderer/clipper.cpp b/renderer/clipper.cpp new file mode 100644 index 000000000..7d3b54454 --- /dev/null +++ b/renderer/clipper.cpp @@ -0,0 +1,447 @@ +/* +* Descent 3 +* Copyright (C) 2024 Parallax Software +* +* This program is free software: you can redistribute it and/or modify +* it under the terms of the GNU General Public License as published by +* the Free Software Foundation, either version 3 of the License, or +* (at your option) any later version. +* +* This program is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +* GNU General Public License for more details. +* +* You should have received a copy of the GNU General Public License +* along with this program. If not, see . +*/ +#include "pserror.h" +#include "3d.h" +#include "HardwareInternal.h" + +static int free_point_num = -1; +static g3Point temp_points[MAX_POINTS_IN_POLY]; +static g3Point *free_points[MAX_POINTS_IN_POLY]; +vector Clip_plane_point; + +void InitFreePoints(void) +{ + int i; + + for( i = 0; i < MAX_POINTS_IN_POLY; i++ ) + { + free_points[i] = &temp_points[i]; + } + free_point_num = 0; +} + +g3Point *GetTempPoint(void) +{ + ASSERT(free_point_num < MAX_POINTS_IN_POLY); + + g3Point *p = free_points[ free_point_num++ ]; + p->p3_flags = PF_TEMP_POINT; + return p; +} + +void FreeTempPoint(g3Point *p) +{ + if( free_point_num < 1 ) + { + mprintf((1,"clipper: no temp points to free\n")); + free_point_num = 1; + Int3(); + } + ASSERT( p->p3_flags & PF_TEMP_POINT ); + + free_points[ --free_point_num ] = p; + + p->p3_flags &= ~PF_TEMP_POINT; +} + +//Verify that all the temp points are free, and free them it they are not. +#ifdef _DEBUG +void CheckTempPoints(void) +{ + if( free_point_num ) + { + Int3(); + InitFreePoints(); + } +} +#endif + +//Free up any temp points (created by the clipper) in the given pointlist +//Parameters: pointlist - pointer to list of pointers to points, returned by g3_ClipPolygon() +// nv - the number of points in pointlist +void g3_FreeTempPoints( g3Point **pointlist, int nv ) +{ + // Go through list + int i; + for( i = 0; i < nv; i++ ) + { + if( pointlist[i]->p3_flags & PF_TEMP_POINT ) + { + FreeTempPoint( pointlist[i] ); + } + } + + // Make sure all temp points are freed + CheckTempPoints(); +} + +// Clips an edge against the far plane +g3Point *ClipFarEdge( g3Point *on_pnt, g3Point *off_pnt ) +{ + float z_on = on_pnt->p3_z; + float z_off = off_pnt->p3_z; + + float k = 1.0f - ((z_off-Far_clip_z) / (z_off-z_on)); + + g3Point *tmp = GetTempPoint(); + tmp->p3_z = on_pnt->p3_z + ((off_pnt->p3_z-on_pnt->p3_z) * k); + tmp->p3_x = on_pnt->p3_x + ((off_pnt->p3_x-on_pnt->p3_x) * k); + tmp->p3_y = on_pnt->p3_y + ((off_pnt->p3_y-on_pnt->p3_y) * k); + + if (on_pnt->p3_flags & PF_UV) + { + tmp->p3_u = on_pnt->p3_u + ((off_pnt->p3_u-on_pnt->p3_u) * k); + tmp->p3_v = on_pnt->p3_v + ((off_pnt->p3_v-on_pnt->p3_v) * k); + tmp->p3_flags |= PF_UV; + } + + if (on_pnt->p3_flags & PF_UV2) + { + tmp->p3_u2 = on_pnt->p3_u2 + ((off_pnt->p3_u2-on_pnt->p3_u2) * k); + tmp->p3_v2 = on_pnt->p3_v2 + ((off_pnt->p3_v2-on_pnt->p3_v2) * k); + tmp->p3_flags |= PF_UV2; + } + + if (on_pnt->p3_flags & PF_L) + { + tmp->p3_l = on_pnt->p3_l + ((off_pnt->p3_l-on_pnt->p3_l) * k); + tmp->p3_flags |= PF_L; + } + + if (on_pnt->p3_flags & PF_RGBA) + { + tmp->p3_r = on_pnt->p3_r + ((off_pnt->p3_r-on_pnt->p3_r) * k); + tmp->p3_g = on_pnt->p3_g + ((off_pnt->p3_g-on_pnt->p3_g) * k); + tmp->p3_b = on_pnt->p3_b + ((off_pnt->p3_b-on_pnt->p3_b) * k); + tmp->p3_a = on_pnt->p3_a + ((off_pnt->p3_a-on_pnt->p3_a) * k); + tmp->p3_flags |= PF_RGBA; + } + + g3_CodePoint(tmp); + return tmp; +} + +// Clips an edge against the far plane +g3Point *ClipCustomEdge( g3Point *on_pnt, g3Point *off_pnt ) +{ + g3Point *tmp = GetTempPoint(); + + vector ray_direction = off_pnt->p3_vec - on_pnt->p3_vec; + ray_direction.x /= Matrix_scale.x; + ray_direction.y /= Matrix_scale.y; + ray_direction.z /= Matrix_scale.z; + + vector w = on_pnt->p3_vec - Clip_plane_point; + w.x /= Matrix_scale.x; + w.y /= Matrix_scale.y; + w.z /= Matrix_scale.z; + + float k, den = -(Clip_plane * ray_direction); + if( den == 0.0f ) + { + k = 1.0f; + } + else + { + float num = Clip_plane * w; + k = num / den; + } + + tmp->p3_vec = on_pnt->p3_vec + ((off_pnt->p3_vec-on_pnt->p3_vec) * k); + + if (on_pnt->p3_flags & PF_UV) + { + tmp->p3_u = on_pnt->p3_u + ((off_pnt->p3_u-on_pnt->p3_u) * k); + tmp->p3_v = on_pnt->p3_v + ((off_pnt->p3_v-on_pnt->p3_v) * k); + tmp->p3_flags |= PF_UV; + } + + if (on_pnt->p3_flags & PF_UV2) + { + tmp->p3_u2 = on_pnt->p3_u2 + ((off_pnt->p3_u2-on_pnt->p3_u2) * k); + tmp->p3_v2 = on_pnt->p3_v2 + ((off_pnt->p3_v2-on_pnt->p3_v2) * k); + tmp->p3_flags |= PF_UV2; + } + + if (on_pnt->p3_flags & PF_L) + { + tmp->p3_l = on_pnt->p3_l + ((off_pnt->p3_l-on_pnt->p3_l) * k); + tmp->p3_flags |= PF_L; + } + + if (on_pnt->p3_flags & PF_RGBA) + { + tmp->p3_r = on_pnt->p3_r + ((off_pnt->p3_r-on_pnt->p3_r) * k); + tmp->p3_g = on_pnt->p3_g + ((off_pnt->p3_g-on_pnt->p3_g) * k); + tmp->p3_b = on_pnt->p3_b + ((off_pnt->p3_b-on_pnt->p3_b) * k); + tmp->p3_a = on_pnt->p3_a + ((off_pnt->p3_a-on_pnt->p3_a) * k); + tmp->p3_flags |= PF_RGBA; + } + + g3_CodePoint(tmp); + return tmp; +} + +//clips an edge against one plane. +g3Point *ClipEdge( int plane_flag, g3Point *on_pnt, g3Point *off_pnt ) +{ + float a,b,k; + g3Point *tmp; + + //compute clipping value k = (xs-zs) / (xs-xe-zs+ze) + //use x or y as appropriate, and negate x/y value as appropriate + + if (plane_flag & CC_OFF_FAR) + { + return ClipFarEdge (on_pnt,off_pnt); + } + + if ((plane_flag & CC_OFF_CUSTOM) && Clip_custom) + { + return ClipCustomEdge (on_pnt,off_pnt); + } + + if (plane_flag & (CC_OFF_RIGHT | CC_OFF_LEFT)) + { + a = on_pnt->p3_x; + b = off_pnt->p3_x; + } + else + { + a = on_pnt->p3_y; + b = off_pnt->p3_y; + } + + if (plane_flag & (CC_OFF_LEFT | CC_OFF_BOT)) + { + a = -a; + b = -b; + } + + k = (a - on_pnt->p3_z) / ((a - on_pnt->p3_z) - b + off_pnt->p3_z); //(xs-zs) / (xs-zs-xe+ze) + + tmp = GetTempPoint(); + + tmp->p3_x = on_pnt->p3_x + ((off_pnt->p3_x-on_pnt->p3_x) * k); + tmp->p3_y = on_pnt->p3_y + ((off_pnt->p3_y-on_pnt->p3_y) * k); + + if (plane_flag & (CC_OFF_TOP|CC_OFF_BOT)) + { + tmp->p3_z = tmp->p3_y; + } + else + { + tmp->p3_z = tmp->p3_x; + } + + if (plane_flag & (CC_OFF_LEFT|CC_OFF_BOT)) + { + tmp->p3_z = -tmp->p3_z; + } + + if (on_pnt->p3_flags & PF_UV) + { + tmp->p3_u = on_pnt->p3_u + ((off_pnt->p3_u-on_pnt->p3_u) * k); + tmp->p3_v = on_pnt->p3_v + ((off_pnt->p3_v-on_pnt->p3_v) * k); + + tmp->p3_flags |= PF_UV; + } + + if (on_pnt->p3_flags & PF_UV2) + { + tmp->p3_u2 = on_pnt->p3_u2 + ((off_pnt->p3_u2-on_pnt->p3_u2) * k); + tmp->p3_v2 = on_pnt->p3_v2 + ((off_pnt->p3_v2-on_pnt->p3_v2) * k); + + tmp->p3_flags |= PF_UV2; + } + + if (on_pnt->p3_flags & PF_L) + { + tmp->p3_l = on_pnt->p3_l + ((off_pnt->p3_l-on_pnt->p3_l) * k); + tmp->p3_flags |= PF_L; + } + + if (on_pnt->p3_flags & PF_RGBA) + { + tmp->p3_r = on_pnt->p3_r + ((off_pnt->p3_r-on_pnt->p3_r) * k); + tmp->p3_g = on_pnt->p3_g + ((off_pnt->p3_g-on_pnt->p3_g) * k); + tmp->p3_b = on_pnt->p3_b + ((off_pnt->p3_b-on_pnt->p3_b) * k); + tmp->p3_a = on_pnt->p3_a + ((off_pnt->p3_a-on_pnt->p3_a) * k); + tmp->p3_flags |= PF_RGBA; + } + + g3_CodePoint(tmp); + + return tmp; +} + +//clips a line to the viewing pyramid. +void ClipLine(g3Point **p0,g3Point **p1,uint8_t codes_or) +{ + int plane_flag; + g3Point *old_p1; + + //might have these left over + //(*p0)->p3_flags &= ~(PF_UV|PF_L|PF_RGBA|PF_UV2); + //(*p1)->p3_flags &= ~(PF_UV|PF_L|PF_RGBA|PF_UV2); + + for (plane_flag=1;plane_flag<=32;plane_flag<<=1) + { + if (codes_or & plane_flag) + { + if ((*p0)->p3_codes & plane_flag) + { + //swap! + g3Point *t=*p0; + *p0=*p1; + *p1=t; + } + + old_p1 = *p1; + + *p1 = ClipEdge(plane_flag,*p0,*p1); + + codes_or = (*p0)->p3_codes | (*p1)->p3_codes; //get new codes + + if (old_p1->p3_flags & PF_TEMP_POINT) + { + FreeTempPoint(old_p1); + } + } + } +} + +int ClipPlane(int plane_flag,g3Point **src,g3Point **dest,int *nv,g3Codes *cc) +{ + int i,prev,next; + g3Point **save_dest=dest; + + //Init codes + cc->cc_and = 0xff; cc->cc_or = 0; + + for (i=0,prev=*nv-1,next=1;i<*nv;i++) + { + if (src[i]->p3_codes & plane_flag) + { + //cur point off? + if (! (src[prev]->p3_codes & plane_flag)) + { + //prev not off? + *dest = ClipEdge(plane_flag,src[prev],src[i]); + cc->cc_or |= (*dest)->p3_codes; + cc->cc_and &= (*dest)->p3_codes; + dest++; + } + + if (! (src[next]->p3_codes & plane_flag)) + { + *dest = ClipEdge(plane_flag,src[next],src[i]); + cc->cc_or |= (*dest)->p3_codes; + cc->cc_and &= (*dest)->p3_codes; + dest++; + } + + //see if must free discarded point + if (src[i]->p3_flags & PF_TEMP_POINT) + { + FreeTempPoint(src[i]); + } + } + else + { + //cur not off, copy to dest buffer + *dest++ = src[i]; + + cc->cc_or |= src[i]->p3_codes; + cc->cc_and &= src[i]->p3_codes; + } + + prev = i; + if (++next == *nv) + { + next = 0; + } + } + + return (dest-save_dest); +} + +//temp buffers for clipping +static g3Point *Vbuf0[MAX_POINTS_IN_POLY]; +static g3Point *Vbuf1[MAX_POINTS_IN_POLY]; + +//Clips a polygon +//Parameters: pointlist - pointer to a list of pointers to points +// nv - the number of points in the polygon +// cc - the clip codes for this polygon +//Returns: a pointer to a list of pointer of points in the clipped polygon +//NOTE: You MUST call g3_FreeTempPoints() when you're done with the clipped polygon +g3Point **g3_ClipPolygon(g3Point **pointlist,int *nv,g3Codes *cc) +{ + int plane_flag; + g3Point **dest; + + dest = Vbuf0; + + //& ASSERT(free_point_num == 0); //DAJ UTB CMO + if(free_point_num!=0){ + mprintf((1,"clipper: leftover temp point\n")); + free_point_num = 0; + Int3(); + } + + for (plane_flag=1;plane_flag<=32;plane_flag<<=1) + { + if (cc->cc_or & plane_flag) + { + + *nv = ClipPlane(plane_flag,pointlist,dest,nv,cc); + + if (cc->cc_and) //clipped away + return dest; + + pointlist = dest; + dest = (pointlist == Vbuf0) ? Vbuf1 : Vbuf0; + } + } + return pointlist; //we swapped after we copied +} + + +// sets the z distance of the far clipping plane +void g3_SetFarClipZ(float z) +{ + Far_clip_z = z; +} + +// Sets up a custom clipping plane - g3_StartFrame must be called before this is called +void g3_SetCustomClipPlane(uint8_t state,vector *pnt,vector *normal) +{ + Clip_custom=state; + if (state) + { + vector tempv; + vector norm=*normal; + + tempv = *pnt - View_position; + Clip_plane_point = tempv * View_matrix; + + Clip_plane=norm * Unscaled_matrix;//View_matrix; + vm_NormalizeVector(&Clip_plane); + } +} diff --git a/renderer/draw.cpp b/renderer/draw.cpp new file mode 100644 index 000000000..cd90f19d1 --- /dev/null +++ b/renderer/draw.cpp @@ -0,0 +1,514 @@ +/* +* Descent 3 +* Copyright (C) 2024 Parallax Software +* +* This program is free software: you can redistribute it and/or modify +* it under the terms of the GNU General Public License as published by +* the Free Software Foundation, either version 3 of the License, or +* (at your option) any later version. +* +* This program is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +* GNU General Public License for more details. +* +* You should have received a copy of the GNU General Public License +* along with this program. If not, see . +*/ +#include "RendererConfig.h" +#ifndef USE_SOFTWARE_TNL + +#include "3d.h" +#include "HardwareInternal.h" +#include "renderer.h" + +#define round(v) ( (int)( ((v) + 0.5f) ) ) + +//draws a line. takes two points. returns true if drew +void g3_DrawLine(ddgr_color color,g3Point *p0,g3Point *p1) +{ + uint8_t codes_or; + bool was_clipped=0; + + if (p0->p3_codes & p1->p3_codes) + return; + + codes_or = p0->p3_codes | p1->p3_codes; + + if (codes_or) + { + ClipLine(&p0,&p1,codes_or); + was_clipped = 1; + } + + if (!(p0->p3_flags & PF_PROJECTED)) + { + g3_ProjectPoint(p0); + } + + if (!(p1->p3_flags & PF_PROJECTED)) + { + g3_ProjectPoint(p1); + } + + rend_SetFlatColor (color); + rend_DrawLine( round(p0->p3_sx),round(p0->p3_sy),round(p1->p3_sx),round(p1->p3_sy)); + + //If was clipped, free temp points + if (was_clipped) + { + if (p0->p3_flags & PF_TEMP_POINT) + { + FreeTempPoint(p0); + } + + if (p1->p3_flags & PF_TEMP_POINT) + { + FreeTempPoint(p1); + } + + //Make sure all temp points have been freed + CheckTempPoints(); + } +} + +//draws a line based on the current setting of render states. takes two points. returns true if drew +void g3_DrawSpecialLine(g3Point *p0,g3Point *p1) +{ + uint8_t codes_or; + bool was_clipped=0; + + if (p0->p3_codes & p1->p3_codes) + return; + + codes_or = p0->p3_codes | p1->p3_codes; + + if (codes_or) + { + + ClipLine(&p0,&p1,codes_or); + + was_clipped = 1; + } + + if (!(p0->p3_flags & PF_PROJECTED)) + g3_ProjectPoint(p0); + + if (!(p1->p3_flags & PF_PROJECTED)) + g3_ProjectPoint(p1); + + rend_DrawSpecialLine (p0,p1); + + //If was clipped, free temp points + if (was_clipped) + { + if (p0->p3_flags & PF_TEMP_POINT) + FreeTempPoint(p0); + + if (p1->p3_flags & PF_TEMP_POINT) + FreeTempPoint(p1); + + //Make sure all temp points have been freed + CheckTempPoints(); + } +} + +//returns true if a plane is facing the viewer. takes the unrotated surface +//normal of the plane, and a point on it. The normal need not be normalized +bool g3_CheckNormalFacing(vector *v,vector *norm) +{ + vector tempv; + + tempv = View_position - *v; + + return ((tempv * *norm) > 0); +} + +bool DoFacingCheck(vector *norm,g3Point **vertlist,vector *p) +{ + if (norm) + { + //have normal + ASSERT(norm->x || norm->y || norm->z); + return g3_CheckNormalFacing(p,norm); + } + else + { + //normal not specified, so must compute + vector tempv; + //get three points (rotated) and compute normal + vm_GetPerp(&tempv,&vertlist[0]->p3_vec,&vertlist[1]->p3_vec,&vertlist[2]->p3_vec); + return ((tempv * vertlist[1]->p3_vec) < 0); + } +} + +//like g3_DrawPoly(), but checks to see if facing. If surface normal is +//NULL, this routine must compute it, which will be slow. It is better to +//pre-compute the normal, and pass it to this function. When the normal +//is passed, this function works like g3_CheckNormalFacing() plus +//g3_DrawPoly(). +void g3_CheckAndDrawPoly(int nv,g3Point **pointlist,int bm,vector *norm,vector *pnt) +{ + if (DoFacingCheck(norm,pointlist,pnt)) + g3_DrawPoly(nv,pointlist,bm); +} + +int Triangulate_test = 0; + +//draw a polygon +//Parameters: nv - the number of verts in the poly +// pointlist - a pointer to a list of pointers to points +// bm - the bitmap handle if texturing. ignored if flat shading +// Returns 0 if clipped away +int g3_DrawPoly(int nv,g3Point **pointlist,int bm,int map_type,g3Codes *clip_codes) +{ + int i; + g3Codes cc; + bool was_clipped=0; + + if( Triangulate_test && (nv > 3) ) + { + g3Point *tripoints[3]; + int sum=0; + + for (i=0;ip3_codes; + cc.cc_and &= c; + cc.cc_or |= c; + } + } + + //All points off screen? + if( cc.cc_and ) + return 0; + + //One or more point off screen, so clip + if( cc.cc_or ) + { + //Clip the polygon, getting pointer to new buffer + pointlist = g3_ClipPolygon( pointlist, &nv, &cc ); + + //Flag as clipped so temp points will be freed + was_clipped = 1; + + //Check for polygon clipped away, or clip otherwise failed + if( (nv==0) || (cc.cc_or&CC_BEHIND) || cc.cc_and ) + goto free_points; + } + + //Make list of 2d coords (& check for overflow) + for( i = 0; i < nv; ++i ) + { + g3Point *p = pointlist[i]; + + //Project if needed + if( !(p->p3_flags&PF_PROJECTED) ) + { + g3_ProjectPoint(p); + } + } + + //Draw! + rend_DrawPolygon3D( bm, pointlist, nv, map_type ); + +free_points:; + + //If was clipped, free temp points + if( was_clipped ) + { + g3_FreeTempPoints( pointlist, nv ); + } + + return 1; +} + +//draw a sortof sphere - i.e., the 2d radius is proportional to the 3d +//radius, but not to the distance from the eye +void g3_DrawSphere(ddgr_color color,g3Point *pnt,float rad) +{ + if (! (pnt->p3_codes & CC_BEHIND)) + { + if (! (pnt->p3_flags & PF_PROJECTED)) + g3_ProjectPoint(pnt); + + rend_FillCircle(color, pnt->p3_sx, pnt->p3_sy,(rad * Matrix_scale.x * Window_w2 / pnt->p3_z)); + } +} + +//draws a bitmap with the specified 3d width & height +// If offsets are not -1, then the blitter draws not from the upper left hand +// corner of the bitmap, but from size*offsetx,size*offsety +// See Jason for explaination +void g3_DrawBitmap(vector *pos,float width,float height,int bm,int color) +{ + g3Point pnt; + float w, h; + int dx, dy, dw, dh; + float u0 = 0.0, u1 = 1.0; + float v0 = 0.0, v1 = 1.0; + + if (g3_RotatePoint(&pnt, pos) & CC_BEHIND) + return; + + if (pnt.p3_codes & CC_OFF_FAR) + return; + + + g3_ProjectPoint(&pnt); + + // Calculate the 4 corners of this bitmap + + w = (width * Window_w2) / pnt.p3_z * Matrix_scale.x; + h = (height * Window_h2) / pnt.p3_z * Matrix_scale.y; + + dw = w; //should round, right? + dh = h; + + if (dw == 0 && dh == 0) + return; + + dx = pnt.p3_sx - dw; + dy = pnt.p3_sy - dh; + + // Now clip to make sure we're on screen + + int x1 = dx; + int y1 = dy; + int x2 = dx + dw * 2; + int y2 = dy + dh * 2; + + if (x2 - x1 == 0) + return; + if (y2 - y1 == 0) + return; + + float xstep = (u1 - u0) / (x2 - x1); + float ystep = (v1 - v0) / (y2 - y1); + + // Clip x dimension + if (x1 < 0) + { + u0 = (xstep * (-x1)); + x1 = 0; + } + else if (x1 > (Window_width - 1)) + return; + + if (x2 > (Window_width - 1)) + { + u1 -= (xstep * (x2 - (Window_width - 1))); + x2 = Window_width - 1; + } + else if (x2 < 0) + return; + + // Clip y dimension + if (y1 < 0) + { + v0 = (ystep * (-y1)); + y1 = 0; + } + else if (y1 > (Window_height - 1)) + return; + + if (y2 > (Window_height - 1)) + { + v1 -= (ystep * (y2 - (Window_height - 1))); + y2 = (Window_height - 1); + } + else if (y2 < 0) + return; + + // And draw!! + rend_DrawScaledBitmapWithZ(x1, y1, x2, y2, bm, u0, v0, u1, v1, pnt.p3_z, color); +} + +// Draws a bitmap that has been rotated about its center. Angle of rotation is passed as 'rot_angle' +void g3_DrawRotatedBitmap(vector *pos,angle rot_angle,float width,float height,int bm,int color) +{ + g3Point pnt, rot_points[8], * pntlist[8]; + vector rot_vectors[4]; + matrix rot_matrix; + float w, h; + int i; + + if (g3_RotatePoint(&pnt, pos) & CC_BEHIND) + return; + + if (pnt.p3_codes & CC_OFF_FAR) + return; + + vm_AnglesToMatrix(&rot_matrix, 0, 0, rot_angle); + + rot_matrix.rvec *= Matrix_scale.x; + rot_matrix.uvec *= Matrix_scale.y; + + + w = width; + h = height; + + rot_vectors[0].x = -w; + rot_vectors[0].y = h; + + rot_vectors[1].x = w; + rot_vectors[1].y = h; + + rot_vectors[2].x = w; + rot_vectors[2].y = -h; + + rot_vectors[3].x = -w; + rot_vectors[3].y = -h; + + for (i = 0; i < 4; i++) + { + rot_vectors[i].z = 0; + vm_MatrixMulVector(&rot_points[i].p3_vec, &rot_vectors[i], &rot_matrix); + + rot_points[i].p3_flags = PF_UV | PF_RGBA; + rot_points[i].p3_l = 1.0; + rot_points[i].p3_vec += pnt.p3_vec; + + g3_CodePoint(&rot_points[i]); + pntlist[i] = &rot_points[i]; + } + + rot_points[0].p3_u = 0; + rot_points[0].p3_v = 0; + + rot_points[1].p3_u = 1; + rot_points[1].p3_v = 0; + + rot_points[2].p3_u = 1; + rot_points[2].p3_v = 1; + + rot_points[3].p3_u = 0; + rot_points[3].p3_v = 1; + + // And draw!! + rend_SetTextureType(TT_LINEAR); + + if (color != -1) + { + rend_SetLighting(LS_FLAT_GOURAUD); + rend_SetFlatColor(color); + } + + g3_DrawPoly(4, pntlist, bm); +} + +// Draws a bitmap on a specific plane. Also does rotation. Angle of rotation is passed as 'rot_angle' +void g3_DrawPlanarRotatedBitmap(vector *pos,vector *norm,angle rot_angle,float width,float height,int bm) +{ + matrix rot_matrix; + vm_VectorToMatrix( &rot_matrix, norm, NULL, NULL ); + vm_TransposeMatrix( &rot_matrix ); + + matrix twist_matrix; + vm_AnglesToMatrix( &twist_matrix, 0, 0, rot_angle ); + + float w = width; + float h = height; + + vector rot_vectors[4]; + rot_vectors[0] = (twist_matrix.rvec * -w); + rot_vectors[0] += (twist_matrix.uvec * h); + + rot_vectors[1] = (twist_matrix.rvec * w); + rot_vectors[1] += (twist_matrix.uvec * h); + + rot_vectors[2] = (twist_matrix.rvec * w); + rot_vectors[2] -= (twist_matrix.uvec * h); + + rot_vectors[3] = (twist_matrix.rvec * -w); + rot_vectors[3] -= (twist_matrix.uvec * h); + + int i; + for( i = 0; i < 4; ++i ) + { + vector temp_vec = rot_vectors[i]; + vm_MatrixMulVector( &rot_vectors[i], &temp_vec, &rot_matrix ); + } + + g3Point rot_points[8],*pntlist[8]; + for( i = 0; i < 4; ++i ) + { + rot_vectors[i] += *pos; + + g3_RotatePoint( &rot_points[i], &rot_vectors[i] ); + rot_points[i].p3_flags |= PF_UV|PF_L; + rot_points[i].p3_l = 1.0f; + + pntlist[i] = &rot_points[i]; + } + + rot_points[0].p3_u = 0.0f; + rot_points[0].p3_v = 0.0f; + + rot_points[1].p3_u = 1.0f; + rot_points[1].p3_v = 0.0f; + + rot_points[2].p3_u = 1.0f; + rot_points[2].p3_v = 1.0f; + + rot_points[3].p3_u = 0.0f; + rot_points[3].p3_v = 1.0f; + + // And draw!! + rend_SetTextureType( TT_LINEAR ); + g3_DrawPoly( 4, pntlist, bm ); +} + + +//Draw a wireframe box aligned with the screen. Used for the editor. +//Parameters: color - the color to draw the lines +// pnt - the center point +// rad - specifies the width/2 & height/2 of the box +void g3_DrawBox(ddgr_color color,g3Point *pnt,float rad) +{ + if (! (pnt->p3_codes & CC_BEHIND)) + { + if (! (pnt->p3_flags & PF_PROJECTED)) + g3_ProjectPoint(pnt); + + float w,h; + + w = rad * Matrix_scale.x * Window_w2 / pnt->p3_z; + h = rad * Matrix_scale.y * Window_h2 / pnt->p3_z; + + rend_DrawLine(round(pnt->p3_sx-w),round(pnt->p3_sy-h),round(pnt->p3_sx+w),round(pnt->p3_sy-h)); + rend_DrawLine(round(pnt->p3_sx+w),round(pnt->p3_sy-h),round(pnt->p3_sx+w),round(pnt->p3_sy+h)); + rend_DrawLine(round(pnt->p3_sx+w),round(pnt->p3_sy+h),round(pnt->p3_sx-w),round(pnt->p3_sy+h)); + rend_DrawLine(round(pnt->p3_sx-w),round(pnt->p3_sy+h),round(pnt->p3_sx-w),round(pnt->p3_sy-h)); + } +} + +// Sets the triangulation test to on or off +void g3_SetTriangulationTest (int state) +{ + Triangulate_test = state; +} + +#endif diff --git a/renderer/gl.c b/renderer/gl.c new file mode 100644 index 000000000..c5f5b2bef --- /dev/null +++ b/renderer/gl.c @@ -0,0 +1,979 @@ +/** + * SPDX-License-Identifier: (WTFPL OR CC0-1.0) AND Apache-2.0 + */ +#include +#include +#include +#include + +#ifndef GLAD_IMPL_UTIL_C_ +#define GLAD_IMPL_UTIL_C_ + +#ifdef _MSC_VER +#define GLAD_IMPL_UTIL_SSCANF sscanf_s +#else +#define GLAD_IMPL_UTIL_SSCANF sscanf +#endif + +#endif /* GLAD_IMPL_UTIL_C_ */ + +#ifdef __cplusplus +extern "C" { +#endif + + + +int GLAD_GL_VERSION_1_0 = 0; +int GLAD_GL_VERSION_1_1 = 0; +int GLAD_GL_VERSION_1_2 = 0; +int GLAD_GL_VERSION_1_3 = 0; +int GLAD_GL_VERSION_1_4 = 0; +int GLAD_GL_VERSION_1_5 = 0; +int GLAD_GL_VERSION_2_0 = 0; +int GLAD_GL_VERSION_2_1 = 0; +int GLAD_GL_VERSION_3_0 = 0; +int GLAD_GL_VERSION_3_1 = 0; +int GLAD_GL_VERSION_3_2 = 0; +int GLAD_GL_VERSION_3_3 = 0; +int GLAD_GL_KHR_debug = 0; + + + +PFNGLACTIVETEXTUREPROC glad_glActiveTexture = NULL; +PFNGLATTACHSHADERPROC glad_glAttachShader = NULL; +PFNGLBEGINCONDITIONALRENDERPROC glad_glBeginConditionalRender = NULL; +PFNGLBEGINQUERYPROC glad_glBeginQuery = NULL; +PFNGLBEGINTRANSFORMFEEDBACKPROC glad_glBeginTransformFeedback = NULL; +PFNGLBINDATTRIBLOCATIONPROC glad_glBindAttribLocation = NULL; +PFNGLBINDBUFFERPROC glad_glBindBuffer = NULL; +PFNGLBINDBUFFERBASEPROC glad_glBindBufferBase = NULL; +PFNGLBINDBUFFERRANGEPROC glad_glBindBufferRange = NULL; +PFNGLBINDFRAGDATALOCATIONPROC glad_glBindFragDataLocation = NULL; +PFNGLBINDFRAGDATALOCATIONINDEXEDPROC glad_glBindFragDataLocationIndexed = NULL; +PFNGLBINDFRAMEBUFFERPROC glad_glBindFramebuffer = NULL; +PFNGLBINDRENDERBUFFERPROC glad_glBindRenderbuffer = NULL; +PFNGLBINDSAMPLERPROC glad_glBindSampler = NULL; +PFNGLBINDTEXTUREPROC glad_glBindTexture = NULL; +PFNGLBINDVERTEXARRAYPROC glad_glBindVertexArray = NULL; +PFNGLBLENDCOLORPROC glad_glBlendColor = NULL; +PFNGLBLENDEQUATIONPROC glad_glBlendEquation = NULL; +PFNGLBLENDEQUATIONSEPARATEPROC glad_glBlendEquationSeparate = NULL; +PFNGLBLENDFUNCPROC glad_glBlendFunc = NULL; +PFNGLBLENDFUNCSEPARATEPROC glad_glBlendFuncSeparate = NULL; +PFNGLBLITFRAMEBUFFERPROC glad_glBlitFramebuffer = NULL; +PFNGLBUFFERDATAPROC glad_glBufferData = NULL; +PFNGLBUFFERSUBDATAPROC glad_glBufferSubData = NULL; +PFNGLCHECKFRAMEBUFFERSTATUSPROC glad_glCheckFramebufferStatus = NULL; +PFNGLCLAMPCOLORPROC glad_glClampColor = NULL; +PFNGLCLEARPROC glad_glClear = NULL; +PFNGLCLEARBUFFERFIPROC glad_glClearBufferfi = NULL; +PFNGLCLEARBUFFERFVPROC glad_glClearBufferfv = NULL; +PFNGLCLEARBUFFERIVPROC glad_glClearBufferiv = NULL; +PFNGLCLEARBUFFERUIVPROC glad_glClearBufferuiv = NULL; +PFNGLCLEARCOLORPROC glad_glClearColor = NULL; +PFNGLCLEARDEPTHPROC glad_glClearDepth = NULL; +PFNGLCLEARSTENCILPROC glad_glClearStencil = NULL; +PFNGLCLIENTWAITSYNCPROC glad_glClientWaitSync = NULL; +PFNGLCOLORMASKPROC glad_glColorMask = NULL; +PFNGLCOLORMASKIPROC glad_glColorMaski = NULL; +PFNGLCOMPILESHADERPROC glad_glCompileShader = NULL; +PFNGLCOMPRESSEDTEXIMAGE1DPROC glad_glCompressedTexImage1D = NULL; +PFNGLCOMPRESSEDTEXIMAGE2DPROC glad_glCompressedTexImage2D = NULL; +PFNGLCOMPRESSEDTEXIMAGE3DPROC glad_glCompressedTexImage3D = NULL; +PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC glad_glCompressedTexSubImage1D = NULL; +PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC glad_glCompressedTexSubImage2D = NULL; +PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC glad_glCompressedTexSubImage3D = NULL; +PFNGLCOPYBUFFERSUBDATAPROC glad_glCopyBufferSubData = NULL; +PFNGLCOPYTEXIMAGE1DPROC glad_glCopyTexImage1D = NULL; +PFNGLCOPYTEXIMAGE2DPROC glad_glCopyTexImage2D = NULL; +PFNGLCOPYTEXSUBIMAGE1DPROC glad_glCopyTexSubImage1D = NULL; +PFNGLCOPYTEXSUBIMAGE2DPROC glad_glCopyTexSubImage2D = NULL; +PFNGLCOPYTEXSUBIMAGE3DPROC glad_glCopyTexSubImage3D = NULL; +PFNGLCREATEPROGRAMPROC glad_glCreateProgram = NULL; +PFNGLCREATESHADERPROC glad_glCreateShader = NULL; +PFNGLCULLFACEPROC glad_glCullFace = NULL; +PFNGLDEBUGMESSAGECALLBACKPROC glad_glDebugMessageCallback = NULL; +PFNGLDEBUGMESSAGECONTROLPROC glad_glDebugMessageControl = NULL; +PFNGLDEBUGMESSAGEINSERTPROC glad_glDebugMessageInsert = NULL; +PFNGLDELETEBUFFERSPROC glad_glDeleteBuffers = NULL; +PFNGLDELETEFRAMEBUFFERSPROC glad_glDeleteFramebuffers = NULL; +PFNGLDELETEPROGRAMPROC glad_glDeleteProgram = NULL; +PFNGLDELETEQUERIESPROC glad_glDeleteQueries = NULL; +PFNGLDELETERENDERBUFFERSPROC glad_glDeleteRenderbuffers = NULL; +PFNGLDELETESAMPLERSPROC glad_glDeleteSamplers = NULL; +PFNGLDELETESHADERPROC glad_glDeleteShader = NULL; +PFNGLDELETESYNCPROC glad_glDeleteSync = NULL; +PFNGLDELETETEXTURESPROC glad_glDeleteTextures = NULL; +PFNGLDELETEVERTEXARRAYSPROC glad_glDeleteVertexArrays = NULL; +PFNGLDEPTHFUNCPROC glad_glDepthFunc = NULL; +PFNGLDEPTHMASKPROC glad_glDepthMask = NULL; +PFNGLDEPTHRANGEPROC glad_glDepthRange = NULL; +PFNGLDETACHSHADERPROC glad_glDetachShader = NULL; +PFNGLDISABLEPROC glad_glDisable = NULL; +PFNGLDISABLEVERTEXATTRIBARRAYPROC glad_glDisableVertexAttribArray = NULL; +PFNGLDISABLEIPROC glad_glDisablei = NULL; +PFNGLDRAWARRAYSPROC glad_glDrawArrays = NULL; +PFNGLDRAWARRAYSINSTANCEDPROC glad_glDrawArraysInstanced = NULL; +PFNGLDRAWBUFFERPROC glad_glDrawBuffer = NULL; +PFNGLDRAWBUFFERSPROC glad_glDrawBuffers = NULL; +PFNGLDRAWELEMENTSPROC glad_glDrawElements = NULL; +PFNGLDRAWELEMENTSBASEVERTEXPROC glad_glDrawElementsBaseVertex = NULL; +PFNGLDRAWELEMENTSINSTANCEDPROC glad_glDrawElementsInstanced = NULL; +PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC glad_glDrawElementsInstancedBaseVertex = NULL; +PFNGLDRAWRANGEELEMENTSPROC glad_glDrawRangeElements = NULL; +PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC glad_glDrawRangeElementsBaseVertex = NULL; +PFNGLENABLEPROC glad_glEnable = NULL; +PFNGLENABLEVERTEXATTRIBARRAYPROC glad_glEnableVertexAttribArray = NULL; +PFNGLENABLEIPROC glad_glEnablei = NULL; +PFNGLENDCONDITIONALRENDERPROC glad_glEndConditionalRender = NULL; +PFNGLENDQUERYPROC glad_glEndQuery = NULL; +PFNGLENDTRANSFORMFEEDBACKPROC glad_glEndTransformFeedback = NULL; +PFNGLFENCESYNCPROC glad_glFenceSync = NULL; +PFNGLFINISHPROC glad_glFinish = NULL; +PFNGLFLUSHPROC glad_glFlush = NULL; +PFNGLFLUSHMAPPEDBUFFERRANGEPROC glad_glFlushMappedBufferRange = NULL; +PFNGLFRAMEBUFFERRENDERBUFFERPROC glad_glFramebufferRenderbuffer = NULL; +PFNGLFRAMEBUFFERTEXTUREPROC glad_glFramebufferTexture = NULL; +PFNGLFRAMEBUFFERTEXTURE1DPROC glad_glFramebufferTexture1D = NULL; +PFNGLFRAMEBUFFERTEXTURE2DPROC glad_glFramebufferTexture2D = NULL; +PFNGLFRAMEBUFFERTEXTURE3DPROC glad_glFramebufferTexture3D = NULL; +PFNGLFRAMEBUFFERTEXTURELAYERPROC glad_glFramebufferTextureLayer = NULL; +PFNGLFRONTFACEPROC glad_glFrontFace = NULL; +PFNGLGENBUFFERSPROC glad_glGenBuffers = NULL; +PFNGLGENFRAMEBUFFERSPROC glad_glGenFramebuffers = NULL; +PFNGLGENQUERIESPROC glad_glGenQueries = NULL; +PFNGLGENRENDERBUFFERSPROC glad_glGenRenderbuffers = NULL; +PFNGLGENSAMPLERSPROC glad_glGenSamplers = NULL; +PFNGLGENTEXTURESPROC glad_glGenTextures = NULL; +PFNGLGENVERTEXARRAYSPROC glad_glGenVertexArrays = NULL; +PFNGLGENERATEMIPMAPPROC glad_glGenerateMipmap = NULL; +PFNGLGETACTIVEATTRIBPROC glad_glGetActiveAttrib = NULL; +PFNGLGETACTIVEUNIFORMPROC glad_glGetActiveUniform = NULL; +PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC glad_glGetActiveUniformBlockName = NULL; +PFNGLGETACTIVEUNIFORMBLOCKIVPROC glad_glGetActiveUniformBlockiv = NULL; +PFNGLGETACTIVEUNIFORMNAMEPROC glad_glGetActiveUniformName = NULL; +PFNGLGETACTIVEUNIFORMSIVPROC glad_glGetActiveUniformsiv = NULL; +PFNGLGETATTACHEDSHADERSPROC glad_glGetAttachedShaders = NULL; +PFNGLGETATTRIBLOCATIONPROC glad_glGetAttribLocation = NULL; +PFNGLGETBOOLEANI_VPROC glad_glGetBooleani_v = NULL; +PFNGLGETBOOLEANVPROC glad_glGetBooleanv = NULL; +PFNGLGETBUFFERPARAMETERI64VPROC glad_glGetBufferParameteri64v = NULL; +PFNGLGETBUFFERPARAMETERIVPROC glad_glGetBufferParameteriv = NULL; +PFNGLGETBUFFERPOINTERVPROC glad_glGetBufferPointerv = NULL; +PFNGLGETBUFFERSUBDATAPROC glad_glGetBufferSubData = NULL; +PFNGLGETCOMPRESSEDTEXIMAGEPROC glad_glGetCompressedTexImage = NULL; +PFNGLGETDEBUGMESSAGELOGPROC glad_glGetDebugMessageLog = NULL; +PFNGLGETDOUBLEVPROC glad_glGetDoublev = NULL; +PFNGLGETERRORPROC glad_glGetError = NULL; +PFNGLGETFLOATVPROC glad_glGetFloatv = NULL; +PFNGLGETFRAGDATAINDEXPROC glad_glGetFragDataIndex = NULL; +PFNGLGETFRAGDATALOCATIONPROC glad_glGetFragDataLocation = NULL; +PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC glad_glGetFramebufferAttachmentParameteriv = NULL; +PFNGLGETINTEGER64I_VPROC glad_glGetInteger64i_v = NULL; +PFNGLGETINTEGER64VPROC glad_glGetInteger64v = NULL; +PFNGLGETINTEGERI_VPROC glad_glGetIntegeri_v = NULL; +PFNGLGETINTEGERVPROC glad_glGetIntegerv = NULL; +PFNGLGETMULTISAMPLEFVPROC glad_glGetMultisamplefv = NULL; +PFNGLGETOBJECTLABELPROC glad_glGetObjectLabel = NULL; +PFNGLGETOBJECTPTRLABELPROC glad_glGetObjectPtrLabel = NULL; +PFNGLGETPOINTERVPROC glad_glGetPointerv = NULL; +PFNGLGETPROGRAMINFOLOGPROC glad_glGetProgramInfoLog = NULL; +PFNGLGETPROGRAMIVPROC glad_glGetProgramiv = NULL; +PFNGLGETQUERYOBJECTI64VPROC glad_glGetQueryObjecti64v = NULL; +PFNGLGETQUERYOBJECTIVPROC glad_glGetQueryObjectiv = NULL; +PFNGLGETQUERYOBJECTUI64VPROC glad_glGetQueryObjectui64v = NULL; +PFNGLGETQUERYOBJECTUIVPROC glad_glGetQueryObjectuiv = NULL; +PFNGLGETQUERYIVPROC glad_glGetQueryiv = NULL; +PFNGLGETRENDERBUFFERPARAMETERIVPROC glad_glGetRenderbufferParameteriv = NULL; +PFNGLGETSAMPLERPARAMETERIIVPROC glad_glGetSamplerParameterIiv = NULL; +PFNGLGETSAMPLERPARAMETERIUIVPROC glad_glGetSamplerParameterIuiv = NULL; +PFNGLGETSAMPLERPARAMETERFVPROC glad_glGetSamplerParameterfv = NULL; +PFNGLGETSAMPLERPARAMETERIVPROC glad_glGetSamplerParameteriv = NULL; +PFNGLGETSHADERINFOLOGPROC glad_glGetShaderInfoLog = NULL; +PFNGLGETSHADERSOURCEPROC glad_glGetShaderSource = NULL; +PFNGLGETSHADERIVPROC glad_glGetShaderiv = NULL; +PFNGLGETSTRINGPROC glad_glGetString = NULL; +PFNGLGETSTRINGIPROC glad_glGetStringi = NULL; +PFNGLGETSYNCIVPROC glad_glGetSynciv = NULL; +PFNGLGETTEXIMAGEPROC glad_glGetTexImage = NULL; +PFNGLGETTEXLEVELPARAMETERFVPROC glad_glGetTexLevelParameterfv = NULL; +PFNGLGETTEXLEVELPARAMETERIVPROC glad_glGetTexLevelParameteriv = NULL; +PFNGLGETTEXPARAMETERIIVPROC glad_glGetTexParameterIiv = NULL; +PFNGLGETTEXPARAMETERIUIVPROC glad_glGetTexParameterIuiv = NULL; +PFNGLGETTEXPARAMETERFVPROC glad_glGetTexParameterfv = NULL; +PFNGLGETTEXPARAMETERIVPROC glad_glGetTexParameteriv = NULL; +PFNGLGETTRANSFORMFEEDBACKVARYINGPROC glad_glGetTransformFeedbackVarying = NULL; +PFNGLGETUNIFORMBLOCKINDEXPROC glad_glGetUniformBlockIndex = NULL; +PFNGLGETUNIFORMINDICESPROC glad_glGetUniformIndices = NULL; +PFNGLGETUNIFORMLOCATIONPROC glad_glGetUniformLocation = NULL; +PFNGLGETUNIFORMFVPROC glad_glGetUniformfv = NULL; +PFNGLGETUNIFORMIVPROC glad_glGetUniformiv = NULL; +PFNGLGETUNIFORMUIVPROC glad_glGetUniformuiv = NULL; +PFNGLGETVERTEXATTRIBIIVPROC glad_glGetVertexAttribIiv = NULL; +PFNGLGETVERTEXATTRIBIUIVPROC glad_glGetVertexAttribIuiv = NULL; +PFNGLGETVERTEXATTRIBPOINTERVPROC glad_glGetVertexAttribPointerv = NULL; +PFNGLGETVERTEXATTRIBDVPROC glad_glGetVertexAttribdv = NULL; +PFNGLGETVERTEXATTRIBFVPROC glad_glGetVertexAttribfv = NULL; +PFNGLGETVERTEXATTRIBIVPROC glad_glGetVertexAttribiv = NULL; +PFNGLHINTPROC glad_glHint = NULL; +PFNGLISBUFFERPROC glad_glIsBuffer = NULL; +PFNGLISENABLEDPROC glad_glIsEnabled = NULL; +PFNGLISENABLEDIPROC glad_glIsEnabledi = NULL; +PFNGLISFRAMEBUFFERPROC glad_glIsFramebuffer = NULL; +PFNGLISPROGRAMPROC glad_glIsProgram = NULL; +PFNGLISQUERYPROC glad_glIsQuery = NULL; +PFNGLISRENDERBUFFERPROC glad_glIsRenderbuffer = NULL; +PFNGLISSAMPLERPROC glad_glIsSampler = NULL; +PFNGLISSHADERPROC glad_glIsShader = NULL; +PFNGLISSYNCPROC glad_glIsSync = NULL; +PFNGLISTEXTUREPROC glad_glIsTexture = NULL; +PFNGLISVERTEXARRAYPROC glad_glIsVertexArray = NULL; +PFNGLLINEWIDTHPROC glad_glLineWidth = NULL; +PFNGLLINKPROGRAMPROC glad_glLinkProgram = NULL; +PFNGLLOGICOPPROC glad_glLogicOp = NULL; +PFNGLMAPBUFFERPROC glad_glMapBuffer = NULL; +PFNGLMAPBUFFERRANGEPROC glad_glMapBufferRange = NULL; +PFNGLMULTIDRAWARRAYSPROC glad_glMultiDrawArrays = NULL; +PFNGLMULTIDRAWELEMENTSPROC glad_glMultiDrawElements = NULL; +PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC glad_glMultiDrawElementsBaseVertex = NULL; +PFNGLOBJECTLABELPROC glad_glObjectLabel = NULL; +PFNGLOBJECTPTRLABELPROC glad_glObjectPtrLabel = NULL; +PFNGLPIXELSTOREFPROC glad_glPixelStoref = NULL; +PFNGLPIXELSTOREIPROC glad_glPixelStorei = NULL; +PFNGLPOINTPARAMETERFPROC glad_glPointParameterf = NULL; +PFNGLPOINTPARAMETERFVPROC glad_glPointParameterfv = NULL; +PFNGLPOINTPARAMETERIPROC glad_glPointParameteri = NULL; +PFNGLPOINTPARAMETERIVPROC glad_glPointParameteriv = NULL; +PFNGLPOINTSIZEPROC glad_glPointSize = NULL; +PFNGLPOLYGONMODEPROC glad_glPolygonMode = NULL; +PFNGLPOLYGONOFFSETPROC glad_glPolygonOffset = NULL; +PFNGLPOPDEBUGGROUPPROC glad_glPopDebugGroup = NULL; +PFNGLPRIMITIVERESTARTINDEXPROC glad_glPrimitiveRestartIndex = NULL; +PFNGLPROVOKINGVERTEXPROC glad_glProvokingVertex = NULL; +PFNGLPUSHDEBUGGROUPPROC glad_glPushDebugGroup = NULL; +PFNGLQUERYCOUNTERPROC glad_glQueryCounter = NULL; +PFNGLREADBUFFERPROC glad_glReadBuffer = NULL; +PFNGLREADPIXELSPROC glad_glReadPixels = NULL; +PFNGLRENDERBUFFERSTORAGEPROC glad_glRenderbufferStorage = NULL; +PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC glad_glRenderbufferStorageMultisample = NULL; +PFNGLSAMPLECOVERAGEPROC glad_glSampleCoverage = NULL; +PFNGLSAMPLEMASKIPROC glad_glSampleMaski = NULL; +PFNGLSAMPLERPARAMETERIIVPROC glad_glSamplerParameterIiv = NULL; +PFNGLSAMPLERPARAMETERIUIVPROC glad_glSamplerParameterIuiv = NULL; +PFNGLSAMPLERPARAMETERFPROC glad_glSamplerParameterf = NULL; +PFNGLSAMPLERPARAMETERFVPROC glad_glSamplerParameterfv = NULL; +PFNGLSAMPLERPARAMETERIPROC glad_glSamplerParameteri = NULL; +PFNGLSAMPLERPARAMETERIVPROC glad_glSamplerParameteriv = NULL; +PFNGLSCISSORPROC glad_glScissor = NULL; +PFNGLSHADERSOURCEPROC glad_glShaderSource = NULL; +PFNGLSTENCILFUNCPROC glad_glStencilFunc = NULL; +PFNGLSTENCILFUNCSEPARATEPROC glad_glStencilFuncSeparate = NULL; +PFNGLSTENCILMASKPROC glad_glStencilMask = NULL; +PFNGLSTENCILMASKSEPARATEPROC glad_glStencilMaskSeparate = NULL; +PFNGLSTENCILOPPROC glad_glStencilOp = NULL; +PFNGLSTENCILOPSEPARATEPROC glad_glStencilOpSeparate = NULL; +PFNGLTEXBUFFERPROC glad_glTexBuffer = NULL; +PFNGLTEXIMAGE1DPROC glad_glTexImage1D = NULL; +PFNGLTEXIMAGE2DPROC glad_glTexImage2D = NULL; +PFNGLTEXIMAGE2DMULTISAMPLEPROC glad_glTexImage2DMultisample = NULL; +PFNGLTEXIMAGE3DPROC glad_glTexImage3D = NULL; +PFNGLTEXIMAGE3DMULTISAMPLEPROC glad_glTexImage3DMultisample = NULL; +PFNGLTEXPARAMETERIIVPROC glad_glTexParameterIiv = NULL; +PFNGLTEXPARAMETERIUIVPROC glad_glTexParameterIuiv = NULL; +PFNGLTEXPARAMETERFPROC glad_glTexParameterf = NULL; +PFNGLTEXPARAMETERFVPROC glad_glTexParameterfv = NULL; +PFNGLTEXPARAMETERIPROC glad_glTexParameteri = NULL; +PFNGLTEXPARAMETERIVPROC glad_glTexParameteriv = NULL; +PFNGLTEXSUBIMAGE1DPROC glad_glTexSubImage1D = NULL; +PFNGLTEXSUBIMAGE2DPROC glad_glTexSubImage2D = NULL; +PFNGLTEXSUBIMAGE3DPROC glad_glTexSubImage3D = NULL; +PFNGLTRANSFORMFEEDBACKVARYINGSPROC glad_glTransformFeedbackVaryings = NULL; +PFNGLUNIFORM1FPROC glad_glUniform1f = NULL; +PFNGLUNIFORM1FVPROC glad_glUniform1fv = NULL; +PFNGLUNIFORM1IPROC glad_glUniform1i = NULL; +PFNGLUNIFORM1IVPROC glad_glUniform1iv = NULL; +PFNGLUNIFORM1UIPROC glad_glUniform1ui = NULL; +PFNGLUNIFORM1UIVPROC glad_glUniform1uiv = NULL; +PFNGLUNIFORM2FPROC glad_glUniform2f = NULL; +PFNGLUNIFORM2FVPROC glad_glUniform2fv = NULL; +PFNGLUNIFORM2IPROC glad_glUniform2i = NULL; +PFNGLUNIFORM2IVPROC glad_glUniform2iv = NULL; +PFNGLUNIFORM2UIPROC glad_glUniform2ui = NULL; +PFNGLUNIFORM2UIVPROC glad_glUniform2uiv = NULL; +PFNGLUNIFORM3FPROC glad_glUniform3f = NULL; +PFNGLUNIFORM3FVPROC glad_glUniform3fv = NULL; +PFNGLUNIFORM3IPROC glad_glUniform3i = NULL; +PFNGLUNIFORM3IVPROC glad_glUniform3iv = NULL; +PFNGLUNIFORM3UIPROC glad_glUniform3ui = NULL; +PFNGLUNIFORM3UIVPROC glad_glUniform3uiv = NULL; +PFNGLUNIFORM4FPROC glad_glUniform4f = NULL; +PFNGLUNIFORM4FVPROC glad_glUniform4fv = NULL; +PFNGLUNIFORM4IPROC glad_glUniform4i = NULL; +PFNGLUNIFORM4IVPROC glad_glUniform4iv = NULL; +PFNGLUNIFORM4UIPROC glad_glUniform4ui = NULL; +PFNGLUNIFORM4UIVPROC glad_glUniform4uiv = NULL; +PFNGLUNIFORMBLOCKBINDINGPROC glad_glUniformBlockBinding = NULL; +PFNGLUNIFORMMATRIX2FVPROC glad_glUniformMatrix2fv = NULL; +PFNGLUNIFORMMATRIX2X3FVPROC glad_glUniformMatrix2x3fv = NULL; +PFNGLUNIFORMMATRIX2X4FVPROC glad_glUniformMatrix2x4fv = NULL; +PFNGLUNIFORMMATRIX3FVPROC glad_glUniformMatrix3fv = NULL; +PFNGLUNIFORMMATRIX3X2FVPROC glad_glUniformMatrix3x2fv = NULL; +PFNGLUNIFORMMATRIX3X4FVPROC glad_glUniformMatrix3x4fv = NULL; +PFNGLUNIFORMMATRIX4FVPROC glad_glUniformMatrix4fv = NULL; +PFNGLUNIFORMMATRIX4X2FVPROC glad_glUniformMatrix4x2fv = NULL; +PFNGLUNIFORMMATRIX4X3FVPROC glad_glUniformMatrix4x3fv = NULL; +PFNGLUNMAPBUFFERPROC glad_glUnmapBuffer = NULL; +PFNGLUSEPROGRAMPROC glad_glUseProgram = NULL; +PFNGLVALIDATEPROGRAMPROC glad_glValidateProgram = NULL; +PFNGLVERTEXATTRIB1DPROC glad_glVertexAttrib1d = NULL; +PFNGLVERTEXATTRIB1DVPROC glad_glVertexAttrib1dv = NULL; +PFNGLVERTEXATTRIB1FPROC glad_glVertexAttrib1f = NULL; +PFNGLVERTEXATTRIB1FVPROC glad_glVertexAttrib1fv = NULL; +PFNGLVERTEXATTRIB1SPROC glad_glVertexAttrib1s = NULL; +PFNGLVERTEXATTRIB1SVPROC glad_glVertexAttrib1sv = NULL; +PFNGLVERTEXATTRIB2DPROC glad_glVertexAttrib2d = NULL; +PFNGLVERTEXATTRIB2DVPROC glad_glVertexAttrib2dv = NULL; +PFNGLVERTEXATTRIB2FPROC glad_glVertexAttrib2f = NULL; +PFNGLVERTEXATTRIB2FVPROC glad_glVertexAttrib2fv = NULL; +PFNGLVERTEXATTRIB2SPROC glad_glVertexAttrib2s = NULL; +PFNGLVERTEXATTRIB2SVPROC glad_glVertexAttrib2sv = NULL; +PFNGLVERTEXATTRIB3DPROC glad_glVertexAttrib3d = NULL; +PFNGLVERTEXATTRIB3DVPROC glad_glVertexAttrib3dv = NULL; +PFNGLVERTEXATTRIB3FPROC glad_glVertexAttrib3f = NULL; +PFNGLVERTEXATTRIB3FVPROC glad_glVertexAttrib3fv = NULL; +PFNGLVERTEXATTRIB3SPROC glad_glVertexAttrib3s = NULL; +PFNGLVERTEXATTRIB3SVPROC glad_glVertexAttrib3sv = NULL; +PFNGLVERTEXATTRIB4NBVPROC glad_glVertexAttrib4Nbv = NULL; +PFNGLVERTEXATTRIB4NIVPROC glad_glVertexAttrib4Niv = NULL; +PFNGLVERTEXATTRIB4NSVPROC glad_glVertexAttrib4Nsv = NULL; +PFNGLVERTEXATTRIB4NUBPROC glad_glVertexAttrib4Nub = NULL; +PFNGLVERTEXATTRIB4NUBVPROC glad_glVertexAttrib4Nubv = NULL; +PFNGLVERTEXATTRIB4NUIVPROC glad_glVertexAttrib4Nuiv = NULL; +PFNGLVERTEXATTRIB4NUSVPROC glad_glVertexAttrib4Nusv = NULL; +PFNGLVERTEXATTRIB4BVPROC glad_glVertexAttrib4bv = NULL; +PFNGLVERTEXATTRIB4DPROC glad_glVertexAttrib4d = NULL; +PFNGLVERTEXATTRIB4DVPROC glad_glVertexAttrib4dv = NULL; +PFNGLVERTEXATTRIB4FPROC glad_glVertexAttrib4f = NULL; +PFNGLVERTEXATTRIB4FVPROC glad_glVertexAttrib4fv = NULL; +PFNGLVERTEXATTRIB4IVPROC glad_glVertexAttrib4iv = NULL; +PFNGLVERTEXATTRIB4SPROC glad_glVertexAttrib4s = NULL; +PFNGLVERTEXATTRIB4SVPROC glad_glVertexAttrib4sv = NULL; +PFNGLVERTEXATTRIB4UBVPROC glad_glVertexAttrib4ubv = NULL; +PFNGLVERTEXATTRIB4UIVPROC glad_glVertexAttrib4uiv = NULL; +PFNGLVERTEXATTRIB4USVPROC glad_glVertexAttrib4usv = NULL; +PFNGLVERTEXATTRIBDIVISORPROC glad_glVertexAttribDivisor = NULL; +PFNGLVERTEXATTRIBI1IPROC glad_glVertexAttribI1i = NULL; +PFNGLVERTEXATTRIBI1IVPROC glad_glVertexAttribI1iv = NULL; +PFNGLVERTEXATTRIBI1UIPROC glad_glVertexAttribI1ui = NULL; +PFNGLVERTEXATTRIBI1UIVPROC glad_glVertexAttribI1uiv = NULL; +PFNGLVERTEXATTRIBI2IPROC glad_glVertexAttribI2i = NULL; +PFNGLVERTEXATTRIBI2IVPROC glad_glVertexAttribI2iv = NULL; +PFNGLVERTEXATTRIBI2UIPROC glad_glVertexAttribI2ui = NULL; +PFNGLVERTEXATTRIBI2UIVPROC glad_glVertexAttribI2uiv = NULL; +PFNGLVERTEXATTRIBI3IPROC glad_glVertexAttribI3i = NULL; +PFNGLVERTEXATTRIBI3IVPROC glad_glVertexAttribI3iv = NULL; +PFNGLVERTEXATTRIBI3UIPROC glad_glVertexAttribI3ui = NULL; +PFNGLVERTEXATTRIBI3UIVPROC glad_glVertexAttribI3uiv = NULL; +PFNGLVERTEXATTRIBI4BVPROC glad_glVertexAttribI4bv = NULL; +PFNGLVERTEXATTRIBI4IPROC glad_glVertexAttribI4i = NULL; +PFNGLVERTEXATTRIBI4IVPROC glad_glVertexAttribI4iv = NULL; +PFNGLVERTEXATTRIBI4SVPROC glad_glVertexAttribI4sv = NULL; +PFNGLVERTEXATTRIBI4UBVPROC glad_glVertexAttribI4ubv = NULL; +PFNGLVERTEXATTRIBI4UIPROC glad_glVertexAttribI4ui = NULL; +PFNGLVERTEXATTRIBI4UIVPROC glad_glVertexAttribI4uiv = NULL; +PFNGLVERTEXATTRIBI4USVPROC glad_glVertexAttribI4usv = NULL; +PFNGLVERTEXATTRIBIPOINTERPROC glad_glVertexAttribIPointer = NULL; +PFNGLVERTEXATTRIBP1UIPROC glad_glVertexAttribP1ui = NULL; +PFNGLVERTEXATTRIBP1UIVPROC glad_glVertexAttribP1uiv = NULL; +PFNGLVERTEXATTRIBP2UIPROC glad_glVertexAttribP2ui = NULL; +PFNGLVERTEXATTRIBP2UIVPROC glad_glVertexAttribP2uiv = NULL; +PFNGLVERTEXATTRIBP3UIPROC glad_glVertexAttribP3ui = NULL; +PFNGLVERTEXATTRIBP3UIVPROC glad_glVertexAttribP3uiv = NULL; +PFNGLVERTEXATTRIBP4UIPROC glad_glVertexAttribP4ui = NULL; +PFNGLVERTEXATTRIBP4UIVPROC glad_glVertexAttribP4uiv = NULL; +PFNGLVERTEXATTRIBPOINTERPROC glad_glVertexAttribPointer = NULL; +PFNGLVIEWPORTPROC glad_glViewport = NULL; +PFNGLWAITSYNCPROC glad_glWaitSync = NULL; + + +static void glad_gl_load_GL_VERSION_1_0( GLADuserptrloadfunc load, void* userptr) { + if(!GLAD_GL_VERSION_1_0) return; + glad_glBlendFunc = (PFNGLBLENDFUNCPROC) load(userptr, "glBlendFunc"); + glad_glClear = (PFNGLCLEARPROC) load(userptr, "glClear"); + glad_glClearColor = (PFNGLCLEARCOLORPROC) load(userptr, "glClearColor"); + glad_glClearDepth = (PFNGLCLEARDEPTHPROC) load(userptr, "glClearDepth"); + glad_glClearStencil = (PFNGLCLEARSTENCILPROC) load(userptr, "glClearStencil"); + glad_glColorMask = (PFNGLCOLORMASKPROC) load(userptr, "glColorMask"); + glad_glCullFace = (PFNGLCULLFACEPROC) load(userptr, "glCullFace"); + glad_glDepthFunc = (PFNGLDEPTHFUNCPROC) load(userptr, "glDepthFunc"); + glad_glDepthMask = (PFNGLDEPTHMASKPROC) load(userptr, "glDepthMask"); + glad_glDepthRange = (PFNGLDEPTHRANGEPROC) load(userptr, "glDepthRange"); + glad_glDisable = (PFNGLDISABLEPROC) load(userptr, "glDisable"); + glad_glDrawBuffer = (PFNGLDRAWBUFFERPROC) load(userptr, "glDrawBuffer"); + glad_glEnable = (PFNGLENABLEPROC) load(userptr, "glEnable"); + glad_glFinish = (PFNGLFINISHPROC) load(userptr, "glFinish"); + glad_glFlush = (PFNGLFLUSHPROC) load(userptr, "glFlush"); + glad_glFrontFace = (PFNGLFRONTFACEPROC) load(userptr, "glFrontFace"); + glad_glGetBooleanv = (PFNGLGETBOOLEANVPROC) load(userptr, "glGetBooleanv"); + glad_glGetDoublev = (PFNGLGETDOUBLEVPROC) load(userptr, "glGetDoublev"); + glad_glGetError = (PFNGLGETERRORPROC) load(userptr, "glGetError"); + glad_glGetFloatv = (PFNGLGETFLOATVPROC) load(userptr, "glGetFloatv"); + glad_glGetIntegerv = (PFNGLGETINTEGERVPROC) load(userptr, "glGetIntegerv"); + glad_glGetString = (PFNGLGETSTRINGPROC) load(userptr, "glGetString"); + glad_glGetTexImage = (PFNGLGETTEXIMAGEPROC) load(userptr, "glGetTexImage"); + glad_glGetTexLevelParameterfv = (PFNGLGETTEXLEVELPARAMETERFVPROC) load(userptr, "glGetTexLevelParameterfv"); + glad_glGetTexLevelParameteriv = (PFNGLGETTEXLEVELPARAMETERIVPROC) load(userptr, "glGetTexLevelParameteriv"); + glad_glGetTexParameterfv = (PFNGLGETTEXPARAMETERFVPROC) load(userptr, "glGetTexParameterfv"); + glad_glGetTexParameteriv = (PFNGLGETTEXPARAMETERIVPROC) load(userptr, "glGetTexParameteriv"); + glad_glHint = (PFNGLHINTPROC) load(userptr, "glHint"); + glad_glIsEnabled = (PFNGLISENABLEDPROC) load(userptr, "glIsEnabled"); + glad_glLineWidth = (PFNGLLINEWIDTHPROC) load(userptr, "glLineWidth"); + glad_glLogicOp = (PFNGLLOGICOPPROC) load(userptr, "glLogicOp"); + glad_glPixelStoref = (PFNGLPIXELSTOREFPROC) load(userptr, "glPixelStoref"); + glad_glPixelStorei = (PFNGLPIXELSTOREIPROC) load(userptr, "glPixelStorei"); + glad_glPointSize = (PFNGLPOINTSIZEPROC) load(userptr, "glPointSize"); + glad_glPolygonMode = (PFNGLPOLYGONMODEPROC) load(userptr, "glPolygonMode"); + glad_glReadBuffer = (PFNGLREADBUFFERPROC) load(userptr, "glReadBuffer"); + glad_glReadPixels = (PFNGLREADPIXELSPROC) load(userptr, "glReadPixels"); + glad_glScissor = (PFNGLSCISSORPROC) load(userptr, "glScissor"); + glad_glStencilFunc = (PFNGLSTENCILFUNCPROC) load(userptr, "glStencilFunc"); + glad_glStencilMask = (PFNGLSTENCILMASKPROC) load(userptr, "glStencilMask"); + glad_glStencilOp = (PFNGLSTENCILOPPROC) load(userptr, "glStencilOp"); + glad_glTexImage1D = (PFNGLTEXIMAGE1DPROC) load(userptr, "glTexImage1D"); + glad_glTexImage2D = (PFNGLTEXIMAGE2DPROC) load(userptr, "glTexImage2D"); + glad_glTexParameterf = (PFNGLTEXPARAMETERFPROC) load(userptr, "glTexParameterf"); + glad_glTexParameterfv = (PFNGLTEXPARAMETERFVPROC) load(userptr, "glTexParameterfv"); + glad_glTexParameteri = (PFNGLTEXPARAMETERIPROC) load(userptr, "glTexParameteri"); + glad_glTexParameteriv = (PFNGLTEXPARAMETERIVPROC) load(userptr, "glTexParameteriv"); + glad_glViewport = (PFNGLVIEWPORTPROC) load(userptr, "glViewport"); +} +static void glad_gl_load_GL_VERSION_1_1( GLADuserptrloadfunc load, void* userptr) { + if(!GLAD_GL_VERSION_1_1) return; + glad_glBindTexture = (PFNGLBINDTEXTUREPROC) load(userptr, "glBindTexture"); + glad_glCopyTexImage1D = (PFNGLCOPYTEXIMAGE1DPROC) load(userptr, "glCopyTexImage1D"); + glad_glCopyTexImage2D = (PFNGLCOPYTEXIMAGE2DPROC) load(userptr, "glCopyTexImage2D"); + glad_glCopyTexSubImage1D = (PFNGLCOPYTEXSUBIMAGE1DPROC) load(userptr, "glCopyTexSubImage1D"); + glad_glCopyTexSubImage2D = (PFNGLCOPYTEXSUBIMAGE2DPROC) load(userptr, "glCopyTexSubImage2D"); + glad_glDeleteTextures = (PFNGLDELETETEXTURESPROC) load(userptr, "glDeleteTextures"); + glad_glDrawArrays = (PFNGLDRAWARRAYSPROC) load(userptr, "glDrawArrays"); + glad_glDrawElements = (PFNGLDRAWELEMENTSPROC) load(userptr, "glDrawElements"); + glad_glGenTextures = (PFNGLGENTEXTURESPROC) load(userptr, "glGenTextures"); + glad_glGetPointerv = (PFNGLGETPOINTERVPROC) load(userptr, "glGetPointerv"); + glad_glIsTexture = (PFNGLISTEXTUREPROC) load(userptr, "glIsTexture"); + glad_glPolygonOffset = (PFNGLPOLYGONOFFSETPROC) load(userptr, "glPolygonOffset"); + glad_glTexSubImage1D = (PFNGLTEXSUBIMAGE1DPROC) load(userptr, "glTexSubImage1D"); + glad_glTexSubImage2D = (PFNGLTEXSUBIMAGE2DPROC) load(userptr, "glTexSubImage2D"); +} +static void glad_gl_load_GL_VERSION_1_2( GLADuserptrloadfunc load, void* userptr) { + if(!GLAD_GL_VERSION_1_2) return; + glad_glCopyTexSubImage3D = (PFNGLCOPYTEXSUBIMAGE3DPROC) load(userptr, "glCopyTexSubImage3D"); + glad_glDrawRangeElements = (PFNGLDRAWRANGEELEMENTSPROC) load(userptr, "glDrawRangeElements"); + glad_glTexImage3D = (PFNGLTEXIMAGE3DPROC) load(userptr, "glTexImage3D"); + glad_glTexSubImage3D = (PFNGLTEXSUBIMAGE3DPROC) load(userptr, "glTexSubImage3D"); +} +static void glad_gl_load_GL_VERSION_1_3( GLADuserptrloadfunc load, void* userptr) { + if(!GLAD_GL_VERSION_1_3) return; + glad_glActiveTexture = (PFNGLACTIVETEXTUREPROC) load(userptr, "glActiveTexture"); + glad_glCompressedTexImage1D = (PFNGLCOMPRESSEDTEXIMAGE1DPROC) load(userptr, "glCompressedTexImage1D"); + glad_glCompressedTexImage2D = (PFNGLCOMPRESSEDTEXIMAGE2DPROC) load(userptr, "glCompressedTexImage2D"); + glad_glCompressedTexImage3D = (PFNGLCOMPRESSEDTEXIMAGE3DPROC) load(userptr, "glCompressedTexImage3D"); + glad_glCompressedTexSubImage1D = (PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC) load(userptr, "glCompressedTexSubImage1D"); + glad_glCompressedTexSubImage2D = (PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC) load(userptr, "glCompressedTexSubImage2D"); + glad_glCompressedTexSubImage3D = (PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC) load(userptr, "glCompressedTexSubImage3D"); + glad_glGetCompressedTexImage = (PFNGLGETCOMPRESSEDTEXIMAGEPROC) load(userptr, "glGetCompressedTexImage"); + glad_glSampleCoverage = (PFNGLSAMPLECOVERAGEPROC) load(userptr, "glSampleCoverage"); +} +static void glad_gl_load_GL_VERSION_1_4( GLADuserptrloadfunc load, void* userptr) { + if(!GLAD_GL_VERSION_1_4) return; + glad_glBlendColor = (PFNGLBLENDCOLORPROC) load(userptr, "glBlendColor"); + glad_glBlendEquation = (PFNGLBLENDEQUATIONPROC) load(userptr, "glBlendEquation"); + glad_glBlendFuncSeparate = (PFNGLBLENDFUNCSEPARATEPROC) load(userptr, "glBlendFuncSeparate"); + glad_glMultiDrawArrays = (PFNGLMULTIDRAWARRAYSPROC) load(userptr, "glMultiDrawArrays"); + glad_glMultiDrawElements = (PFNGLMULTIDRAWELEMENTSPROC) load(userptr, "glMultiDrawElements"); + glad_glPointParameterf = (PFNGLPOINTPARAMETERFPROC) load(userptr, "glPointParameterf"); + glad_glPointParameterfv = (PFNGLPOINTPARAMETERFVPROC) load(userptr, "glPointParameterfv"); + glad_glPointParameteri = (PFNGLPOINTPARAMETERIPROC) load(userptr, "glPointParameteri"); + glad_glPointParameteriv = (PFNGLPOINTPARAMETERIVPROC) load(userptr, "glPointParameteriv"); +} +static void glad_gl_load_GL_VERSION_1_5( GLADuserptrloadfunc load, void* userptr) { + if(!GLAD_GL_VERSION_1_5) return; + glad_glBeginQuery = (PFNGLBEGINQUERYPROC) load(userptr, "glBeginQuery"); + glad_glBindBuffer = (PFNGLBINDBUFFERPROC) load(userptr, "glBindBuffer"); + glad_glBufferData = (PFNGLBUFFERDATAPROC) load(userptr, "glBufferData"); + glad_glBufferSubData = (PFNGLBUFFERSUBDATAPROC) load(userptr, "glBufferSubData"); + glad_glDeleteBuffers = (PFNGLDELETEBUFFERSPROC) load(userptr, "glDeleteBuffers"); + glad_glDeleteQueries = (PFNGLDELETEQUERIESPROC) load(userptr, "glDeleteQueries"); + glad_glEndQuery = (PFNGLENDQUERYPROC) load(userptr, "glEndQuery"); + glad_glGenBuffers = (PFNGLGENBUFFERSPROC) load(userptr, "glGenBuffers"); + glad_glGenQueries = (PFNGLGENQUERIESPROC) load(userptr, "glGenQueries"); + glad_glGetBufferParameteriv = (PFNGLGETBUFFERPARAMETERIVPROC) load(userptr, "glGetBufferParameteriv"); + glad_glGetBufferPointerv = (PFNGLGETBUFFERPOINTERVPROC) load(userptr, "glGetBufferPointerv"); + glad_glGetBufferSubData = (PFNGLGETBUFFERSUBDATAPROC) load(userptr, "glGetBufferSubData"); + glad_glGetQueryObjectiv = (PFNGLGETQUERYOBJECTIVPROC) load(userptr, "glGetQueryObjectiv"); + glad_glGetQueryObjectuiv = (PFNGLGETQUERYOBJECTUIVPROC) load(userptr, "glGetQueryObjectuiv"); + glad_glGetQueryiv = (PFNGLGETQUERYIVPROC) load(userptr, "glGetQueryiv"); + glad_glIsBuffer = (PFNGLISBUFFERPROC) load(userptr, "glIsBuffer"); + glad_glIsQuery = (PFNGLISQUERYPROC) load(userptr, "glIsQuery"); + glad_glMapBuffer = (PFNGLMAPBUFFERPROC) load(userptr, "glMapBuffer"); + glad_glUnmapBuffer = (PFNGLUNMAPBUFFERPROC) load(userptr, "glUnmapBuffer"); +} +static void glad_gl_load_GL_VERSION_2_0( GLADuserptrloadfunc load, void* userptr) { + if(!GLAD_GL_VERSION_2_0) return; + glad_glAttachShader = (PFNGLATTACHSHADERPROC) load(userptr, "glAttachShader"); + glad_glBindAttribLocation = (PFNGLBINDATTRIBLOCATIONPROC) load(userptr, "glBindAttribLocation"); + glad_glBlendEquationSeparate = (PFNGLBLENDEQUATIONSEPARATEPROC) load(userptr, "glBlendEquationSeparate"); + glad_glCompileShader = (PFNGLCOMPILESHADERPROC) load(userptr, "glCompileShader"); + glad_glCreateProgram = (PFNGLCREATEPROGRAMPROC) load(userptr, "glCreateProgram"); + glad_glCreateShader = (PFNGLCREATESHADERPROC) load(userptr, "glCreateShader"); + glad_glDeleteProgram = (PFNGLDELETEPROGRAMPROC) load(userptr, "glDeleteProgram"); + glad_glDeleteShader = (PFNGLDELETESHADERPROC) load(userptr, "glDeleteShader"); + glad_glDetachShader = (PFNGLDETACHSHADERPROC) load(userptr, "glDetachShader"); + glad_glDisableVertexAttribArray = (PFNGLDISABLEVERTEXATTRIBARRAYPROC) load(userptr, "glDisableVertexAttribArray"); + glad_glDrawBuffers = (PFNGLDRAWBUFFERSPROC) load(userptr, "glDrawBuffers"); + glad_glEnableVertexAttribArray = (PFNGLENABLEVERTEXATTRIBARRAYPROC) load(userptr, "glEnableVertexAttribArray"); + glad_glGetActiveAttrib = (PFNGLGETACTIVEATTRIBPROC) load(userptr, "glGetActiveAttrib"); + glad_glGetActiveUniform = (PFNGLGETACTIVEUNIFORMPROC) load(userptr, "glGetActiveUniform"); + glad_glGetAttachedShaders = (PFNGLGETATTACHEDSHADERSPROC) load(userptr, "glGetAttachedShaders"); + glad_glGetAttribLocation = (PFNGLGETATTRIBLOCATIONPROC) load(userptr, "glGetAttribLocation"); + glad_glGetProgramInfoLog = (PFNGLGETPROGRAMINFOLOGPROC) load(userptr, "glGetProgramInfoLog"); + glad_glGetProgramiv = (PFNGLGETPROGRAMIVPROC) load(userptr, "glGetProgramiv"); + glad_glGetShaderInfoLog = (PFNGLGETSHADERINFOLOGPROC) load(userptr, "glGetShaderInfoLog"); + glad_glGetShaderSource = (PFNGLGETSHADERSOURCEPROC) load(userptr, "glGetShaderSource"); + glad_glGetShaderiv = (PFNGLGETSHADERIVPROC) load(userptr, "glGetShaderiv"); + glad_glGetUniformLocation = (PFNGLGETUNIFORMLOCATIONPROC) load(userptr, "glGetUniformLocation"); + glad_glGetUniformfv = (PFNGLGETUNIFORMFVPROC) load(userptr, "glGetUniformfv"); + glad_glGetUniformiv = (PFNGLGETUNIFORMIVPROC) load(userptr, "glGetUniformiv"); + glad_glGetVertexAttribPointerv = (PFNGLGETVERTEXATTRIBPOINTERVPROC) load(userptr, "glGetVertexAttribPointerv"); + glad_glGetVertexAttribdv = (PFNGLGETVERTEXATTRIBDVPROC) load(userptr, "glGetVertexAttribdv"); + glad_glGetVertexAttribfv = (PFNGLGETVERTEXATTRIBFVPROC) load(userptr, "glGetVertexAttribfv"); + glad_glGetVertexAttribiv = (PFNGLGETVERTEXATTRIBIVPROC) load(userptr, "glGetVertexAttribiv"); + glad_glIsProgram = (PFNGLISPROGRAMPROC) load(userptr, "glIsProgram"); + glad_glIsShader = (PFNGLISSHADERPROC) load(userptr, "glIsShader"); + glad_glLinkProgram = (PFNGLLINKPROGRAMPROC) load(userptr, "glLinkProgram"); + glad_glShaderSource = (PFNGLSHADERSOURCEPROC) load(userptr, "glShaderSource"); + glad_glStencilFuncSeparate = (PFNGLSTENCILFUNCSEPARATEPROC) load(userptr, "glStencilFuncSeparate"); + glad_glStencilMaskSeparate = (PFNGLSTENCILMASKSEPARATEPROC) load(userptr, "glStencilMaskSeparate"); + glad_glStencilOpSeparate = (PFNGLSTENCILOPSEPARATEPROC) load(userptr, "glStencilOpSeparate"); + glad_glUniform1f = (PFNGLUNIFORM1FPROC) load(userptr, "glUniform1f"); + glad_glUniform1fv = (PFNGLUNIFORM1FVPROC) load(userptr, "glUniform1fv"); + glad_glUniform1i = (PFNGLUNIFORM1IPROC) load(userptr, "glUniform1i"); + glad_glUniform1iv = (PFNGLUNIFORM1IVPROC) load(userptr, "glUniform1iv"); + glad_glUniform2f = (PFNGLUNIFORM2FPROC) load(userptr, "glUniform2f"); + glad_glUniform2fv = (PFNGLUNIFORM2FVPROC) load(userptr, "glUniform2fv"); + glad_glUniform2i = (PFNGLUNIFORM2IPROC) load(userptr, "glUniform2i"); + glad_glUniform2iv = (PFNGLUNIFORM2IVPROC) load(userptr, "glUniform2iv"); + glad_glUniform3f = (PFNGLUNIFORM3FPROC) load(userptr, "glUniform3f"); + glad_glUniform3fv = (PFNGLUNIFORM3FVPROC) load(userptr, "glUniform3fv"); + glad_glUniform3i = (PFNGLUNIFORM3IPROC) load(userptr, "glUniform3i"); + glad_glUniform3iv = (PFNGLUNIFORM3IVPROC) load(userptr, "glUniform3iv"); + glad_glUniform4f = (PFNGLUNIFORM4FPROC) load(userptr, "glUniform4f"); + glad_glUniform4fv = (PFNGLUNIFORM4FVPROC) load(userptr, "glUniform4fv"); + glad_glUniform4i = (PFNGLUNIFORM4IPROC) load(userptr, "glUniform4i"); + glad_glUniform4iv = (PFNGLUNIFORM4IVPROC) load(userptr, "glUniform4iv"); + glad_glUniformMatrix2fv = (PFNGLUNIFORMMATRIX2FVPROC) load(userptr, "glUniformMatrix2fv"); + glad_glUniformMatrix3fv = (PFNGLUNIFORMMATRIX3FVPROC) load(userptr, "glUniformMatrix3fv"); + glad_glUniformMatrix4fv = (PFNGLUNIFORMMATRIX4FVPROC) load(userptr, "glUniformMatrix4fv"); + glad_glUseProgram = (PFNGLUSEPROGRAMPROC) load(userptr, "glUseProgram"); + glad_glValidateProgram = (PFNGLVALIDATEPROGRAMPROC) load(userptr, "glValidateProgram"); + glad_glVertexAttrib1d = (PFNGLVERTEXATTRIB1DPROC) load(userptr, "glVertexAttrib1d"); + glad_glVertexAttrib1dv = (PFNGLVERTEXATTRIB1DVPROC) load(userptr, "glVertexAttrib1dv"); + glad_glVertexAttrib1f = (PFNGLVERTEXATTRIB1FPROC) load(userptr, "glVertexAttrib1f"); + glad_glVertexAttrib1fv = (PFNGLVERTEXATTRIB1FVPROC) load(userptr, "glVertexAttrib1fv"); + glad_glVertexAttrib1s = (PFNGLVERTEXATTRIB1SPROC) load(userptr, "glVertexAttrib1s"); + glad_glVertexAttrib1sv = (PFNGLVERTEXATTRIB1SVPROC) load(userptr, "glVertexAttrib1sv"); + glad_glVertexAttrib2d = (PFNGLVERTEXATTRIB2DPROC) load(userptr, "glVertexAttrib2d"); + glad_glVertexAttrib2dv = (PFNGLVERTEXATTRIB2DVPROC) load(userptr, "glVertexAttrib2dv"); + glad_glVertexAttrib2f = (PFNGLVERTEXATTRIB2FPROC) load(userptr, "glVertexAttrib2f"); + glad_glVertexAttrib2fv = (PFNGLVERTEXATTRIB2FVPROC) load(userptr, "glVertexAttrib2fv"); + glad_glVertexAttrib2s = (PFNGLVERTEXATTRIB2SPROC) load(userptr, "glVertexAttrib2s"); + glad_glVertexAttrib2sv = (PFNGLVERTEXATTRIB2SVPROC) load(userptr, "glVertexAttrib2sv"); + glad_glVertexAttrib3d = (PFNGLVERTEXATTRIB3DPROC) load(userptr, "glVertexAttrib3d"); + glad_glVertexAttrib3dv = (PFNGLVERTEXATTRIB3DVPROC) load(userptr, "glVertexAttrib3dv"); + glad_glVertexAttrib3f = (PFNGLVERTEXATTRIB3FPROC) load(userptr, "glVertexAttrib3f"); + glad_glVertexAttrib3fv = (PFNGLVERTEXATTRIB3FVPROC) load(userptr, "glVertexAttrib3fv"); + glad_glVertexAttrib3s = (PFNGLVERTEXATTRIB3SPROC) load(userptr, "glVertexAttrib3s"); + glad_glVertexAttrib3sv = (PFNGLVERTEXATTRIB3SVPROC) load(userptr, "glVertexAttrib3sv"); + glad_glVertexAttrib4Nbv = (PFNGLVERTEXATTRIB4NBVPROC) load(userptr, "glVertexAttrib4Nbv"); + glad_glVertexAttrib4Niv = (PFNGLVERTEXATTRIB4NIVPROC) load(userptr, "glVertexAttrib4Niv"); + glad_glVertexAttrib4Nsv = (PFNGLVERTEXATTRIB4NSVPROC) load(userptr, "glVertexAttrib4Nsv"); + glad_glVertexAttrib4Nub = (PFNGLVERTEXATTRIB4NUBPROC) load(userptr, "glVertexAttrib4Nub"); + glad_glVertexAttrib4Nubv = (PFNGLVERTEXATTRIB4NUBVPROC) load(userptr, "glVertexAttrib4Nubv"); + glad_glVertexAttrib4Nuiv = (PFNGLVERTEXATTRIB4NUIVPROC) load(userptr, "glVertexAttrib4Nuiv"); + glad_glVertexAttrib4Nusv = (PFNGLVERTEXATTRIB4NUSVPROC) load(userptr, "glVertexAttrib4Nusv"); + glad_glVertexAttrib4bv = (PFNGLVERTEXATTRIB4BVPROC) load(userptr, "glVertexAttrib4bv"); + glad_glVertexAttrib4d = (PFNGLVERTEXATTRIB4DPROC) load(userptr, "glVertexAttrib4d"); + glad_glVertexAttrib4dv = (PFNGLVERTEXATTRIB4DVPROC) load(userptr, "glVertexAttrib4dv"); + glad_glVertexAttrib4f = (PFNGLVERTEXATTRIB4FPROC) load(userptr, "glVertexAttrib4f"); + glad_glVertexAttrib4fv = (PFNGLVERTEXATTRIB4FVPROC) load(userptr, "glVertexAttrib4fv"); + glad_glVertexAttrib4iv = (PFNGLVERTEXATTRIB4IVPROC) load(userptr, "glVertexAttrib4iv"); + glad_glVertexAttrib4s = (PFNGLVERTEXATTRIB4SPROC) load(userptr, "glVertexAttrib4s"); + glad_glVertexAttrib4sv = (PFNGLVERTEXATTRIB4SVPROC) load(userptr, "glVertexAttrib4sv"); + glad_glVertexAttrib4ubv = (PFNGLVERTEXATTRIB4UBVPROC) load(userptr, "glVertexAttrib4ubv"); + glad_glVertexAttrib4uiv = (PFNGLVERTEXATTRIB4UIVPROC) load(userptr, "glVertexAttrib4uiv"); + glad_glVertexAttrib4usv = (PFNGLVERTEXATTRIB4USVPROC) load(userptr, "glVertexAttrib4usv"); + glad_glVertexAttribPointer = (PFNGLVERTEXATTRIBPOINTERPROC) load(userptr, "glVertexAttribPointer"); +} +static void glad_gl_load_GL_VERSION_2_1( GLADuserptrloadfunc load, void* userptr) { + if(!GLAD_GL_VERSION_2_1) return; + glad_glUniformMatrix2x3fv = (PFNGLUNIFORMMATRIX2X3FVPROC) load(userptr, "glUniformMatrix2x3fv"); + glad_glUniformMatrix2x4fv = (PFNGLUNIFORMMATRIX2X4FVPROC) load(userptr, "glUniformMatrix2x4fv"); + glad_glUniformMatrix3x2fv = (PFNGLUNIFORMMATRIX3X2FVPROC) load(userptr, "glUniformMatrix3x2fv"); + glad_glUniformMatrix3x4fv = (PFNGLUNIFORMMATRIX3X4FVPROC) load(userptr, "glUniformMatrix3x4fv"); + glad_glUniformMatrix4x2fv = (PFNGLUNIFORMMATRIX4X2FVPROC) load(userptr, "glUniformMatrix4x2fv"); + glad_glUniformMatrix4x3fv = (PFNGLUNIFORMMATRIX4X3FVPROC) load(userptr, "glUniformMatrix4x3fv"); +} +static void glad_gl_load_GL_VERSION_3_0( GLADuserptrloadfunc load, void* userptr) { + if(!GLAD_GL_VERSION_3_0) return; + glad_glBeginConditionalRender = (PFNGLBEGINCONDITIONALRENDERPROC) load(userptr, "glBeginConditionalRender"); + glad_glBeginTransformFeedback = (PFNGLBEGINTRANSFORMFEEDBACKPROC) load(userptr, "glBeginTransformFeedback"); + glad_glBindBufferBase = (PFNGLBINDBUFFERBASEPROC) load(userptr, "glBindBufferBase"); + glad_glBindBufferRange = (PFNGLBINDBUFFERRANGEPROC) load(userptr, "glBindBufferRange"); + glad_glBindFragDataLocation = (PFNGLBINDFRAGDATALOCATIONPROC) load(userptr, "glBindFragDataLocation"); + glad_glBindFramebuffer = (PFNGLBINDFRAMEBUFFERPROC) load(userptr, "glBindFramebuffer"); + glad_glBindRenderbuffer = (PFNGLBINDRENDERBUFFERPROC) load(userptr, "glBindRenderbuffer"); + glad_glBindVertexArray = (PFNGLBINDVERTEXARRAYPROC) load(userptr, "glBindVertexArray"); + glad_glBlitFramebuffer = (PFNGLBLITFRAMEBUFFERPROC) load(userptr, "glBlitFramebuffer"); + glad_glCheckFramebufferStatus = (PFNGLCHECKFRAMEBUFFERSTATUSPROC) load(userptr, "glCheckFramebufferStatus"); + glad_glClampColor = (PFNGLCLAMPCOLORPROC) load(userptr, "glClampColor"); + glad_glClearBufferfi = (PFNGLCLEARBUFFERFIPROC) load(userptr, "glClearBufferfi"); + glad_glClearBufferfv = (PFNGLCLEARBUFFERFVPROC) load(userptr, "glClearBufferfv"); + glad_glClearBufferiv = (PFNGLCLEARBUFFERIVPROC) load(userptr, "glClearBufferiv"); + glad_glClearBufferuiv = (PFNGLCLEARBUFFERUIVPROC) load(userptr, "glClearBufferuiv"); + glad_glColorMaski = (PFNGLCOLORMASKIPROC) load(userptr, "glColorMaski"); + glad_glDeleteFramebuffers = (PFNGLDELETEFRAMEBUFFERSPROC) load(userptr, "glDeleteFramebuffers"); + glad_glDeleteRenderbuffers = (PFNGLDELETERENDERBUFFERSPROC) load(userptr, "glDeleteRenderbuffers"); + glad_glDeleteVertexArrays = (PFNGLDELETEVERTEXARRAYSPROC) load(userptr, "glDeleteVertexArrays"); + glad_glDisablei = (PFNGLDISABLEIPROC) load(userptr, "glDisablei"); + glad_glEnablei = (PFNGLENABLEIPROC) load(userptr, "glEnablei"); + glad_glEndConditionalRender = (PFNGLENDCONDITIONALRENDERPROC) load(userptr, "glEndConditionalRender"); + glad_glEndTransformFeedback = (PFNGLENDTRANSFORMFEEDBACKPROC) load(userptr, "glEndTransformFeedback"); + glad_glFlushMappedBufferRange = (PFNGLFLUSHMAPPEDBUFFERRANGEPROC) load(userptr, "glFlushMappedBufferRange"); + glad_glFramebufferRenderbuffer = (PFNGLFRAMEBUFFERRENDERBUFFERPROC) load(userptr, "glFramebufferRenderbuffer"); + glad_glFramebufferTexture1D = (PFNGLFRAMEBUFFERTEXTURE1DPROC) load(userptr, "glFramebufferTexture1D"); + glad_glFramebufferTexture2D = (PFNGLFRAMEBUFFERTEXTURE2DPROC) load(userptr, "glFramebufferTexture2D"); + glad_glFramebufferTexture3D = (PFNGLFRAMEBUFFERTEXTURE3DPROC) load(userptr, "glFramebufferTexture3D"); + glad_glFramebufferTextureLayer = (PFNGLFRAMEBUFFERTEXTURELAYERPROC) load(userptr, "glFramebufferTextureLayer"); + glad_glGenFramebuffers = (PFNGLGENFRAMEBUFFERSPROC) load(userptr, "glGenFramebuffers"); + glad_glGenRenderbuffers = (PFNGLGENRENDERBUFFERSPROC) load(userptr, "glGenRenderbuffers"); + glad_glGenVertexArrays = (PFNGLGENVERTEXARRAYSPROC) load(userptr, "glGenVertexArrays"); + glad_glGenerateMipmap = (PFNGLGENERATEMIPMAPPROC) load(userptr, "glGenerateMipmap"); + glad_glGetBooleani_v = (PFNGLGETBOOLEANI_VPROC) load(userptr, "glGetBooleani_v"); + glad_glGetFragDataLocation = (PFNGLGETFRAGDATALOCATIONPROC) load(userptr, "glGetFragDataLocation"); + glad_glGetFramebufferAttachmentParameteriv = (PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC) load(userptr, "glGetFramebufferAttachmentParameteriv"); + glad_glGetIntegeri_v = (PFNGLGETINTEGERI_VPROC) load(userptr, "glGetIntegeri_v"); + glad_glGetRenderbufferParameteriv = (PFNGLGETRENDERBUFFERPARAMETERIVPROC) load(userptr, "glGetRenderbufferParameteriv"); + glad_glGetStringi = (PFNGLGETSTRINGIPROC) load(userptr, "glGetStringi"); + glad_glGetTexParameterIiv = (PFNGLGETTEXPARAMETERIIVPROC) load(userptr, "glGetTexParameterIiv"); + glad_glGetTexParameterIuiv = (PFNGLGETTEXPARAMETERIUIVPROC) load(userptr, "glGetTexParameterIuiv"); + glad_glGetTransformFeedbackVarying = (PFNGLGETTRANSFORMFEEDBACKVARYINGPROC) load(userptr, "glGetTransformFeedbackVarying"); + glad_glGetUniformuiv = (PFNGLGETUNIFORMUIVPROC) load(userptr, "glGetUniformuiv"); + glad_glGetVertexAttribIiv = (PFNGLGETVERTEXATTRIBIIVPROC) load(userptr, "glGetVertexAttribIiv"); + glad_glGetVertexAttribIuiv = (PFNGLGETVERTEXATTRIBIUIVPROC) load(userptr, "glGetVertexAttribIuiv"); + glad_glIsEnabledi = (PFNGLISENABLEDIPROC) load(userptr, "glIsEnabledi"); + glad_glIsFramebuffer = (PFNGLISFRAMEBUFFERPROC) load(userptr, "glIsFramebuffer"); + glad_glIsRenderbuffer = (PFNGLISRENDERBUFFERPROC) load(userptr, "glIsRenderbuffer"); + glad_glIsVertexArray = (PFNGLISVERTEXARRAYPROC) load(userptr, "glIsVertexArray"); + glad_glMapBufferRange = (PFNGLMAPBUFFERRANGEPROC) load(userptr, "glMapBufferRange"); + glad_glRenderbufferStorage = (PFNGLRENDERBUFFERSTORAGEPROC) load(userptr, "glRenderbufferStorage"); + glad_glRenderbufferStorageMultisample = (PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC) load(userptr, "glRenderbufferStorageMultisample"); + glad_glTexParameterIiv = (PFNGLTEXPARAMETERIIVPROC) load(userptr, "glTexParameterIiv"); + glad_glTexParameterIuiv = (PFNGLTEXPARAMETERIUIVPROC) load(userptr, "glTexParameterIuiv"); + glad_glTransformFeedbackVaryings = (PFNGLTRANSFORMFEEDBACKVARYINGSPROC) load(userptr, "glTransformFeedbackVaryings"); + glad_glUniform1ui = (PFNGLUNIFORM1UIPROC) load(userptr, "glUniform1ui"); + glad_glUniform1uiv = (PFNGLUNIFORM1UIVPROC) load(userptr, "glUniform1uiv"); + glad_glUniform2ui = (PFNGLUNIFORM2UIPROC) load(userptr, "glUniform2ui"); + glad_glUniform2uiv = (PFNGLUNIFORM2UIVPROC) load(userptr, "glUniform2uiv"); + glad_glUniform3ui = (PFNGLUNIFORM3UIPROC) load(userptr, "glUniform3ui"); + glad_glUniform3uiv = (PFNGLUNIFORM3UIVPROC) load(userptr, "glUniform3uiv"); + glad_glUniform4ui = (PFNGLUNIFORM4UIPROC) load(userptr, "glUniform4ui"); + glad_glUniform4uiv = (PFNGLUNIFORM4UIVPROC) load(userptr, "glUniform4uiv"); + glad_glVertexAttribI1i = (PFNGLVERTEXATTRIBI1IPROC) load(userptr, "glVertexAttribI1i"); + glad_glVertexAttribI1iv = (PFNGLVERTEXATTRIBI1IVPROC) load(userptr, "glVertexAttribI1iv"); + glad_glVertexAttribI1ui = (PFNGLVERTEXATTRIBI1UIPROC) load(userptr, "glVertexAttribI1ui"); + glad_glVertexAttribI1uiv = (PFNGLVERTEXATTRIBI1UIVPROC) load(userptr, "glVertexAttribI1uiv"); + glad_glVertexAttribI2i = (PFNGLVERTEXATTRIBI2IPROC) load(userptr, "glVertexAttribI2i"); + glad_glVertexAttribI2iv = (PFNGLVERTEXATTRIBI2IVPROC) load(userptr, "glVertexAttribI2iv"); + glad_glVertexAttribI2ui = (PFNGLVERTEXATTRIBI2UIPROC) load(userptr, "glVertexAttribI2ui"); + glad_glVertexAttribI2uiv = (PFNGLVERTEXATTRIBI2UIVPROC) load(userptr, "glVertexAttribI2uiv"); + glad_glVertexAttribI3i = (PFNGLVERTEXATTRIBI3IPROC) load(userptr, "glVertexAttribI3i"); + glad_glVertexAttribI3iv = (PFNGLVERTEXATTRIBI3IVPROC) load(userptr, "glVertexAttribI3iv"); + glad_glVertexAttribI3ui = (PFNGLVERTEXATTRIBI3UIPROC) load(userptr, "glVertexAttribI3ui"); + glad_glVertexAttribI3uiv = (PFNGLVERTEXATTRIBI3UIVPROC) load(userptr, "glVertexAttribI3uiv"); + glad_glVertexAttribI4bv = (PFNGLVERTEXATTRIBI4BVPROC) load(userptr, "glVertexAttribI4bv"); + glad_glVertexAttribI4i = (PFNGLVERTEXATTRIBI4IPROC) load(userptr, "glVertexAttribI4i"); + glad_glVertexAttribI4iv = (PFNGLVERTEXATTRIBI4IVPROC) load(userptr, "glVertexAttribI4iv"); + glad_glVertexAttribI4sv = (PFNGLVERTEXATTRIBI4SVPROC) load(userptr, "glVertexAttribI4sv"); + glad_glVertexAttribI4ubv = (PFNGLVERTEXATTRIBI4UBVPROC) load(userptr, "glVertexAttribI4ubv"); + glad_glVertexAttribI4ui = (PFNGLVERTEXATTRIBI4UIPROC) load(userptr, "glVertexAttribI4ui"); + glad_glVertexAttribI4uiv = (PFNGLVERTEXATTRIBI4UIVPROC) load(userptr, "glVertexAttribI4uiv"); + glad_glVertexAttribI4usv = (PFNGLVERTEXATTRIBI4USVPROC) load(userptr, "glVertexAttribI4usv"); + glad_glVertexAttribIPointer = (PFNGLVERTEXATTRIBIPOINTERPROC) load(userptr, "glVertexAttribIPointer"); +} +static void glad_gl_load_GL_VERSION_3_1( GLADuserptrloadfunc load, void* userptr) { + if(!GLAD_GL_VERSION_3_1) return; + glad_glBindBufferBase = (PFNGLBINDBUFFERBASEPROC) load(userptr, "glBindBufferBase"); + glad_glBindBufferRange = (PFNGLBINDBUFFERRANGEPROC) load(userptr, "glBindBufferRange"); + glad_glCopyBufferSubData = (PFNGLCOPYBUFFERSUBDATAPROC) load(userptr, "glCopyBufferSubData"); + glad_glDrawArraysInstanced = (PFNGLDRAWARRAYSINSTANCEDPROC) load(userptr, "glDrawArraysInstanced"); + glad_glDrawElementsInstanced = (PFNGLDRAWELEMENTSINSTANCEDPROC) load(userptr, "glDrawElementsInstanced"); + glad_glGetActiveUniformBlockName = (PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC) load(userptr, "glGetActiveUniformBlockName"); + glad_glGetActiveUniformBlockiv = (PFNGLGETACTIVEUNIFORMBLOCKIVPROC) load(userptr, "glGetActiveUniformBlockiv"); + glad_glGetActiveUniformName = (PFNGLGETACTIVEUNIFORMNAMEPROC) load(userptr, "glGetActiveUniformName"); + glad_glGetActiveUniformsiv = (PFNGLGETACTIVEUNIFORMSIVPROC) load(userptr, "glGetActiveUniformsiv"); + glad_glGetIntegeri_v = (PFNGLGETINTEGERI_VPROC) load(userptr, "glGetIntegeri_v"); + glad_glGetUniformBlockIndex = (PFNGLGETUNIFORMBLOCKINDEXPROC) load(userptr, "glGetUniformBlockIndex"); + glad_glGetUniformIndices = (PFNGLGETUNIFORMINDICESPROC) load(userptr, "glGetUniformIndices"); + glad_glPrimitiveRestartIndex = (PFNGLPRIMITIVERESTARTINDEXPROC) load(userptr, "glPrimitiveRestartIndex"); + glad_glTexBuffer = (PFNGLTEXBUFFERPROC) load(userptr, "glTexBuffer"); + glad_glUniformBlockBinding = (PFNGLUNIFORMBLOCKBINDINGPROC) load(userptr, "glUniformBlockBinding"); +} +static void glad_gl_load_GL_VERSION_3_2( GLADuserptrloadfunc load, void* userptr) { + if(!GLAD_GL_VERSION_3_2) return; + glad_glClientWaitSync = (PFNGLCLIENTWAITSYNCPROC) load(userptr, "glClientWaitSync"); + glad_glDeleteSync = (PFNGLDELETESYNCPROC) load(userptr, "glDeleteSync"); + glad_glDrawElementsBaseVertex = (PFNGLDRAWELEMENTSBASEVERTEXPROC) load(userptr, "glDrawElementsBaseVertex"); + glad_glDrawElementsInstancedBaseVertex = (PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC) load(userptr, "glDrawElementsInstancedBaseVertex"); + glad_glDrawRangeElementsBaseVertex = (PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC) load(userptr, "glDrawRangeElementsBaseVertex"); + glad_glFenceSync = (PFNGLFENCESYNCPROC) load(userptr, "glFenceSync"); + glad_glFramebufferTexture = (PFNGLFRAMEBUFFERTEXTUREPROC) load(userptr, "glFramebufferTexture"); + glad_glGetBufferParameteri64v = (PFNGLGETBUFFERPARAMETERI64VPROC) load(userptr, "glGetBufferParameteri64v"); + glad_glGetInteger64i_v = (PFNGLGETINTEGER64I_VPROC) load(userptr, "glGetInteger64i_v"); + glad_glGetInteger64v = (PFNGLGETINTEGER64VPROC) load(userptr, "glGetInteger64v"); + glad_glGetMultisamplefv = (PFNGLGETMULTISAMPLEFVPROC) load(userptr, "glGetMultisamplefv"); + glad_glGetSynciv = (PFNGLGETSYNCIVPROC) load(userptr, "glGetSynciv"); + glad_glIsSync = (PFNGLISSYNCPROC) load(userptr, "glIsSync"); + glad_glMultiDrawElementsBaseVertex = (PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC) load(userptr, "glMultiDrawElementsBaseVertex"); + glad_glProvokingVertex = (PFNGLPROVOKINGVERTEXPROC) load(userptr, "glProvokingVertex"); + glad_glSampleMaski = (PFNGLSAMPLEMASKIPROC) load(userptr, "glSampleMaski"); + glad_glTexImage2DMultisample = (PFNGLTEXIMAGE2DMULTISAMPLEPROC) load(userptr, "glTexImage2DMultisample"); + glad_glTexImage3DMultisample = (PFNGLTEXIMAGE3DMULTISAMPLEPROC) load(userptr, "glTexImage3DMultisample"); + glad_glWaitSync = (PFNGLWAITSYNCPROC) load(userptr, "glWaitSync"); +} +static void glad_gl_load_GL_VERSION_3_3( GLADuserptrloadfunc load, void* userptr) { + if(!GLAD_GL_VERSION_3_3) return; + glad_glBindFragDataLocationIndexed = (PFNGLBINDFRAGDATALOCATIONINDEXEDPROC) load(userptr, "glBindFragDataLocationIndexed"); + glad_glBindSampler = (PFNGLBINDSAMPLERPROC) load(userptr, "glBindSampler"); + glad_glDeleteSamplers = (PFNGLDELETESAMPLERSPROC) load(userptr, "glDeleteSamplers"); + glad_glGenSamplers = (PFNGLGENSAMPLERSPROC) load(userptr, "glGenSamplers"); + glad_glGetFragDataIndex = (PFNGLGETFRAGDATAINDEXPROC) load(userptr, "glGetFragDataIndex"); + glad_glGetQueryObjecti64v = (PFNGLGETQUERYOBJECTI64VPROC) load(userptr, "glGetQueryObjecti64v"); + glad_glGetQueryObjectui64v = (PFNGLGETQUERYOBJECTUI64VPROC) load(userptr, "glGetQueryObjectui64v"); + glad_glGetSamplerParameterIiv = (PFNGLGETSAMPLERPARAMETERIIVPROC) load(userptr, "glGetSamplerParameterIiv"); + glad_glGetSamplerParameterIuiv = (PFNGLGETSAMPLERPARAMETERIUIVPROC) load(userptr, "glGetSamplerParameterIuiv"); + glad_glGetSamplerParameterfv = (PFNGLGETSAMPLERPARAMETERFVPROC) load(userptr, "glGetSamplerParameterfv"); + glad_glGetSamplerParameteriv = (PFNGLGETSAMPLERPARAMETERIVPROC) load(userptr, "glGetSamplerParameteriv"); + glad_glIsSampler = (PFNGLISSAMPLERPROC) load(userptr, "glIsSampler"); + glad_glQueryCounter = (PFNGLQUERYCOUNTERPROC) load(userptr, "glQueryCounter"); + glad_glSamplerParameterIiv = (PFNGLSAMPLERPARAMETERIIVPROC) load(userptr, "glSamplerParameterIiv"); + glad_glSamplerParameterIuiv = (PFNGLSAMPLERPARAMETERIUIVPROC) load(userptr, "glSamplerParameterIuiv"); + glad_glSamplerParameterf = (PFNGLSAMPLERPARAMETERFPROC) load(userptr, "glSamplerParameterf"); + glad_glSamplerParameterfv = (PFNGLSAMPLERPARAMETERFVPROC) load(userptr, "glSamplerParameterfv"); + glad_glSamplerParameteri = (PFNGLSAMPLERPARAMETERIPROC) load(userptr, "glSamplerParameteri"); + glad_glSamplerParameteriv = (PFNGLSAMPLERPARAMETERIVPROC) load(userptr, "glSamplerParameteriv"); + glad_glVertexAttribDivisor = (PFNGLVERTEXATTRIBDIVISORPROC) load(userptr, "glVertexAttribDivisor"); + glad_glVertexAttribP1ui = (PFNGLVERTEXATTRIBP1UIPROC) load(userptr, "glVertexAttribP1ui"); + glad_glVertexAttribP1uiv = (PFNGLVERTEXATTRIBP1UIVPROC) load(userptr, "glVertexAttribP1uiv"); + glad_glVertexAttribP2ui = (PFNGLVERTEXATTRIBP2UIPROC) load(userptr, "glVertexAttribP2ui"); + glad_glVertexAttribP2uiv = (PFNGLVERTEXATTRIBP2UIVPROC) load(userptr, "glVertexAttribP2uiv"); + glad_glVertexAttribP3ui = (PFNGLVERTEXATTRIBP3UIPROC) load(userptr, "glVertexAttribP3ui"); + glad_glVertexAttribP3uiv = (PFNGLVERTEXATTRIBP3UIVPROC) load(userptr, "glVertexAttribP3uiv"); + glad_glVertexAttribP4ui = (PFNGLVERTEXATTRIBP4UIPROC) load(userptr, "glVertexAttribP4ui"); + glad_glVertexAttribP4uiv = (PFNGLVERTEXATTRIBP4UIVPROC) load(userptr, "glVertexAttribP4uiv"); +} +static void glad_gl_load_GL_KHR_debug( GLADuserptrloadfunc load, void* userptr) { + if(!GLAD_GL_KHR_debug) return; + glad_glDebugMessageCallback = (PFNGLDEBUGMESSAGECALLBACKPROC) load(userptr, "glDebugMessageCallback"); + glad_glDebugMessageControl = (PFNGLDEBUGMESSAGECONTROLPROC) load(userptr, "glDebugMessageControl"); + glad_glDebugMessageInsert = (PFNGLDEBUGMESSAGEINSERTPROC) load(userptr, "glDebugMessageInsert"); + glad_glGetDebugMessageLog = (PFNGLGETDEBUGMESSAGELOGPROC) load(userptr, "glGetDebugMessageLog"); + glad_glGetObjectLabel = (PFNGLGETOBJECTLABELPROC) load(userptr, "glGetObjectLabel"); + glad_glGetObjectPtrLabel = (PFNGLGETOBJECTPTRLABELPROC) load(userptr, "glGetObjectPtrLabel"); + glad_glGetPointerv = (PFNGLGETPOINTERVPROC) load(userptr, "glGetPointerv"); + glad_glObjectLabel = (PFNGLOBJECTLABELPROC) load(userptr, "glObjectLabel"); + glad_glObjectPtrLabel = (PFNGLOBJECTPTRLABELPROC) load(userptr, "glObjectPtrLabel"); + glad_glPopDebugGroup = (PFNGLPOPDEBUGGROUPPROC) load(userptr, "glPopDebugGroup"); + glad_glPushDebugGroup = (PFNGLPUSHDEBUGGROUPPROC) load(userptr, "glPushDebugGroup"); +} + + + +static void glad_gl_free_extensions(char **exts_i) { + if (exts_i != NULL) { + unsigned int index; + for(index = 0; exts_i[index]; index++) { + free((void *) (exts_i[index])); + } + free((void *)exts_i); + exts_i = NULL; + } +} +static int glad_gl_get_extensions( const char **out_exts, char ***out_exts_i) { +#if defined(GL_ES_VERSION_3_0) || defined(GL_VERSION_3_0) + if (glad_glGetStringi != NULL && glad_glGetIntegerv != NULL) { + unsigned int index = 0; + unsigned int num_exts_i = 0; + char **exts_i = NULL; + glad_glGetIntegerv(GL_NUM_EXTENSIONS, (int*) &num_exts_i); + exts_i = (char **) malloc((num_exts_i + 1) * (sizeof *exts_i)); + if (exts_i == NULL) { + return 0; + } + for(index = 0; index < num_exts_i; index++) { + const char *gl_str_tmp = (const char*) glad_glGetStringi(GL_EXTENSIONS, index); + size_t len = strlen(gl_str_tmp) + 1; + + char *local_str = (char*) malloc(len * sizeof(char)); + if(local_str == NULL) { + exts_i[index] = NULL; + glad_gl_free_extensions(exts_i); + return 0; + } + + memcpy(local_str, gl_str_tmp, len * sizeof(char)); + exts_i[index] = local_str; + } + exts_i[index] = NULL; + + *out_exts_i = exts_i; + + return 1; + } +#else + GLAD_UNUSED(out_exts_i); +#endif + if (glad_glGetString == NULL) { + return 0; + } + *out_exts = (const char *)glad_glGetString(GL_EXTENSIONS); + return 1; +} +static int glad_gl_has_extension(const char *exts, char **exts_i, const char *ext) { + if(exts_i) { + unsigned int index; + for(index = 0; exts_i[index]; index++) { + const char *e = exts_i[index]; + if(strcmp(e, ext) == 0) { + return 1; + } + } + } else { + const char *extensions; + const char *loc; + const char *terminator; + extensions = exts; + if(extensions == NULL || ext == NULL) { + return 0; + } + while(1) { + loc = strstr(extensions, ext); + if(loc == NULL) { + return 0; + } + terminator = loc + strlen(ext); + if((loc == extensions || *(loc - 1) == ' ') && + (*terminator == ' ' || *terminator == '\0')) { + return 1; + } + extensions = terminator; + } + } + return 0; +} + +static GLADapiproc glad_gl_get_proc_from_userptr(void *userptr, const char* name) { + return (GLAD_GNUC_EXTENSION (GLADapiproc (*)(const char *name)) userptr)(name); +} + +static int glad_gl_find_extensions_gl(void) { + const char *exts = NULL; + char **exts_i = NULL; + if (!glad_gl_get_extensions(&exts, &exts_i)) return 0; + + GLAD_GL_KHR_debug = glad_gl_has_extension(exts, exts_i, "GL_KHR_debug"); + + glad_gl_free_extensions(exts_i); + + return 1; +} + +static int glad_gl_find_core_gl(void) { + int i; + const char* version; + const char* prefixes[] = { + "OpenGL ES-CM ", + "OpenGL ES-CL ", + "OpenGL ES ", + "OpenGL SC ", + NULL + }; + int major = 0; + int minor = 0; + version = (const char*) glad_glGetString(GL_VERSION); + if (!version) return 0; + for (i = 0; prefixes[i]; i++) { + const size_t length = strlen(prefixes[i]); + if (strncmp(version, prefixes[i], length) == 0) { + version += length; + break; + } + } + + GLAD_IMPL_UTIL_SSCANF(version, "%d.%d", &major, &minor); + + GLAD_GL_VERSION_1_0 = (major == 1 && minor >= 0) || major > 1; + GLAD_GL_VERSION_1_1 = (major == 1 && minor >= 1) || major > 1; + GLAD_GL_VERSION_1_2 = (major == 1 && minor >= 2) || major > 1; + GLAD_GL_VERSION_1_3 = (major == 1 && minor >= 3) || major > 1; + GLAD_GL_VERSION_1_4 = (major == 1 && minor >= 4) || major > 1; + GLAD_GL_VERSION_1_5 = (major == 1 && minor >= 5) || major > 1; + GLAD_GL_VERSION_2_0 = (major == 2 && minor >= 0) || major > 2; + GLAD_GL_VERSION_2_1 = (major == 2 && minor >= 1) || major > 2; + GLAD_GL_VERSION_3_0 = (major == 3 && minor >= 0) || major > 3; + GLAD_GL_VERSION_3_1 = (major == 3 && minor >= 1) || major > 3; + GLAD_GL_VERSION_3_2 = (major == 3 && minor >= 2) || major > 3; + GLAD_GL_VERSION_3_3 = (major == 3 && minor >= 3) || major > 3; + + return GLAD_MAKE_VERSION(major, minor); +} + +int gladLoadGLUserPtr( GLADuserptrloadfunc load, void *userptr) { + int version; + + glad_glGetString = (PFNGLGETSTRINGPROC) load(userptr, "glGetString"); + if(glad_glGetString == NULL) return 0; + version = glad_gl_find_core_gl(); + + glad_gl_load_GL_VERSION_1_0(load, userptr); + glad_gl_load_GL_VERSION_1_1(load, userptr); + glad_gl_load_GL_VERSION_1_2(load, userptr); + glad_gl_load_GL_VERSION_1_3(load, userptr); + glad_gl_load_GL_VERSION_1_4(load, userptr); + glad_gl_load_GL_VERSION_1_5(load, userptr); + glad_gl_load_GL_VERSION_2_0(load, userptr); + glad_gl_load_GL_VERSION_2_1(load, userptr); + glad_gl_load_GL_VERSION_3_0(load, userptr); + glad_gl_load_GL_VERSION_3_1(load, userptr); + glad_gl_load_GL_VERSION_3_2(load, userptr); + glad_gl_load_GL_VERSION_3_3(load, userptr); + + if (!glad_gl_find_extensions_gl()) return 0; + glad_gl_load_GL_KHR_debug(load, userptr); + + + + return version; +} + + +int gladLoadGL( GLADloadfunc load) { + return gladLoadGLUserPtr( glad_gl_get_proc_from_userptr, GLAD_GNUC_EXTENSION (void*) load); +} + + + + + + +#ifdef __cplusplus +} +#endif diff --git a/renderer/gl_draw.cpp b/renderer/gl_draw.cpp new file mode 100644 index 000000000..39eba361b --- /dev/null +++ b/renderer/gl_draw.cpp @@ -0,0 +1,819 @@ +/* +* Descent 3: Piccu Engine +* Copyright (C) 2024 Parallax Software +* Copyright (C) 2024 SaladBadger +* +* This program is free software: you can redistribute it and/or modify +* it under the terms of the GNU General Public License as published by +* the Free Software Foundation, either version 3 of the License, or +* (at your option) any later version. +* +* This program is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +* GNU General Public License for more details. +* +* You should have received a copy of the GNU General Public License +* along with this program. If not, see . +*/ +#include "gl_local.h" + +//The number of vertex attributes the legacy code used. +constexpr int NUM_LEGACY_VERTEX_ATTRIBS = 4; +//The count of vertices that each buffer will store +constexpr int NUM_VERTS_PER_BUFFER = 32000; + +struct color_array +{ + float r, g, b, a; +}; + +struct tex_array +{ + float s, t, r, w; +}; + +struct gl_vertex +{ + vector vert; + color_array color; + tex_array tex_coord; + tex_array tex_coord2; +}; + +gl_vertex GL_vertices[100]; + +float OpenGL_Alpha_factor = 1.0f; +float Alpha_multiplier = 1.0f; + +int OpenGL_polys_drawn; +int OpenGL_verts_processed; + +int Overlay_map = -1; +int Bump_map = 0; +int Bumpmap_ready = 0; +uint8_t Overlay_type = OT_NONE; +float Z_bias = 0.0f; + +bool OpenGL_blending_on = true; + +static GLuint drawbuffer; +//The next committed vertex is where to start writing vertex data to the buffer +static GLuint nextcommittedvertex; +static ShaderProgram drawshaders[4]; +static int lastdrawshader = -1; + +static GLuint drawvao; + +void GL_UseDrawVAO(void) +{ + glBindVertexArray(drawvao); +} + +int GL_CopyVertices(int numvertices) +{ + glBindBuffer(GL_ARRAY_BUFFER, drawbuffer); + if (nextcommittedvertex + numvertices > NUM_VERTS_PER_BUFFER) + nextcommittedvertex = 0; + + int startoffset = nextcommittedvertex; + + glBufferSubData(GL_ARRAY_BUFFER, startoffset * sizeof(gl_vertex), numvertices * sizeof(gl_vertex), GL_vertices); + + nextcommittedvertex += numvertices; + + return startoffset; +} + +void opengl_SetDrawDefaults(void) +{ + //Init shaders + extern const char* genericVertexBody; + extern const char* genericFragBody; + //No texturing + drawshaders[0].AttachSourcePreprocess(genericVertexBody, genericFragBody, false, false, false); + //Textured + drawshaders[1].AttachSourcePreprocess(genericVertexBody, genericFragBody, true, false, false); + //Textured and lightmapped + drawshaders[2].AttachSourcePreprocess(genericVertexBody, genericFragBody, true, true, false); + //Specular. + drawshaders[3].AttachSourcePreprocess(genericVertexBody, genericFragBody, true, false, true); + + lastdrawshader = -1; + + //Init draw buffers + glGenBuffers(1, &drawbuffer); + glBindBuffer(GL_ARRAY_BUFFER, drawbuffer); + size_t buffersize = NUM_VERTS_PER_BUFFER * sizeof(gl_vertex); + glBufferData(GL_ARRAY_BUFFER, buffersize, nullptr, GL_DYNAMIC_DRAW); + + //Init VAO and vertex state + glGenVertexArrays(1, &drawvao); + glBindVertexArray(drawvao); + + size_t offset = 0; + + //attrib 0: position + glEnableVertexAttribArray(0); + glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(gl_vertex), 0); + + //attrib 1: color + //glBufferData(GL_ARRAY_BUFFER, NUM_VERTS_PER_BUFFER * sizeof(color_array), nullptr, GL_DYNAMIC_DRAW); + glEnableVertexAttribArray(1); + glVertexAttribPointer(1, 4, GL_FLOAT, GL_FALSE, sizeof(gl_vertex), (const void*)offsetof(gl_vertex, color)); + + //attrib 2: uv + //glBufferData(GL_ARRAY_BUFFER, NUM_VERTS_PER_BUFFER * sizeof(tex_array), nullptr, GL_DYNAMIC_DRAW); + glEnableVertexAttribArray(2); + glVertexAttribPointer(2, 4, GL_FLOAT, GL_FALSE, sizeof(gl_vertex), (const void*)offsetof(gl_vertex, tex_coord)); + offset += sizeof(tex_array) * NUM_VERTS_PER_BUFFER; + + //attrib 3: uv 2 + //glBufferData(GL_ARRAY_BUFFER, NUM_VERTS_PER_BUFFER * sizeof(tex_array), nullptr, GL_DYNAMIC_DRAW); + glEnableVertexAttribArray(3); + glVertexAttribPointer(3, 4, GL_FLOAT, GL_FALSE, sizeof(gl_vertex), (const void*)offsetof(gl_vertex, tex_coord2)); + offset += sizeof(tex_array) * NUM_VERTS_PER_BUFFER; + + glBindBuffer(GL_ARRAY_BUFFER, 0); +} + +void GL_SelectDrawShader() +{ + //TODO: This will bind excessively because I don't know if the previous shader was overridden by something. + //This should probably be cleaned up + if (OpenGL_state.cur_alpha_type == AT_SPECULAR) + drawshaders[3].Use(); + else if (OpenGL_state.cur_texture_quality == 0) + drawshaders[0].Use(); + else if (OpenGL_state.cur_texture_quality != 0) + { + if (Overlay_type != OT_NONE) + drawshaders[2].Use(); + else + drawshaders[1].Use(); + } +} + +// Takes nv vertices and draws the 3D polygon defined by those vertices. +// Uses bitmap "handle" as a texture +void rend_DrawPolygon3D(int handle, g3Point** p, int nv, int map_type) +{ + g3Point* pnt; + int i; + float fr, fg, fb; + + ASSERT(nv < 100); + + /*if (OpenGL_state.cur_texture_quality == 0) + { + opengl_DrawFlatPolygon3D(p, nv); + return; + } + + if (Overlay_type != OT_NONE && UseMultitexture) + { + opengl_DrawMultitexturePolygon3D(handle, p, nv, map_type); + return; + }*/ + + float one_over_square_res = 1; + float xscalar = 1; + float yscalar = 1; + + GL_SelectDrawShader(); + + if (OpenGL_state.cur_light_state == LS_FLAT_GOURAUD || OpenGL_state.cur_texture_type == 0) + { + fr = GR_COLOR_RED(OpenGL_state.cur_color) / 255.0; + fg = GR_COLOR_GREEN(OpenGL_state.cur_color) / 255.0; + fb = GR_COLOR_BLUE(OpenGL_state.cur_color) / 255.0; + } + + if (UseMultitexture) + { + opengl_SetMultitextureBlendMode(false); + } + + if (OpenGL_state.cur_texture_quality != 0) + { + // make sure our bitmap is ready to be drawn + opengl_MakeBitmapCurrent(handle, map_type, 0); + opengl_MakeWrapTypeCurrent(handle, map_type, 0); + opengl_MakeFilterTypeCurrent(handle, map_type, 0); + + if (Overlay_type != OT_NONE) + { + one_over_square_res = 1.0 / GameLightmaps[Overlay_map].square_res; + xscalar = (float)GameLightmaps[Overlay_map].width * one_over_square_res; + yscalar = (float)GameLightmaps[Overlay_map].height * one_over_square_res; + // make sure our bitmap is ready to be drawn + opengl_MakeBitmapCurrent(Overlay_map, MAP_TYPE_LIGHTMAP, 1); + opengl_MakeWrapTypeCurrent(Overlay_map, MAP_TYPE_LIGHTMAP, 1); + opengl_MakeFilterTypeCurrent(Overlay_map, MAP_TYPE_LIGHTMAP, 1); + } + } + + float alpha = Alpha_multiplier * OpenGL_Alpha_factor; + + gl_vertex* vertp = GL_vertices; + + // Specify our coordinates + for (i = 0; i < nv; i++, vertp++) + { + pnt = p[i]; + + if (OpenGL_state.cur_alpha_type & ATF_VERTEX) + { + alpha = pnt->p3_a * Alpha_multiplier * OpenGL_Alpha_factor; + } + + // If we have a lighting model, apply the correct lighting! + if (OpenGL_state.cur_light_state != LS_NONE) + { + if (OpenGL_state.cur_light_state == LS_FLAT_GOURAUD) + { + vertp->color.r = fr; + vertp->color.g = fg; + vertp->color.b = fb; + vertp->color.a = alpha; + } + else + { + // Do lighting based on intesity (MONO) or colored (RGB) + if (OpenGL_state.cur_color_model == CM_MONO) + { + vertp->color.r = pnt->p3_l; + vertp->color.g = pnt->p3_l; + vertp->color.b = pnt->p3_l; + vertp->color.a = alpha; + } + else + { + vertp->color.r = pnt->p3_r; + vertp->color.g = pnt->p3_g; + vertp->color.b = pnt->p3_b; + vertp->color.a = alpha; + } + } + } + else + { + if (OpenGL_state.cur_texture_type != 0) + { + vertp->color.r = 1; + vertp->color.g = 1; + vertp->color.b = 1; + vertp->color.a = alpha; + } + else + { + vertp->color.r = fr; + vertp->color.g = fg; + vertp->color.b = fb; + vertp->color.a = alpha; + } + } + + if (OpenGL_state.cur_texture_type != 0) + { + // Texture this polygon! + float texw = 1.0 / (pnt->p3_z + Z_bias); + vertp->tex_coord.s = pnt->p3_u * texw; + vertp->tex_coord.t = pnt->p3_v * texw; + vertp->tex_coord.r = 0; + vertp->tex_coord.w = texw; + + if (Overlay_type != OT_NONE) + { + vertp->tex_coord2.s = pnt->p3_u2 * xscalar * texw; + vertp->tex_coord2.t = pnt->p3_v2 * yscalar * texw; + vertp->tex_coord2.r = 0; + vertp->tex_coord2.w = texw; + } + } + + // Finally, specify a vertex + vertp->vert.x = pnt->p3_sx; + vertp->vert.y = pnt->p3_sy; + + float z = std::max(0.f, std::min(1.0f, 1.0f - (1.0f / (pnt->p3_z + Z_bias)))); + vertp->vert.z = -z; + } + + // And draw! + int offset = GL_CopyVertices(nv); + glDrawArrays(GL_TRIANGLE_FAN, offset, nv); + OpenGL_polys_drawn++; + OpenGL_verts_processed += nv; + + CHECK_ERROR(10) +} + +// Takes nv vertices and draws the 2D polygon defined by those vertices. +// Uses bitmap "handle" as a texture +void rend_DrawPolygon2D(int handle, g3Point** p, int nv) +{ + ASSERT(nv < 100); + ASSERT(Overlay_type == OT_NONE); + + rend_DrawPolygon3D(handle, p, nv, MAP_TYPE_BITMAP); +} + +// draws a scaled 2d bitmap to our buffer +void rend_DrawScaledBitmap(int x1, int y1, int x2, int y2, + int bm, float u0, float v0, float u1, float v1, int color, float* alphas) +{ + g3Point* ptr_pnts[4]; + g3Point pnts[4]; + float r, g, b; + if (color != -1) + { + r = GR_COLOR_RED(color) / 255.0; + g = GR_COLOR_GREEN(color) / 255.0; + b = GR_COLOR_BLUE(color) / 255.0; + } + for (int i = 0; i < 4; i++) + { + if (color == -1) + pnts[i].p3_l = 1.0; + else + { + pnts[i].p3_r = r; + pnts[i].p3_g = g; + pnts[i].p3_b = b; + } + if (alphas) + { + pnts[i].p3_a = alphas[i]; + } + + pnts[i].p3_z = 1.0f; + pnts[i].p3_flags = PF_PROJECTED; + } + + pnts[0].p3_sx = x1; + pnts[0].p3_sy = y1; + pnts[0].p3_u = u0; + pnts[0].p3_v = v0; + pnts[1].p3_sx = x2; + pnts[1].p3_sy = y1; + pnts[1].p3_u = u1; + pnts[1].p3_v = v0; + pnts[2].p3_sx = x2; + pnts[2].p3_sy = y2; + pnts[2].p3_u = u1; + pnts[2].p3_v = v1; + pnts[3].p3_sx = x1; + pnts[3].p3_sy = y2; + pnts[3].p3_u = u0; + pnts[3].p3_v = v1; + ptr_pnts[0] = &pnts[0]; + ptr_pnts[1] = &pnts[1]; + ptr_pnts[2] = &pnts[2]; + ptr_pnts[3] = &pnts[3]; + rend_SetTextureType(TT_LINEAR); + rend_DrawPolygon2D(bm, ptr_pnts, 4); +} + +void rend_DrawScaledBitmapWithZ(int x1, int y1, int x2, int y2, + int bm, float u0, float v0, float u1, float v1, float zval, int color, float* alphas) +{ + g3Point* ptr_pnts[4]; + g3Point pnts[4]; + float r, g, b; + + if (color != -1) + { + r = GR_COLOR_RED(color) / 255.0; + g = GR_COLOR_GREEN(color) / 255.0; + b = GR_COLOR_BLUE(color) / 255.0; + } + + for (int i = 0; i < 4; i++) + { + if (color == -1) + pnts[i].p3_l = 1.0; + else + { + pnts[i].p3_r = r; + pnts[i].p3_g = g; + pnts[i].p3_b = b; + } + + if (alphas) + { + pnts[i].p3_a = alphas[i]; + } + + pnts[i].p3_z = zval; + pnts[i].p3_flags = PF_PROJECTED; + } + + + + pnts[0].p3_sx = x1; + pnts[0].p3_sy = y1; + pnts[0].p3_u = u0; + pnts[0].p3_v = v0; + + pnts[1].p3_sx = x2; + pnts[1].p3_sy = y1; + pnts[1].p3_u = u1; + pnts[1].p3_v = v0; + + pnts[2].p3_sx = x2; + pnts[2].p3_sy = y2; + pnts[2].p3_u = u1; + pnts[2].p3_v = v1; + + pnts[3].p3_sx = x1; + pnts[3].p3_sy = y2; + pnts[3].p3_u = u0; + pnts[3].p3_v = v1; + + ptr_pnts[0] = &pnts[0]; + ptr_pnts[1] = &pnts[1]; + ptr_pnts[2] = &pnts[2]; + ptr_pnts[3] = &pnts[3]; + + rend_SetTextureType(TT_LINEAR); + rend_DrawPolygon3D(bm, ptr_pnts, 4); +} + +// Fills a rectangle on the display +void rend_FillRect(ddgr_color color, int x1, int y1, int x2, int y2) +{ + int r = GR_COLOR_RED(color); + int g = GR_COLOR_GREEN(color); + int b = GR_COLOR_BLUE(color); + + int width = x2 - x1; + int height = y2 - y1; + + x1 += OpenGL_state.clip_x1; + y1 += OpenGL_state.clip_y1; + + glEnable(GL_SCISSOR_TEST); + glScissor(x1, OpenGL_state.screen_height - (height + y1), width, height); + glClearColor((float)r / 255.0, (float)g / 255.0, (float)b / 255.0, 0); + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + + width = OpenGL_state.clip_x2 - OpenGL_state.clip_x1; + height = OpenGL_state.clip_y2 - OpenGL_state.clip_y1; + + glScissor(OpenGL_state.clip_x1, OpenGL_state.screen_height - (OpenGL_state.clip_y1 + height), width, height); + glDisable(GL_SCISSOR_TEST); +} + +// Sets a pixel on the display +void rend_SetPixel(ddgr_color color, int x, int y) +{ + float r = (color >> 16 & 0xFF) / 255.f; + float g = (color >> 8 & 0xFF) / 255.f; + float b = (color & 0xFF) / 255.f; + + GL_SelectDrawShader(); + + GL_vertices[0].color.r = r; + GL_vertices[0].color.g = g; + GL_vertices[0].color.b = b; + GL_vertices[0].color.a = 1.0f; + + GL_vertices[0].vert.x = x; + GL_vertices[0].vert.y = y; + GL_vertices[0].vert.z = 0; + + //please do not call this function if you can avoid it. + int offset = GL_CopyVertices(1); + glDrawArrays(GL_POINTS, offset, 1); + + /*glColor3ub(r, g, b); + + glBegin(GL_POINTS); + glVertex2i(x, y); + glEnd();*/ +} + +// Sets a pixel on the display +ddgr_color rend_GetPixel(int x, int y) +{ + ddgr_color color[4]; + glReadPixels(x, (OpenGL_state.screen_height - 1) - y, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, (GLvoid*)color); + return color[0]; +} + +void rend_FillCircle(ddgr_color col, int x, int y, int rad) +{ +} + +void rend_DrawCircle(int x, int y, int rad) +{ +} + +// Sets up a font character to draw. We draw our fonts as pieces of textures +void rend_DrawFontCharacter(int bm_handle, int x1, int y1, int x2, int y2, float u, float v, float w, float h) +{ + g3Point* ptr_pnts[4]; + g3Point pnts[4]; + for (int i = 0; i < 4; i++) + { + pnts[i].p3_z = 1; // Make REALLY close! + pnts[i].p3_flags = PF_PROJECTED; + ptr_pnts[i] = &pnts[i]; + } + pnts[0].p3_sx = x1; + pnts[0].p3_sy = y1; + pnts[0].p3_u = u; + pnts[0].p3_v = v; + pnts[1].p3_sx = x2; + pnts[1].p3_sy = y1; + pnts[1].p3_u = u + w; + pnts[1].p3_v = v; + pnts[2].p3_sx = x2; + pnts[2].p3_sy = y2; + pnts[2].p3_u = u + w; + pnts[2].p3_v = v + h; + pnts[3].p3_sx = x1; + pnts[3].p3_sy = y2; + pnts[3].p3_u = u; + pnts[3].p3_v = v + h; + rend_DrawPolygon2D(bm_handle, ptr_pnts, 4); +} + +// Draws a line +void rend_DrawLine(int x1, int y1, int x2, int y2) +{ + int8_t atype; + light_state ltype; + texture_type ttype; + int color = OpenGL_state.cur_color; + + float r = GR_COLOR_RED(color) / 255.f; + float g = GR_COLOR_GREEN(color) / 255.f; + float b = GR_COLOR_BLUE(color) / 255.f; + + atype = OpenGL_state.cur_alpha_type; + ltype = OpenGL_state.cur_light_state; + ttype = OpenGL_state.cur_texture_type; + + rend_SetAlphaType(AT_ALWAYS); + rend_SetLighting(LS_NONE); + rend_SetTextureType(TT_FLAT); + + GL_SelectDrawShader(); + + GL_vertices[0].color.r = r; + GL_vertices[0].color.g = g; + GL_vertices[0].color.b = b; + GL_vertices[0].color.a = 1.0f; + GL_vertices[1].color = GL_vertices[0].color; + + //hack to avoid line clipping but this isn't working correctly yet, causes one corner to vanish. + GL_vertices[0].vert.x = x1 + 1.f; + GL_vertices[0].vert.y = y1 + 1.f; + GL_vertices[0].vert.z = 0; + GL_vertices[1].vert.x = x2 + 1.f; + GL_vertices[1].vert.y = y2 + 1.f; + GL_vertices[1].vert.z = 0; + + int offset = GL_CopyVertices(2); + glDrawArrays(GL_LINES, offset, 2); + + rend_SetAlphaType(atype); + rend_SetLighting(ltype); + rend_SetTextureType(ttype); +} + +// The font characteristics +static float rend_FontRed[4], rend_FontBlue[4], rend_FontGreen[4], rend_FontAlpha[4]; + +// Sets the argb characteristics of the font characters. color1 is the upper left and proceeds clockwise +void rend_SetCharacterParameters(ddgr_color color1, ddgr_color color2, ddgr_color color3, ddgr_color color4) +{ + rend_FontRed[0] = (float)(GR_COLOR_RED(color1) / 255.0f); + rend_FontRed[1] = (float)(GR_COLOR_RED(color2) / 255.0f); + rend_FontRed[2] = (float)(GR_COLOR_RED(color3) / 255.0f); + rend_FontRed[3] = (float)(GR_COLOR_RED(color4) / 255.0f); + rend_FontGreen[0] = (float)(GR_COLOR_GREEN(color1) / 255.0f); + rend_FontGreen[1] = (float)(GR_COLOR_GREEN(color2) / 255.0f); + rend_FontGreen[2] = (float)(GR_COLOR_GREEN(color3) / 255.0f); + rend_FontGreen[3] = (float)(GR_COLOR_GREEN(color4) / 255.0f); + rend_FontBlue[0] = (float)(GR_COLOR_BLUE(color1) / 255.0f); + rend_FontBlue[1] = (float)(GR_COLOR_BLUE(color2) / 255.0f); + rend_FontBlue[2] = (float)(GR_COLOR_BLUE(color3) / 255.0f); + rend_FontBlue[3] = (float)(GR_COLOR_BLUE(color4) / 255.0f); + rend_FontAlpha[0] = (color1 >> 24) / 255.0f; + rend_FontAlpha[1] = (color2 >> 24) / 255.0f; + rend_FontAlpha[2] = (color3 >> 24) / 255.0f; + rend_FontAlpha[3] = (color4 >> 24) / 255.0f; +} + +// Turns on/off multitexture blending +void opengl_SetMultitextureBlendMode(bool state) +{ + if (OpenGL_multitexture_state == state) + return; + OpenGL_multitexture_state = state; + if (state) + { + Last_texel_unit_set = 0; + } + else + { + Last_texel_unit_set = 0; + } +} + +// Takes nv vertices and draws the polygon defined by those vertices. Uses bitmap "handle" +// as a texture +void opengl_DrawMultitexturePolygon3D(int handle, g3Point** p, int nv, int map_type) +{ + Int3(); +} + +void opengl_DrawFlatPolygon3D(g3Point** p, int nv) +{ + Int3(); +} + +// Draws a line using the states of the renderer +void rend_DrawSpecialLine(g3Point* p0, g3Point* p1) +{ + float fr, fg, fb, alpha; + int i; + + fr = GR_COLOR_RED(OpenGL_state.cur_color); + fg = GR_COLOR_GREEN(OpenGL_state.cur_color); + fb = GR_COLOR_BLUE(OpenGL_state.cur_color); + + fr /= 255.0f; + fg /= 255.0f; + fb /= 255.0f; + + alpha = Alpha_multiplier * OpenGL_Alpha_factor; + + gl_vertex* vertp = GL_vertices; + + // And draw! + for (i = 0; i < 2; i++, vertp++) + { + color_array* colorp = &vertp->color; + + g3Point* pnt = p0; + + if (i == 1) + pnt = p1; + + if (OpenGL_state.cur_alpha_type & ATF_VERTEX) + alpha = pnt->p3_a * Alpha_multiplier * OpenGL_Alpha_factor; + + // If we have a lighting model, apply the correct lighting! + if (OpenGL_state.cur_light_state != LS_NONE) + { + if (OpenGL_state.cur_light_state == LS_FLAT_GOURAUD) + { + colorp->r = fr; colorp->g = fg, colorp->b = fb; colorp->a = alpha; + } + else + { + // Do lighting based on intesity (MONO) or colored (RGB) + if (OpenGL_state.cur_color_model == CM_MONO) + { + colorp->r = pnt->p3_uvl.l; colorp->g = pnt->p3_uvl.l; colorp->b = pnt->p3_uvl.l; colorp->a = alpha; + } + else + { + colorp->r = pnt->p3_uvl.r; colorp->g = pnt->p3_uvl.g; colorp->b = pnt->p3_uvl.r; colorp->a = alpha; + } + } + } + else + { + colorp->r = fr; colorp->g = fg, colorp->b = fb; colorp->a = alpha; + } + + // Finally, specify a vertex + float z = std::max(0., std::min(1.0, 1.0 - (1.0 / (pnt->p3_z + Z_bias)))); + + vertp->vert.x = pnt->p3_sx; vertp->vert.y = pnt->p3_sy; vertp->vert.z = -z; + //glVertex3f(pnt->p3_sx + x_add, pnt->p3_sy + y_add, -z); + } + + GL_SelectDrawShader(); + int offset = GL_CopyVertices(2); + glDrawArrays(GL_LINES, offset, 2); +} + +// Gets a pointer to a linear frame buffer +void rend_GetLFBLock(renderer_lfb* lfb) +{ +} + +// Releases an lfb lock +void rend_ReleaseLFBLock(renderer_lfb* lfb) +{ +} + +// Given a source x,y and width,height, draws any sized bitmap into the renderer lfb +void rend_DrawLFBBitmap(int sx, int sy, int w, int h, int dx, int dy, uint16_t* data, int rowsize) +{ +} + +// given a chunked bitmap, renders it. +void rend_DrawChunkedBitmap(chunked_bitmap* chunk, int x, int y, uint8_t alpha) +{ + int* bm_array = chunk->bm_array; + int w = chunk->w; + int h = chunk->h; + int piece_w = bm_w(bm_array[0], 0); + int piece_h = bm_h(bm_array[0], 0); + int screen_w, screen_h; + int i, t; + rend_SetZBufferState(0); + rend_GetProjectionParameters(&screen_w, &screen_h); + for (i = 0; i < h; i++) + { + for (t = 0; t < w; t++) + { + int dx = x + (piece_w * t); + int dy = y + (piece_h * i); + int dw, dh; + if ((dx + piece_w) > screen_w) + dw = piece_w - ((dx + piece_w) - screen_w); + else + dw = piece_w; + if ((dy + piece_h) > screen_h) + dh = piece_h - ((dy + piece_h) - screen_h); + else + dh = piece_h; + + float u2 = (float)dw / (float)piece_w; + float v2 = (float)dh / (float)piece_h; + rend_DrawSimpleBitmap(bm_array[i * w + t], dx, dy); + } + } + rend_SetZBufferState(1); +} + +// given a chunked bitmap, renders it.scaled +void rend_DrawScaledChunkedBitmap(chunked_bitmap* chunk, int x, int y, int neww, int newh, uint8_t alpha) +{ + int* bm_array = chunk->bm_array; + int w = chunk->w; + int h = chunk->h; + int piece_w; + int piece_h; + int screen_w, screen_h; + int i, t; + + float scalew, scaleh; + + scalew = ((float)neww) / ((float)chunk->pw); + scaleh = ((float)newh) / ((float)chunk->ph); + piece_w = scalew * ((float)bm_w(bm_array[0], 0)); + piece_h = scaleh * ((float)bm_h(bm_array[0], 0)); + rend_GetProjectionParameters(&screen_w, &screen_h); + rend_SetOverlayType(OT_NONE); + rend_SetLighting(LS_NONE); + rend_SetColorModel(CM_MONO); + rend_SetZBufferState(0); + rend_SetAlphaType(AT_CONSTANT_TEXTURE); + rend_SetAlphaValue(alpha); + rend_SetWrapType(WT_WRAP); + for (i = 0; i < h; i++) + { + for (t = 0; t < w; t++) + { + int dx = x + (piece_w * t); + int dy = y + (piece_h * i); + int dw, dh; + if ((dx + piece_w) > screen_w) + dw = piece_w - ((dx + piece_w) - screen_w); + else + dw = piece_w; + if ((dy + piece_h) > screen_h) + dh = piece_h - ((dy + piece_h) - screen_h); + else + dh = piece_h; + + float u2 = (float)dw / (float)piece_w; + float v2 = (float)dh / (float)piece_h; + rend_DrawScaledBitmap(dx, dy, dx + dw, dy + dh, bm_array[i * w + t], 0, 0, u2, v2); + + } + } + rend_SetZBufferState(1); +} + +// Draws a simple bitmap at the specified x,y location +void rend_DrawSimpleBitmap(int bm_handle, int x, int y) +{ + rend_SetAlphaType(AT_CONSTANT_TEXTURE); + rend_SetAlphaValue(255); + rend_SetLighting(LS_NONE); + rend_SetColorModel(CM_MONO); + rend_SetOverlayType(OT_NONE); + rend_SetFiltering(0); + rend_DrawScaledBitmap(x, y, x + bm_w(bm_handle, 0), y + bm_h(bm_handle, 0), bm_handle, 0, 0, 1, 1); + rend_SetFiltering(1); +} diff --git a/renderer/gl_framebuffer.cpp b/renderer/gl_framebuffer.cpp new file mode 100644 index 000000000..cec64096f --- /dev/null +++ b/renderer/gl_framebuffer.cpp @@ -0,0 +1,259 @@ +/* +* Piccu Engine +* Copyright (C) 2024 SaladBadger +* +* This program is free software: you can redistribute it and/or modify +* it under the terms of the GNU General Public License as published by +* the Free Software Foundation, either version 3 of the License, or +* (at your option) any later version. +* +* This program is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +* GNU General Public License for more details. +* +* You should have received a copy of the GNU General Public License +* along with this program. If not, see . +*/ +#include "gl_local.h" + +static GLuint fbVAOName; +static GLuint fbVBOName; + +static const float framebuffer_buffer[] = { -1.0f, -3.0f, 0.0f, 0.0f, + -1.0f, 1.0f, 0.0f, 2.0f, + 3.0f, 1.0f, 2.0f, 2.0f }; + +void GL_InitFramebufferVAO(void) +{ + if (fbVAOName) + return; + + glGenVertexArrays(1, &fbVAOName); + glGenBuffers(1, &fbVBOName); + + glBindVertexArray(fbVAOName); + glBindBuffer(GL_ARRAY_BUFFER, fbVBOName); + glBufferData(GL_ARRAY_BUFFER, sizeof(framebuffer_buffer), framebuffer_buffer, GL_STATIC_DRAW); + + glEnableVertexAttribArray(0); + glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(float) * 4, 0); + glEnableVertexAttribArray(1); + glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, sizeof(float) * 4, (GLvoid*)(sizeof(float) * 2)); + + glBindBuffer(GL_ARRAY_BUFFER, 0); + GL_UseDrawVAO(); + //glBindVertexArray(0); +} + +void GL_DestroyFramebufferVAO(void) +{ + glDeleteBuffers(1, &fbVBOName); + glDeleteVertexArrays(1, &fbVAOName); + fbVBOName = fbVAOName = 0; +} + +Framebuffer::Framebuffer() +{ + m_width = m_height = 0; + m_name = m_subname = m_colorname = m_subcolorname = m_depthname = 0; + m_msaa = false; +} + +constexpr int SAMPLE_COUNT = 8; + +void Framebuffer::Update(int width, int height, bool msaa) +{ + if (width == m_width && height == m_height && msaa == m_msaa) + return; + + m_width = width; + m_height = height; + m_msaa = msaa; + + + //The solution to all problems with changing framebuffer status is to delete everything and start over. + if (!msaa && m_subname != 0) + { + glBindFramebuffer(GL_FRAMEBUFFER, 0); + Destroy(); + } + else if (msaa && m_name != 0 && m_subname == 0) + { + glBindFramebuffer(GL_FRAMEBUFFER, 0); + Destroy(); + } + + glActiveTexture(GL_TEXTURE0); + if (m_name == 0) + { + glGenTextures(1, &m_colorname); + glGenTextures(1, &m_depthname); + glGenFramebuffers(1, &m_name); + } + + GLenum textureType = msaa ? GL_TEXTURE_2D_MULTISAMPLE : GL_TEXTURE_2D; + + if (msaa) + { + //Create the sub framebuffer now if it hasn't already been. + //When multisampling is used, the sub framebuffer is a non-multisampled framebuffer for the main framebuffer to resolve to. + if (m_subname == 0) + { + glGenTextures(1, &m_subcolorname); + glGenFramebuffers(1, &m_subname); + } + + glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, m_colorname); + glTexImage2DMultisample(GL_TEXTURE_2D_MULTISAMPLE, SAMPLE_COUNT, GL_RGBA8, OpenGL_state.screen_width, OpenGL_state.screen_height, GL_FALSE); + + glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, m_depthname); + glTexImage2DMultisample(GL_TEXTURE_2D_MULTISAMPLE, SAMPLE_COUNT, GL_DEPTH_COMPONENT32F, OpenGL_state.screen_width, OpenGL_state.screen_height, GL_FALSE); + + glBindTexture(GL_TEXTURE_2D, m_subcolorname); + glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB8, OpenGL_state.screen_width, OpenGL_state.screen_height, 0, GL_RGB, GL_UNSIGNED_BYTE, nullptr); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); + + //Do attachment for the sub framebuffer + glBindFramebuffer(GL_FRAMEBUFFER, m_subname); + glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_subcolorname, 0); + + GLenum fbstatus = glCheckFramebufferStatus(GL_FRAMEBUFFER); + if (fbstatus != GL_FRAMEBUFFER_COMPLETE) + { + Error("Framebuffer::Update: Sub framebuffer object is incomplete!"); + } + + glEnable(GL_MULTISAMPLE); + } + else + { + glBindTexture(GL_TEXTURE_2D, m_colorname); + glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB8, OpenGL_state.screen_width, OpenGL_state.screen_height, 0, GL_RGB, GL_UNSIGNED_BYTE, nullptr); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); + + glBindTexture(GL_TEXTURE_2D, m_depthname); + glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT32F, OpenGL_state.screen_width, OpenGL_state.screen_height, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_BYTE, nullptr); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); + } + + OpenGL_last_bound[0] = -1; + OpenGL_last_bound[1] = -1; + Last_texel_unit_set = -1; + + glBindFramebuffer(GL_FRAMEBUFFER, m_name); + glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, textureType, m_colorname, 0); + glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, textureType, m_depthname, 0); + + GLenum fbstatus = glCheckFramebufferStatus(GL_FRAMEBUFFER); + if (fbstatus != GL_FRAMEBUFFER_COMPLETE) + { + Error("Framebuffer::Update: Framebuffer object is incomplete!"); + } +} + +void Framebuffer::Destroy() +{ + glDeleteTextures(1, &m_colorname); + glDeleteTextures(1, &m_depthname); + glDeleteFramebuffers(1, &m_name); + m_name = m_colorname = m_depthname = 0; + + glDeleteFramebuffers(1, &m_subname); + glDeleteTextures(1, &m_subcolorname); + m_subname = m_subcolorname = 0; +} + +void Framebuffer::SubColorBlit() +{ + if (!m_msaa) + { + glBindFramebuffer(GL_READ_FRAMEBUFFER, m_name); + } + else + { + glBindFramebuffer(GL_READ_FRAMEBUFFER, m_name); + glBindFramebuffer(GL_DRAW_FRAMEBUFFER, m_subname); + glBlitFramebuffer(0, 0, m_width, m_height, 0, 0, + m_width, m_height, GL_COLOR_BUFFER_BIT, GL_NEAREST); + + GLenum err = glGetError(); + if (err != GL_NO_ERROR) + { + mprintf((0, "Error resolving multisampling: %d\n", err)); + } + + //Leave the sub color buffer bound for reading by BlitToRaw. + glBindFramebuffer(GL_READ_FRAMEBUFFER, m_subname); + } +} + +void Framebuffer::BlitToRaw(GLuint target, unsigned int x, unsigned int y, unsigned int w, unsigned int h) +{ + SubColorBlit(); + glBindFramebuffer(GL_DRAW_FRAMEBUFFER, target); + + GLenum err = glGetError(); + if (err != GL_NO_ERROR) + { + mprintf((0, "Error unbinding draw framebuffer: %d\n", err)); + } + + glClearColor(0.0, 0.0, 0.0, 1.0); + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + + glBlitFramebuffer(0, 0, m_width, m_height, + x, y, x + w, y + h, GL_COLOR_BUFFER_BIT, GL_NEAREST); +} + +void Framebuffer::BlitTo(GLuint target, unsigned int x, unsigned int y, unsigned int w, unsigned int h) +{ + SubColorBlit(); + + GLenum err = glGetError(); + if (err != GL_NO_ERROR) + { + mprintf((0, "Error leaving sub color blit: %d\n", err)); + } + + glBindVertexArray(fbVAOName); + GLint oldviewport[4]; + glGetIntegerv(GL_VIEWPORT, oldviewport); + glViewport(x, y, w, h); + + glBindFramebuffer(GL_DRAW_FRAMEBUFFER, target); + glBindFramebuffer(GL_READ_FRAMEBUFFER, 0); + + err = glGetError(); + if (err != GL_NO_ERROR) + { + mprintf((0, "Error binding framebuffers: %d\n", err)); + } + + + Last_texel_unit_set = 0; + //glClientActiveTextureARB(GL_TEXTURE0); + glActiveTexture(GL_TEXTURE0); + + GLuint sourcename = m_msaa ? m_subcolorname : m_colorname; + OpenGL_last_bound[0] = sourcename; + glEnable(GL_TEXTURE_2D); + glBindTexture(GL_TEXTURE_2D, sourcename); + err = glGetError(); + if (err != GL_NO_ERROR) + { + mprintf((0, "Error unbinding draw framebuffer: %d\n", err)); + } + + glClearColor(0.0, 0.0, 0.0, 1.0); + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + + glDrawArrays(GL_TRIANGLES, 0, 3); + + //glBindVertexArray(0); + GL_UseDrawVAO(); + glViewport(oldviewport[0], oldviewport[1], oldviewport[2], oldviewport[3]); +} diff --git a/renderer/gl_image.cpp b/renderer/gl_image.cpp new file mode 100644 index 000000000..b0175eebe --- /dev/null +++ b/renderer/gl_image.cpp @@ -0,0 +1,918 @@ +/* +* Descent 3: Piccu Engine +* Copyright (C) 2024 Parallax Software +* Copyright (C) 2024 SaladBadger +* +* This program is free software: you can redistribute it and/or modify +* it under the terms of the GNU General Public License as published by +* the Free Software Foundation, either version 3 of the License, or +* (at your option) any later version. +* +* This program is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +* GNU General Public License for more details. +* +* You should have received a copy of the GNU General Public License +* along with this program. If not, see . +*/ +#include +#include "gl_local.h" + +#ifndef GL_UNSIGNED_SHORT_5_5_5_1 +#define GL_UNSIGNED_SHORT_5_5_5_1 0x8034 +#endif + +#ifndef GL_UNSIGNED_SHORT_4_4_4_4 +#define GL_UNSIGNED_SHORT_4_4_4_4 0x8033 +#endif + +uint16_t* OpenGL_bitmap_remap = NULL; +uint16_t* OpenGL_lightmap_remap = NULL; +uint8_t* OpenGL_bitmap_states = NULL; +uint8_t* OpenGL_lightmap_states = NULL; + +unsigned int opengl_last_upload_res = 0; +uint* opengl_Upload_data = NULL; +uint* opengl_Translate_table = NULL; +uint* opengl_4444_translate_table = NULL; + +uint16_t* opengl_packed_Upload_data = NULL; +uint16_t* opengl_packed_Translate_table = NULL; +uint16_t* opengl_packed_4444_translate_table = NULL; + +//Texture list +GLuint texture_name_list[10000]; +int Cur_texture_object_num = 1; +int Last_texel_unit_set = -1; + +int OpenGL_last_bound[2]; +int OpenGL_sets_this_frame[10]; +int OpenGL_uploads; + +bool OpenGL_cache_initted; + +void opengl_InitImages(void) +{ + memset(texture_name_list, 0, sizeof(texture_name_list)); + Cur_texture_object_num = 1; + Last_texel_unit_set = -1; +} + +void opengl_FreeImages(void) +{ + uint* delete_list = (uint*)mem_malloc(Cur_texture_object_num * sizeof(int)); + ASSERT(delete_list); + for (int i = 1; i < Cur_texture_object_num; i++) + delete_list[i] = i; + + if (Cur_texture_object_num > 1) + glDeleteTextures(Cur_texture_object_num, (const uint*)delete_list); + + mem_free(delete_list); +} + +int opengl_MakeTextureObject(int tn) +{ + int num = Cur_texture_object_num; + + Cur_texture_object_num++; + + if (texture_name_list[num] == 0) + glGenTextures(1, &texture_name_list[num]); + + if (UseMultitexture && Last_texel_unit_set != tn) + { + glActiveTexture(GL_TEXTURE0 + tn); + Last_texel_unit_set = tn; + } + + num = texture_name_list[num]; + + glBindTexture(GL_TEXTURE_2D, num); + glPixelStorei(GL_UNPACK_ALIGNMENT, 2); + + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); + + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); + + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, NUM_MIP_LEVELS - 1); + + //glTexEnvf (GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_MODULATE); + + CHECK_ERROR(2) + + return num; +} + +extern bool Force_one_texture; + +// Utilizes a LRU cacheing scheme to select/upload textures the opengl driver +int opengl_MakeBitmapCurrent(int handle, int map_type, int tn) +{ + int w, h; + int texnum; + + if (map_type == MAP_TYPE_LIGHTMAP) + { + w = GameLightmaps[handle].square_res; + h = GameLightmaps[handle].square_res; + } + else + { + if (Force_one_texture) + { + handle = 0; + } + + w = bm_w(handle, 0); + h = bm_h(handle, 0); + } + + // See if the bitmaps is already in the cache + if (map_type == MAP_TYPE_LIGHTMAP) + { + if (OpenGL_lightmap_remap[handle] == 65535) + { + texnum = opengl_MakeTextureObject(tn); + SET_WRAP_STATE(OpenGL_lightmap_states[handle], WT_WRAP); + SET_FILTER_STATE(OpenGL_lightmap_states[handle], 0); + OpenGL_lightmap_remap[handle] = texnum; + opengl_TranslateBitmapToOpenGL(texnum, handle, map_type, 0, tn); + } + else + { + texnum = OpenGL_lightmap_remap[handle]; + if (GameLightmaps[handle].flags & LF_CHANGED) + opengl_TranslateBitmapToOpenGL(texnum, handle, map_type, 1, tn); + } + } + else + { + if (OpenGL_bitmap_remap[handle] == 65535) + { + texnum = opengl_MakeTextureObject(tn); + SET_WRAP_STATE(OpenGL_bitmap_states[handle], WT_WRAP); + SET_FILTER_STATE(OpenGL_bitmap_states[handle], 0); + OpenGL_bitmap_remap[handle] = texnum; + opengl_TranslateBitmapToOpenGL(texnum, handle, map_type, 0, tn); + } + else + { + texnum = OpenGL_bitmap_remap[handle]; + if (GameBitmaps[handle].flags & BF_CHANGED) + { + opengl_TranslateBitmapToOpenGL(texnum, handle, map_type, 1, tn); + } + } + } + + if (OpenGL_last_bound[tn] != texnum) + { + if (UseMultitexture && Last_texel_unit_set != tn) + { + glActiveTexture(GL_TEXTURE0 + tn); + Last_texel_unit_set = tn; + } + + glBindTexture(GL_TEXTURE_2D, texnum); + OpenGL_last_bound[tn] = texnum; + OpenGL_sets_this_frame[0]++; + } + + CHECK_ERROR(7) + return 1; +} + +// Sets up an appropriate wrap type for the current bound texture +void opengl_MakeWrapTypeCurrent(int handle, int map_type, int tn) +{ + int uwrap; + wrap_type dest_wrap; + + if (tn == 1) + dest_wrap = WT_CLAMP; + else + dest_wrap = OpenGL_state.cur_wrap_type; + + if (map_type == MAP_TYPE_LIGHTMAP) + uwrap = GET_WRAP_STATE(OpenGL_lightmap_states[handle]); + else + uwrap = GET_WRAP_STATE(OpenGL_bitmap_states[handle]); + + if (uwrap == dest_wrap) + return; + + if (UseMultitexture && Last_texel_unit_set != tn) + { + glActiveTexture(GL_TEXTURE0 + tn); + Last_texel_unit_set = tn; + } + + OpenGL_sets_this_frame[1]++; + + if (dest_wrap == WT_CLAMP) + { + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); + + } + else if (dest_wrap == WT_WRAP_V) + { + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); + } + else + { + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); + } + + if (map_type == MAP_TYPE_LIGHTMAP) + { + SET_WRAP_STATE(OpenGL_lightmap_states[handle], dest_wrap); + } + else + { + SET_WRAP_STATE(OpenGL_bitmap_states[handle], dest_wrap); + } + + CHECK_ERROR(8) +} + +// Chooses the correct filter type for the currently bound texture +void opengl_MakeFilterTypeCurrent(int handle, int map_type, int tn) +{ + int magf, mmip; + int8_t dest_filter, dest_mip; + + if (map_type == MAP_TYPE_LIGHTMAP) + { + magf = GET_FILTER_STATE(OpenGL_lightmap_states[handle]); + mmip = GET_MIP_STATE(OpenGL_lightmap_states[handle]); + dest_filter = 1; + dest_mip = 0; + } + else + { + magf = GET_FILTER_STATE(OpenGL_bitmap_states[handle]); + mmip = GET_MIP_STATE(OpenGL_bitmap_states[handle]); + dest_filter = OpenGL_preferred_state.filtering; + if (!OpenGL_state.cur_bilinear_state) + dest_filter = 0; + dest_mip = OpenGL_preferred_state.mipping; + if (!OpenGL_state.cur_mip_state || !bm_mipped(handle)) + dest_mip = 0; + } + + if (magf == dest_filter && mmip == dest_mip) + return; + if (UseMultitexture && Last_texel_unit_set != tn) + { + glActiveTexture(GL_TEXTURE0 + tn); + Last_texel_unit_set = tn; + } + + GLenum mag_filter = dest_filter ? GL_LINEAR : GL_NEAREST; + GLenum min_filter; + if (dest_mip) + { + min_filter = dest_filter ? GL_LINEAR_MIPMAP_LINEAR : GL_NEAREST_MIPMAP_NEAREST; + //This is a bit hacky, this should be set once at texture creation. + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, NUM_MIP_LEVELS - 1); + } + else + { + min_filter = dest_filter ? GL_LINEAR : GL_NEAREST; + } + + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, mag_filter); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, min_filter); + + OpenGL_sets_this_frame[2]++; + + if (map_type == MAP_TYPE_LIGHTMAP) + { + SET_FILTER_STATE(OpenGL_lightmap_states[handle], dest_filter); + SET_MIP_STATE(OpenGL_lightmap_states[handle], dest_mip); + } + else + { + SET_FILTER_STATE(OpenGL_bitmap_states[handle], dest_filter); + SET_MIP_STATE(OpenGL_bitmap_states[handle], dest_mip); + } + + CHECK_ERROR(9) +} + +int opengl_InitCache(void) +{ + OpenGL_bitmap_remap = (uint16_t*)mem_malloc(MAX_BITMAPS * 2); + ASSERT(OpenGL_bitmap_remap); + OpenGL_lightmap_remap = (uint16_t*)mem_malloc(MAX_LIGHTMAPS * 2); + ASSERT(OpenGL_lightmap_remap); + + OpenGL_bitmap_states = (uint8_t*)mem_malloc(MAX_BITMAPS); + ASSERT(OpenGL_bitmap_states); + OpenGL_lightmap_states = (uint8_t*)mem_malloc(MAX_LIGHTMAPS); + ASSERT(OpenGL_lightmap_states); + + Cur_texture_object_num = 1; + + // Setup textures and cacheing + int i; + for (i = 0; i < MAX_BITMAPS; i++) + { + OpenGL_bitmap_remap[i] = 65535; + OpenGL_bitmap_states[i] = 255; + GameBitmaps[i].flags |= BF_CHANGED | BF_BRAND_NEW; + } + + for (i = 0; i < MAX_LIGHTMAPS; i++) + { + OpenGL_lightmap_remap[i] = 65535; + OpenGL_lightmap_states[i] = 255; + GameLightmaps[i].flags |= LF_CHANGED | LF_BRAND_NEW; + } + + /*glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); + + if (UseMultitexture) + { + glActiveTexture(GL_TEXTURE0 + 1); + glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); + glActiveTexture(GL_TEXTURE0 + 0); + }*/ + + CHECK_ERROR(3); + + OpenGL_cache_initted = true; + return 1; +} + +void opengl_FreeCache(void) +{ + if (OpenGL_cache_initted) + { + mem_free(OpenGL_lightmap_remap); + mem_free(OpenGL_bitmap_remap); + mem_free(OpenGL_lightmap_states); + mem_free(OpenGL_bitmap_states); + OpenGL_cache_initted = false; + } +} + +// Resets the texture cache +void opengl_ResetCache(void) +{ + if (OpenGL_cache_initted) + { + mem_free(OpenGL_lightmap_remap); + mem_free(OpenGL_bitmap_remap); + mem_free(OpenGL_lightmap_states); + mem_free(OpenGL_bitmap_states); + OpenGL_cache_initted = false; + } + + opengl_InitCache(); +} + +void opengl_FreeUploadBuffers(void) +{ + if (OpenGL_packed_pixels) + { + if (opengl_packed_Upload_data) + { + mem_free(opengl_packed_Upload_data); + } + if (opengl_packed_Translate_table) + { + mem_free(opengl_packed_Translate_table); + } + if (opengl_packed_4444_translate_table) + { + mem_free(opengl_packed_4444_translate_table); + } + opengl_packed_Upload_data = NULL; + opengl_packed_Translate_table = NULL; + opengl_packed_4444_translate_table = NULL; + } + else + { + if (opengl_Upload_data) + mem_free(opengl_Upload_data); + if (opengl_Translate_table) + mem_free(opengl_Translate_table); + if (opengl_4444_translate_table) + mem_free(opengl_4444_translate_table); + opengl_Upload_data = NULL; + opengl_Translate_table = NULL; + opengl_4444_translate_table = NULL; + } + opengl_last_upload_res = 0; +} + +void opengl_SetUploadBufferSize(int width, int height) +{ + if ((width * height) <= opengl_last_upload_res) + return; + + opengl_FreeUploadBuffers(); + + if (OpenGL_packed_pixels) + { + opengl_packed_Upload_data = (uint16_t*)mem_malloc(width * height * 2); + opengl_packed_Translate_table = (uint16_t*)mem_malloc(65536 * 2); + opengl_packed_4444_translate_table = (uint16_t*)mem_malloc(65536 * 2); + + ASSERT(opengl_packed_Upload_data); + ASSERT(opengl_packed_Translate_table); + ASSERT(opengl_packed_4444_translate_table); + + mprintf((0, "Building packed OpenGL translate table...\n")); + + for (int i = 0; i < 65536; i++) + { + int r = (i >> 10) & 0x1f; + int g = (i >> 5) & 0x1f; + int b = i & 0x1f; + +#ifdef BRIGHTNESS_HACK + r *= BRIGHTNESS_HACK; + g *= BRIGHTNESS_HACK; + b *= BRIGHTNESS_HACK; + if (r > 0x1F) r = 0x1F; + if (g > 0x1F) g = 0x1F; + if (b > 0x1F) b = 0x1F; +#endif + + uint16_t pix; + + if (!(i & OPAQUE_FLAG)) + { + pix = 0; + } + else + { + pix = (r << 11) | (g << 6) | (b << 1) | 1; + } + + opengl_packed_Translate_table[i] = pix; + + // 4444 table + int a = (i >> 12) & 0xf; + r = (i >> 8) & 0xf; + g = (i >> 4) & 0xf; + b = i & 0xf; + + pix = (r << 12) | (g << 8) | (b << 4) | a; + opengl_packed_4444_translate_table[i] = pix; + } + } + else + { + opengl_Upload_data = (uint*)mem_malloc(width * height * 4); + opengl_Translate_table = (uint*)mem_malloc(65536 * 4); + opengl_4444_translate_table = (uint*)mem_malloc(65536 * 4); + + ASSERT(opengl_Upload_data); + ASSERT(opengl_Translate_table); + ASSERT(opengl_4444_translate_table); + + mprintf((0, "Building OpenGL translate table...\n")); + + for (int i = 0; i < 65536; i++) + { + uint pix; + int r = (i >> 10) & 0x1f; + int g = (i >> 5) & 0x1f; + int b = i & 0x1f; + +#ifdef BRIGHTNESS_HACK + r *= BRIGHTNESS_HACK; + g *= BRIGHTNESS_HACK; + b *= BRIGHTNESS_HACK; + if (r > 0x1F) r = 0x1F; + if (g > 0x1F) g = 0x1F; + if (b > 0x1F) b = 0x1F; +#endif + + float fr = (float)r / 31.0f; + float fg = (float)g / 31.0f; + float fb = (float)b / 31.0f; + + r = 255 * fr; + g = 255 * fg; + b = 255 * fb; + + if (!(i & OPAQUE_FLAG)) + { + pix = 0; + } + else + { + pix = (255 << 24) | (b << 16) | (g << 8) | (r); + } + + opengl_Translate_table[i] = pix; + + // Do 4444 + int a = (i >> 12) & 0xf; + r = (i >> 8) & 0xf; + g = (i >> 4) & 0xf; + b = i & 0xf; + + float fa = (float)a / 15.0f; + fr = (float)r / 15.0f; + fg = (float)g / 15.0f; + fb = (float)b / 15.0f; + + a = 255 * fa; + r = 255 * fr; + g = 255 * fg; + b = 255 * fb; + + pix = (a << 24) | (b << 16) | (g << 8) | (r); + + opengl_4444_translate_table[i] = pix; + } + } + + opengl_last_upload_res = width * height; +} + +// Takes our 16bit format and converts it into the memory scheme that OpenGL wants +void opengl_TranslateBitmapToOpenGL(int texnum, int bm_handle, int map_type, int replace, int tn) +{ + uint16_t* bm_ptr; + + int w, h; + int size; + + if (UseMultitexture && Last_texel_unit_set != tn) + { + glActiveTexture(GL_TEXTURE0 + tn); + Last_texel_unit_set = tn; + } + + if (map_type == MAP_TYPE_LIGHTMAP) + { + if (GameLightmaps[bm_handle].flags & LF_BRAND_NEW) + replace = 0; + + bm_ptr = lm_data(bm_handle); + GameLightmaps[bm_handle].flags &= ~(LF_CHANGED | LF_BRAND_NEW); + + w = lm_w(bm_handle); + h = lm_h(bm_handle); + size = GameLightmaps[bm_handle].square_res; + } + else + { + if (GameBitmaps[bm_handle].flags & BF_BRAND_NEW) + replace = 0; + + bm_ptr = bm_data(bm_handle, 0); + GameBitmaps[bm_handle].flags &= ~(BF_CHANGED | BF_BRAND_NEW); + w = bm_w(bm_handle, 0); + h = bm_h(bm_handle, 0); + size = w; + } + + if (OpenGL_last_bound[tn] != texnum) + { + glBindTexture(GL_TEXTURE_2D, texnum); + OpenGL_sets_this_frame[0]++; + OpenGL_last_bound[tn] = texnum; + } + + opengl_SetUploadBufferSize(w, h); + + int i; + + if (OpenGL_packed_pixels) + { + if (map_type == MAP_TYPE_LIGHTMAP) + { + uint16_t* left_data = (uint16_t*)opengl_packed_Upload_data; + int bm_left = 0; + + for (int i = 0; i < h; i++, left_data += size, bm_left += w) + { + uint16_t* dest_data = left_data; + for (int t = 0; t < w; t++) + { + *dest_data++ = opengl_packed_Translate_table[bm_ptr[bm_left + t]]; + } + } + + if (replace) + { + glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, size, size, GL_RGBA, GL_UNSIGNED_SHORT_5_5_5_1, opengl_packed_Upload_data); + } + else + { + glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB5_A1, size, size, 0, GL_RGBA, GL_UNSIGNED_SHORT_5_5_5_1, opengl_packed_Upload_data); + } + } + else + { + int limit = 0; + + if (bm_mipped(bm_handle)) + { + limit = NUM_MIP_LEVELS; + } + else + { + limit = 1; + } + + for (int m = 0; m < limit; m++) + { + if (m < NUM_MIP_LEVELS) + { + bm_ptr = bm_data(bm_handle, m); + w = bm_w(bm_handle, m); + h = bm_h(bm_handle, m); + } + else + { + bm_ptr = bm_data(bm_handle, NUM_MIP_LEVELS - 1); + w = bm_w(bm_handle, NUM_MIP_LEVELS - 1); + h = bm_h(bm_handle, NUM_MIP_LEVELS - 1); + + w >>= m - (NUM_MIP_LEVELS - 1); + h >>= m - (NUM_MIP_LEVELS - 1); + + if ((w < 1) || (h < 1)) + continue; + + } + + if (bm_format(bm_handle) == BITMAP_FORMAT_4444) + { + // Do 4444 + for (i = 0; i < w * h; i++) + opengl_packed_Upload_data[i] = opengl_packed_4444_translate_table[bm_ptr[i]]; + + if (replace) + { + glTexSubImage2D(GL_TEXTURE_2D, m, 0, 0, w, h, GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4, opengl_packed_Upload_data); + } + else + { + glTexImage2D(GL_TEXTURE_2D, m, GL_RGBA4, w, h, 0, GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4, opengl_packed_Upload_data); + } + } + else + { + // Do 1555 + for (i = 0; i < w * h; i++) + { + opengl_packed_Upload_data[i] = opengl_packed_Translate_table[bm_ptr[i]]; + } + + if (replace) + { + glTexSubImage2D(GL_TEXTURE_2D, m, 0, 0, w, h, GL_RGBA, GL_UNSIGNED_SHORT_5_5_5_1, opengl_packed_Upload_data); + } + else + { + glTexImage2D(GL_TEXTURE_2D, m, GL_RGB5_A1, w, h, 0, GL_RGBA, GL_UNSIGNED_SHORT_5_5_5_1, opengl_packed_Upload_data); + } + } + } + } + } + else + { + if (map_type == MAP_TYPE_LIGHTMAP) + { + uint* left_data = (uint*)opengl_Upload_data; + int bm_left = 0; + + for (int i = 0; i < h; i++, left_data += size, bm_left += w) + { + uint* dest_data = left_data; + for (int t = 0; t < w; t++) + { + *dest_data++ = opengl_Translate_table[bm_ptr[bm_left + t]]; + } + } + if (size > 0) + { + if (replace) + { + glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, size, size, GL_RGBA, GL_UNSIGNED_BYTE, opengl_Upload_data); + } + else + { + glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, size, size, 0, GL_RGBA, GL_UNSIGNED_BYTE, opengl_Upload_data); + } + } + } + else + { + int limit = 0; + + if (bm_mipped(bm_handle)) + { + limit = NUM_MIP_LEVELS; + } + else + { + limit = 1; + } + + for (int m = 0; m < limit; m++) + { + bm_ptr = bm_data(bm_handle, m); + w = bm_w(bm_handle, m); + h = bm_h(bm_handle, m); + + if (bm_format(bm_handle) == BITMAP_FORMAT_4444) + { + // Do 4444 + for (i = 0; i < w * h; i++) + opengl_Upload_data[i] = opengl_4444_translate_table[bm_ptr[i]]; + } + else + { + // Do 1555 + + for (i = 0; i < w * h; i++) + opengl_Upload_data[i] = opengl_Translate_table[bm_ptr[i]]; + } + + //rcg06262000 my if wrapper. + if ((w > 0) && (h > 0)) + { + if (replace) + { + glTexSubImage2D(GL_TEXTURE_2D, m, 0, 0, w, h, GL_RGBA, GL_UNSIGNED_BYTE, opengl_Upload_data); + } + else + { + glTexImage2D(GL_TEXTURE_2D, m, GL_RGBA, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, opengl_Upload_data); + } + } + } + } + } + + //mprintf ((1,"Doing slow upload to opengl!\n")); + + if (map_type == MAP_TYPE_LIGHTMAP) + { + GameLightmaps[bm_handle].flags &= ~LF_LIMITS; + } + + CHECK_ERROR(6) + OpenGL_uploads++; +} + +uint8_t opengl_Framebuffer_ready = 0; +chunked_bitmap opengl_Chunked_bitmap; + +void opengl_ChangeChunkedBitmap(int bm_handle, chunked_bitmap* chunk) +{ + int bw = bm_w(bm_handle, 0); + int bh = bm_h(bm_handle, 0); + + //determine optimal size of the square bitmaps + float fopt = 128.0f; + int iopt; + + //find the smallest dimension and base off that + int smallest = std::min(bw, bh); + + if (smallest <= 32) + fopt = 32; + else + if (smallest <= 64) + fopt = 64; + else + fopt = 128; + + iopt = (int)fopt; + + // Get how many pieces we need across and down + float temp = bw / fopt; + int how_many_across = temp; + if ((temp - how_many_across) > 0) + how_many_across++; + + temp = bh / fopt; + int how_many_down = temp; + if ((temp - how_many_down) > 0) + how_many_down++; + + ASSERT(how_many_across > 0); + ASSERT(how_many_down > 0); + + // Now go through our big bitmap and partition it into pieces + uint16_t* src_data = bm_data(bm_handle, 0); + uint16_t* sdata; + uint16_t* ddata; + + int shift; + switch (iopt) + { + case 32: + shift = 5; + break; + case 64: + shift = 6; + break; + case 128: + shift = 7; + break; + default: + Int3(); //Get Jeff + break; + } + int maxx, maxy; + int windex, hindex; + int s_y, s_x, d_y, d_x; + + for (hindex = 0; hindex < how_many_down; hindex++) + { + for (windex = 0; windex < how_many_across; windex++) + { + //loop through the chunks + //find end x and y + if (windex < how_many_across - 1) + maxx = iopt; + else + maxx = bw - (windex << shift); + if (hindex < how_many_down - 1) + maxy = iopt; + else + maxy = bh - (hindex << shift); + + //find the starting source x and y + s_x = (windex << shift); + s_y = (hindex << shift); + + //get the pointers pointing to the right spot + ddata = bm_data(chunk->bm_array[hindex * how_many_across + windex], 0); + GameBitmaps[chunk->bm_array[hindex * how_many_across + windex]].flags |= BF_CHANGED; + sdata = &src_data[s_y * bw + s_x]; + + //copy the data + for (d_y = 0; d_y < maxy; d_y++) + { + for (d_x = 0; d_x < maxx; d_x++) + { + ddata[d_x] = sdata[d_x]; + }//end for d_x + sdata += bw; + ddata += iopt; + }//end for d_y + + }//end for windex + }//end for hindex +} + +// Takes a bitmap and blits it to the screen using linear frame buffer stuff +// X and Y are the destination X,Y +void rend_CopyBitmapToFramebuffer(int bm_handle, int x, int y) +{ + ASSERT(opengl_Framebuffer_ready); + + if (opengl_Framebuffer_ready == 1) + { + bm_CreateChunkedBitmap(bm_handle, &opengl_Chunked_bitmap); + opengl_Framebuffer_ready = 2; + } + else + { + opengl_ChangeChunkedBitmap(bm_handle, &opengl_Chunked_bitmap); + } + + rend_DrawChunkedBitmap(&opengl_Chunked_bitmap, 0, 0, 255); +} + +// Gets a renderer ready for a framebuffer copy, or stops a framebuffer copy +void rend_SetFrameBufferCopyState(bool state) +{ + if (state) + { + ASSERT(opengl_Framebuffer_ready == 0); + opengl_Framebuffer_ready = 1; + } + else + { + ASSERT(opengl_Framebuffer_ready != 0); + opengl_Framebuffer_ready = 0; + + if (opengl_Framebuffer_ready == 2) + { + bm_DestroyChunkedBitmap(&opengl_Chunked_bitmap); + opengl_ResetCache(); + } + } +} diff --git a/renderer/gl_init.cpp b/renderer/gl_init.cpp new file mode 100644 index 000000000..925b0c9e9 --- /dev/null +++ b/renderer/gl_init.cpp @@ -0,0 +1,849 @@ +/* +* Descent 3: Piccu Engine +* Copyright (C) 2024 Parallax Software +* Copyright (C) 2024 SaladBadger +* +* This program is free software: you can redistribute it and/or modify +* it under the terms of the GNU General Public License as published by +* the Free Software Foundation, either version 3 of the License, or +* (at your option) any later version. +* +* This program is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +* GNU General Public License for more details. +* +* You should have received a copy of the GNU General Public License +* along with this program. If not, see . +*/ +#include "gl_local.h" +#include "args.h" +#include "config.h" + +#define DECLARE_OPENGL +#include "dyna_gl.h" + +#ifdef WIN32 +#define NOMINMAX +#include +#endif + +renderer_preferred_state OpenGL_preferred_state = { 0,1,1.0 }; +rendering_state OpenGL_state; + +bool OpenGL_debugging_enabled; + +/* framebuffer object for backbuffer, scale to window size without changing resolution. --ryan, 2019. */ +#define GL_DEPTH_COMPONENT16_EXT 0x81A5 +#define GL_READ_FRAMEBUFFER_EXT 0x8CA8 +#define GL_DRAW_FRAMEBUFFER_EXT 0x8CA9 +#define GL_FRAMEBUFFER_COMPLETE_EXT 0x8CD5 +#define GL_COLOR_ATTACHMENT0_EXT 0x8CE0 +#define GL_DEPTH_ATTACHMENT_EXT 0x8D00 +#define GL_STENCIL_ATTACHMENT_EXT 0x8D20 +#define GL_FRAMEBUFFER_EXT 0x8D40 +#define GL_RENDERBUFFER_EXT 0x8D41 +static GLuint GOpenGLFBO = 0; +static GLuint GOpenGLRBOColor = 0; +static GLuint GOpenGLRBODepth = 0; +static GLuint GOpenGLFBOWidth = 0; +static GLuint GOpenGLFBOHeight = 0; + +#if defined(WIN32) +PFNWGLSWAPINTERVALEXTPROC dwglSwapIntervalEXT; +PFNWGLCREATECONTEXTATTRIBSARBPROC dwglCreateContextAttribsARB; + +// Moved from DDGR library +HWND hOpenGLWnd = NULL; +HDC hOpenGLDC = NULL; +HGLRC ResourceContext; +#elif defined(__LINUX__) +SDL_Window *GSDLWindow = NULL; +SDL_GLContext GSDLGLContext = NULL; +char loadedLibrary[_MAX_PATH]; +#endif + +bool Already_loaded = false; + +// Sets default states for our renderer +void opengl_SetDefaults() +{ + mprintf((0, "Setting states\n")); + + OpenGL_state.cur_color = 0x00FFFFFF; + OpenGL_state.cur_bilinear_state = -1; + OpenGL_state.cur_zbuffer_state = -1; + OpenGL_state.cur_texture_quality = -1; + OpenGL_state.cur_light_state = LS_GOURAUD; + OpenGL_state.cur_color_model = CM_MONO; + OpenGL_state.cur_mip_state = -1; + OpenGL_state.cur_alpha_type = AT_TEXTURE; + + // Enable some states + //glAlphaFunc(GL_GREATER, 0); + //glEnable(GL_ALPHA_TEST); + glEnable(GL_BLEND); + //glEnable(GL_DITHER); + OpenGL_blending_on = true; + +#ifndef RELEASE + if (Fast_test_render) + { + //glDisable(GL_DITHER); + } +#endif + + rend_SetAlphaType(AT_ALWAYS); + rend_SetAlphaValue(255); + rend_SetFiltering(1); + rend_SetLightingState(LS_NONE); + rend_SetTextureType(TT_FLAT); + rend_SetColorModel(CM_RGB); + rend_SetZBufferState(1); + rend_SetZValues(0, 3000); + OpenGL_last_bound[0] = 9999999; + OpenGL_last_bound[1] = 9999999; + Last_texel_unit_set = -1; + OpenGL_multitexture_state = false; + + opengl_SetDrawDefaults(); + + //glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); + //glHint(GL_FOG_HINT, GL_NICEST); + glEnable(GL_SCISSOR_TEST); + glScissor(0, 0, OpenGL_state.screen_width, OpenGL_state.screen_height); + glDisable(GL_SCISSOR_TEST); + //glDepthRange(0.0f, 1.0f); + + if (UseMultitexture) + { + glActiveTexture(GL_TEXTURE0 + 1); + //glClientActiveTextureARB(GL_TEXTURE0 + 1); + //glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); + //glHint(GL_FOG_HINT, GL_NICEST); + + //glClientActiveTextureARB(GL_TEXTURE0 + 0); + + //glDisable(GL_TEXTURE_2D); + //glAlphaFunc(GL_GREATER, 0); + //glEnable(GL_ALPHA_TEST); + glEnable(GL_BLEND); + //glEnable(GL_DITHER); + glBlendFunc(GL_DST_COLOR, GL_ZERO); + glActiveTexture(GL_TEXTURE0 + 0); + } +} + +#if defined(WIN32) +static HMODULE glDllhandle = nullptr; +static GLADapiproc opengl_GLADLoad(const char* name) +{ + if (!glDllhandle) + { + glDllhandle = LoadLibrary("opengl32.dll"); + if (!glDllhandle) + Error("opengl_GLADLoad: failed to load opengl32.dll!"); + } + void* ptr = wglGetProcAddress(name); + //I love OpenGL btw + if (!ptr) + { + ptr = GetProcAddress(glDllhandle, name); + } + return (GLADapiproc)ptr; +} + +//Hack to allow loading wgl extensions. +//Credit to GZDoom for this bit of code +HWND InitDummy() +{ + HMODULE g_hInst = GetModuleHandle(NULL); + HWND dummy; + //Create a rect structure for the size/position of the window + RECT windowRect; + windowRect.left = 0; + windowRect.right = 64; + windowRect.top = 0; + windowRect.bottom = 64; + + //Window class structure + WNDCLASS wc; + + //Fill in window class struct + wc.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC; + wc.lpfnWndProc = (WNDPROC)DefWindowProc; + wc.cbClsExtra = 0; + wc.cbWndExtra = 0; + wc.hInstance = g_hInst; + wc.hIcon = LoadIcon(NULL, IDI_WINLOGO); + wc.hCursor = LoadCursor(NULL, IDC_ARROW); + wc.hbrBackground = NULL; + wc.lpszMenuName = NULL; + wc.lpszClassName = TEXT("PiccuOpenGLDummyWindow"); + + //Register window class + if (!RegisterClass(&wc)) + { + return 0; + } + + //Set window style & extended style + DWORD style, exStyle; + exStyle = WS_EX_CLIENTEDGE; + style = WS_SYSMENU | WS_BORDER | WS_CAPTION;// | WS_VISIBLE; + + //Adjust the window size so that client area is the size requested + AdjustWindowRectEx(&windowRect, style, false, exStyle); + + //Create Window + if (!(dummy = CreateWindowEx(exStyle, + TEXT("PiccuOpenGLDummyWindow"), + TEXT("PiccuEngine"), + WS_CLIPSIBLINGS | WS_CLIPCHILDREN | style, + 0, 0, + windowRect.right - windowRect.left, + windowRect.bottom - windowRect.top, + NULL, NULL, + g_hInst, + NULL))) + { + UnregisterClassW(L"PiccuOpenGLDummyWindow", g_hInst); + return 0; + } + ShowWindow(dummy, SW_HIDE); + + return dummy; +} + +void ShutdownDummy(HWND dummy) +{ + DestroyWindow(dummy); + UnregisterClass(TEXT("PiccuOpenGLDummyWindow"), GetModuleHandle(NULL)); +} + +bool GL_GetWGLExtensionProcs() +{ + HWND DummyHWND = InitDummy(); + HDC DummyDC = GetDC(DummyHWND); + + // Finds an acceptable pixel format to render to + PIXELFORMATDESCRIPTOR pfd, pfd_copy; + int pf; + bool ret = false; + + memset(&pfd, 0, sizeof(pfd)); + pfd.nSize = sizeof(pfd); + pfd.nVersion = 1; + pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER | PFD_GENERIC_ACCELERATED; + pfd.iPixelType = PFD_TYPE_RGBA; + + // Find the user's "best match" PFD + pf = ChoosePixelFormat(DummyDC, &pfd); + if (pf == 0) + { + Int3(); + //FreeLibrary(opengl_dll_handle); + goto die; + } + + mprintf((0, "Choose pixel format successful!\n")); + + // Try and set the new PFD + if (SetPixelFormat(DummyDC, pf, &pfd) == FALSE) + { + DWORD ret = GetLastError(); + Int3(); + //FreeLibrary(opengl_dll_handle); + goto die; + } + + mprintf((0, "SetPixelFormat successful!\n")); + + // Get a copy of the newly set PFD + if (DescribePixelFormat(DummyDC, pf, sizeof(PIXELFORMATDESCRIPTOR), &pfd_copy) == 0) + { + Int3(); + //FreeLibrary(opengl_dll_handle); + goto die; + } + + // Check the returned PFD to see if it is hardware accelerated + if ((pfd_copy.dwFlags & PFD_GENERIC_ACCELERATED) == 0 && (pfd_copy.dwFlags & PFD_GENERIC_FORMAT) != 0) + { + Int3(); + //FreeLibrary(opengl_dll_handle); + goto die; + } + + // Create an OpenGL context, and make it the current context + HGLRC DummyResourceContext = wglCreateContext(DummyDC); + if (DummyResourceContext == nullptr) + { + DWORD ret = GetLastError(); + //FreeLibrary(opengl_dll_handle); + Int3(); + goto die; + } + + ASSERT(DummyResourceContext != nullptr); + mprintf((0, "Making context current\n")); + if (!wglMakeCurrent(DummyDC, DummyResourceContext)) + { + Int3(); + goto die; + } + + dwglCreateContextAttribsARB = (PFNWGLCREATECONTEXTATTRIBSARBPROC)opengl_GLADLoad("wglCreateContextAttribsARB"); + if (!dwglCreateContextAttribsARB) + { + Int3(); + goto die; + } + + ret = true; + +die: + if (DummyResourceContext) + { + //OpenGL on Windows is lovely. + //Delete this context so I can make a new one with wglCreateContextAttribsARB + wglMakeCurrent(nullptr, nullptr); + wglDeleteContext(DummyResourceContext); + ReleaseDC(DummyHWND, DummyDC); + } + + if (DummyHWND) + ShutdownDummy(DummyHWND); + + return ret; +} + +// Check for OpenGL support, +int opengl_Setup(HDC glhdc) +{ + if (!GL_GetWGLExtensionProcs()) + { + mprintf((0, "Dummy GL context failed!\n")); + return 0; + } + + // Finds an acceptable pixel format to render to + PIXELFORMATDESCRIPTOR pfd, pfd_copy; + int pf; + + memset(&pfd, 0, sizeof(pfd)); + pfd.nSize = sizeof(pfd); + pfd.nVersion = 1; + pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER | PFD_GENERIC_ACCELERATED; + pfd.iPixelType = PFD_TYPE_RGBA; + + // Find the user's "best match" PFD + pf = ChoosePixelFormat(glhdc, &pfd); + if (pf == 0) + { + Int3(); + //FreeLibrary(opengl_dll_handle); + return NULL; + } + + mprintf((0, "Choose pixel format successful!\n")); + + // Try and set the new PFD + if (SetPixelFormat(glhdc, pf, &pfd) == FALSE) + { + DWORD ret = GetLastError(); + Int3(); + //FreeLibrary(opengl_dll_handle); + return NULL; + } + + mprintf((0, "SetPixelFormat successful!\n")); + + // Get a copy of the newly set PFD + if (DescribePixelFormat(glhdc, pf, sizeof(PIXELFORMATDESCRIPTOR), &pfd_copy) == 0) + { + Int3(); + //FreeLibrary(opengl_dll_handle); + return NULL; + } + + // Check the returned PFD to see if it is hardware accelerated + if ((pfd_copy.dwFlags & PFD_GENERIC_ACCELERATED) == 0 && (pfd_copy.dwFlags & PFD_GENERIC_FORMAT) != 0) + { + Int3(); + //FreeLibrary(opengl_dll_handle); + return NULL; + } + + GLint attribs[] = + { + WGL_CONTEXT_MAJOR_VERSION_ARB, 3, + WGL_CONTEXT_MINOR_VERSION_ARB, 3, + WGL_CONTEXT_PROFILE_MASK_ARB, WGL_CONTEXT_CORE_PROFILE_BIT_ARB, +#if defined(GL_DEBUG) && !defined(NDEBUG) + WGL_CONTEXT_FLAGS_ARB, WGL_CONTEXT_DEBUG_BIT_ARB, + #endif + 0 + }; + + // Create an OpenGL context, and make it the current context + //ResourceContext = wglCreateContext((HDC)glhdc); + ResourceContext = dwglCreateContextAttribsARB((HDC)glhdc, nullptr, attribs); + if (ResourceContext == NULL) + { + DWORD ret = GetLastError(); + //FreeLibrary(opengl_dll_handle); + Int3(); + return NULL; + } + + ASSERT(ResourceContext != NULL); + mprintf((0, "Making context current\n")); + if (!wglMakeCurrent((HDC)glhdc, ResourceContext)) + Int3(); + + dwglCreateContextAttribsARB = (PFNWGLCREATECONTEXTATTRIBSARBPROC)opengl_GLADLoad("wglCreateContextAttribsARB"); + if (!dwglCreateContextAttribsARB) + { + Error("Cannot load wglCreateContextAttribsARB!"); + return 0; + } + + if (!Already_loaded) + { + if (!gladLoadGL(opengl_GLADLoad)) + { + rend_SetErrorMessage("Failed to load opengl dll!\n"); + Int3(); + return 0; + } + } + + dwglSwapIntervalEXT = (PFNWGLSWAPINTERVALEXTPROC)opengl_GLADLoad("wglSwapIntervalEXT"); + + Already_loaded = true; + + return 1; + +} +#elif defined(__LINUX__) + +extern bool linux_permit_gamma; +extern renderer_preferred_state Render_preferred_state; +extern bool ddio_mouseGrabbed; +int SDLCALL d3SDLEventFilter(void *userdata, SDL_Event *event); + +int opengl_Setup(oeApplication *app, int *width, int *height) { + int winw = Video_res_list[Game_video_resolution].width; + int winh = Video_res_list[Game_video_resolution].height; + + // rcg09182000 don't need to quitsubsystem anymore... + // SDL_QuitSubSystem(SDL_INIT_VIDEO); // here goes nothing... + // Already_loaded = false; + SDL_ClearError(); + if (!SDL_WasInit(SDL_INIT_VIDEO)) { + const int rc = SDL_Init(SDL_INIT_VIDEO); + if (rc != 0) { + char buffer[512]; + snprintf(buffer, sizeof(buffer), "SDL_GetError() reports \"%s\".\n", SDL_GetError()); + fprintf(stderr, "SDL: SDL_Init() failed! rc == (%d).\n", rc); + fprintf(stderr, "%s", buffer); + rend_SetErrorMessage(buffer); + return (0); + } + } + + SDL_SetEventFilter(d3SDLEventFilter, NULL); + + bool fullscreen = true; + + if (FindArgChar("-fullscreen", 'f')) { + fullscreen = true; + } else if (FindArgChar("-windowed", 'w')) { + fullscreen = false; + } + + if (!Already_loaded) { +#define MAX_ARGS 30 +#define MAX_CHARS_PER_ARG 100 + extern char GameArgs[MAX_ARGS][MAX_CHARS_PER_ARG]; + + char gl_library[256]; + int arg; + arg = FindArgChar("-gllibrary", 'g'); + if (arg != 0) { + strcpy(gl_library, GameArgs[arg + 1]); + } else { + gl_library[0] = 0; + } + + mprintf(0, "OpenGL: Attempting to use \"%s\" for OpenGL\n", gl_library[0] ? gl_library : "[system default library]"); + + // ryan's adds. 04/18/2000...SDL stuff on 04/25/2000 + bool success = true; + + OpenGLDLLHandle = LoadOpenGLDLL(gl_library); + if (!(OpenGLDLLHandle)) { + // rcg07072000 last ditch effort... + OpenGLDLLHandle = LoadOpenGLDLL("libGL.so.1"); + if (!(OpenGLDLLHandle)) { + success = false; + } + } // if + + if (success == false) { + char buffer[512]; + snprintf(buffer, sizeof(buffer), "Failed to load library [%s].\n", gl_library); + fprintf(stderr, "%s", buffer); + rend_SetErrorMessage(buffer); + return 0; + } // if + } + +#ifdef __PERMIT_GL_LOGGING + if (FindArg("-gllogging")) { + printf("\n" + "************************************************************\n" + "************************************************************\n" + "************************************************************\n" + "************************************************************\n" + "************************************************************\n" + "******** GL LOGGING ENABLED. ***************************\n" + "************************************************************\n" + "************************************************************\n" + "************************************************************\n" + "************************************************************\n" + "************************************************************\n" + "\n"); + DGL_EnableLogging(1); + __glLog = true; + } // if +#endif + + SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8 ); + SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8); + SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8); + SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 16); + SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1); + Uint32 flags = SDL_WINDOW_OPENGL; + + if (fullscreen) { + flags |= SDL_WINDOW_FULLSCREEN_DESKTOP; + } + + if (!GSDLWindow) { + GSDLWindow = SDL_CreateWindow("Descent 3", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, winw, winh, flags); + if (!GSDLWindow) { + mprintf(0, "OpenGL: SDL window creation failed: %s", SDL_GetError()); + return 0; + } + } else { + SDL_SetWindowSize(GSDLWindow, winw, winh); + SDL_SetWindowFullscreen(GSDLWindow, flags); + } + + if (!GSDLGLContext) { + GSDLGLContext = SDL_GL_CreateContext(GSDLWindow); + if (!GSDLGLContext) { + mprintf(0, "OpenGL: OpenGL context creation failed: %s", SDL_GetError()); + SDL_DestroyWindow(GSDLWindow); + GSDLWindow = NULL; + return 0; + } + } + + // clear the window framebuffer to start. + dglClearColor(0.0f, 0.0f, 0.0f, 1.0f); + dglClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); + SDL_GL_SwapWindow(GSDLWindow); + + bool fbo_available = true; + if (!SDL_GL_ExtensionSupported("GL_EXT_framebuffer_object")) { + mprintf(0, "OpenGL: GL_EXT_framebuffer_object extension is not available"); + fbo_available = false; + } + + if (!SDL_GL_ExtensionSupported("GL_EXT_framebuffer_blit")) { + mprintf(0, "OpenGL: GL_EXT_framebuffer_blit extension is not available"); + fbo_available = false; + } + + if (fbo_available) { + #define LOOKUP_GL_SYM(x) \ + dgl##x = (gl##x##_fp) SDL_GL_GetProcAddress("gl" #x); \ + if (dgl##x == NULL) { \ + mprintf(0, "OpenGL: gl%s function not found!", #x); \ + fbo_available = false; \ + } + LOOKUP_GL_SYM(GenFramebuffersEXT); + LOOKUP_GL_SYM(GenRenderbuffersEXT); + LOOKUP_GL_SYM(BindFramebufferEXT); + LOOKUP_GL_SYM(BindRenderbufferEXT); + LOOKUP_GL_SYM(RenderbufferStorageEXT); + LOOKUP_GL_SYM(FramebufferRenderbufferEXT); + LOOKUP_GL_SYM(CheckFramebufferStatusEXT); + LOOKUP_GL_SYM(DeleteFramebuffersEXT); + LOOKUP_GL_SYM(DeleteRenderbuffersEXT); + LOOKUP_GL_SYM(BlitFramebufferEXT); + } + + if (!fbo_available) { + mprintf(0, "OpenGL: We need missing Framebuffer Object support, giving up"); + SDL_GL_DeleteContext(GSDLGLContext); + SDL_DestroyWindow(GSDLWindow); + GSDLGLContext = NULL; + GSDLWindow = NULL; + return 0; + } + + /* Tear down the backbuffer and rebuild at new dimensions... */ + if (GOpenGLFBO) { + dglBindFramebufferEXT(GL_FRAMEBUFFER_EXT, GOpenGLFBO); + dglFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_RENDERBUFFER_EXT, 0); + dglFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, 0); + dglBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0); + dglBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); + dglDeleteFramebuffersEXT(1, &GOpenGLFBO); + dglDeleteRenderbuffersEXT(1, &GOpenGLRBOColor); + dglDeleteRenderbuffersEXT(1, &GOpenGLRBODepth); + GOpenGLFBOWidth = GOpenGLFBOHeight = GOpenGLFBO = GOpenGLRBOColor = GOpenGLRBODepth = 0; + } + + const GLsizei w = (GLsizei) *width; + const GLsizei h = (GLsizei) *height; + + GOpenGLFBOWidth = w; + GOpenGLFBOHeight = h; + + dglGenFramebuffersEXT(1, &GOpenGLFBO); + dglBindFramebufferEXT(GL_FRAMEBUFFER_EXT, GOpenGLFBO); + + dglGenRenderbuffersEXT(1, &GOpenGLRBOColor); + dglBindRenderbufferEXT(GL_RENDERBUFFER_EXT, GOpenGLRBOColor); + dglRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_RGB, w, h); + dglFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_RENDERBUFFER_EXT, GOpenGLRBOColor); + + dglGenRenderbuffersEXT(1, &GOpenGLRBODepth); + dglBindRenderbufferEXT(GL_RENDERBUFFER_EXT, GOpenGLRBODepth); + dglRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT16_EXT, w, h); + dglFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, GOpenGLRBODepth); + + if (dglCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT) != GL_FRAMEBUFFER_COMPLETE_EXT) { + mprintf(0, "OpenGL: our framebuffer object is incomplete, giving up"); + dglFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_RENDERBUFFER_EXT, 0); + dglFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, 0); + dglBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0); + dglBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); + dglDeleteFramebuffersEXT(1, &GOpenGLFBO); + dglDeleteRenderbuffersEXT(1, &GOpenGLRBOColor); + dglDeleteRenderbuffersEXT(1, &GOpenGLRBODepth); + GOpenGLFBO = GOpenGLRBOColor = GOpenGLRBODepth = 0; + SDL_GL_DeleteContext(GSDLGLContext); + SDL_DestroyWindow(GSDLWindow); + GSDLGLContext = NULL; + GSDLWindow = NULL; + return 0; + } + + if (!FindArg("-nomousegrab")) { + ddio_mouseGrabbed = true; + } + + SDL_SetRelativeMouseMode(ddio_mouseGrabbed ? SDL_TRUE : SDL_FALSE); + + // rcg09182000 gamma fun. + // rcg01112000 --nogamma fun. + if (FindArgChar("-nogamma", 'M')) { + linux_permit_gamma = false; + } else { + Uint16 ramp[256]; + SDL_CalculateGammaRamp(Render_preferred_state.gamma, ramp); + linux_permit_gamma = (SDL_SetWindowGammaRamp(GSDLWindow, ramp, ramp, ramp) == 0); + } // else + + if (ParentApplication) { + reinterpret_cast(ParentApplication)->set_sizepos(0, 0, *width, *height); + } + + Already_loaded = 1; + return 1; +} +#endif + +// Gets some specific information about this particular flavor of opengl +void opengl_GetInformation() +{ + mprintf((0, "OpenGL Vendor: %s\n", glGetString(GL_VENDOR))); + mprintf((0, "OpenGL Renderer: %s\n", glGetString(GL_RENDERER))); + mprintf((0, "OpenGL Version: %s\n", glGetString(GL_VERSION))); +} + +void GLAD_API_PTR GL_LogDebugMsg(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar* msg, const void* user) +{ + mprintf((0, "OpenGL debug msg %d: %s\n", id, msg)); +} + +// Sets up our OpenGL rendering context +// Returns 1 if ok, 0 if something bad +int opengl_Init(oeApplication* app, renderer_preferred_state* pref_state) +{ + //int width,height; + int retval = 1; + int i; + + mprintf((0, "Setting up opengl mode!\n")); + + if (pref_state) + { + OpenGL_preferred_state = *pref_state; + } + + if (app != NULL) + { + ParentApplication = app; + } + + int windowX = 0, windowY = 0; +#if defined(WIN32) + /*********************************************************** + * WINDOWS OPENGL + *********************************************************** + */ + static HWnd hwnd = NULL; + if (ParentApplication != NULL) + { + hwnd = static_cast(reinterpret_cast(ParentApplication)->m_hWnd); + } + + memset(&OpenGL_state, 0, sizeof(rendering_state)); + + // These values are set here - samir + if (app != NULL) + { + hOpenGLWnd = (HWND)((oeWin32Application*)app)->m_hWnd; + } + + hOpenGLDC = GetDC(hOpenGLWnd); + + opengl_InitImages(); + opengl_UpdateWindow(); + + if (!opengl_Setup(hOpenGLDC)) + { + opengl_Close(); + return 0; + } + +#if defined(GL_DEBUG) && !defined(NDEBUG) + OpenGL_debugging_enabled = opengl_CheckExtension("GL_KHR_debug"); + if (OpenGL_debugging_enabled) + { + glDebugMessageCallback(GL_LogDebugMsg, nullptr); + } +#else + OpenGL_debugging_enabled = false; +#endif + +#elif defined(__LINUX__) + /*********************************************************** + * LINUX OPENGL + *********************************************************** + */ + // Setup OpenGL_state.screen_width & OpenGL_state.screen_height & width & height + auto width = OpenGL_preferred_state.width; + auto height = OpenGL_preferred_state.height; + + if (!opengl_Setup(app, &width, &height)) + { + opengl_Close(); + return 0; + } + + memset(&OpenGL_state, 0, sizeof(rendering_state)); + OpenGL_state.screen_width = width; + OpenGL_state.screen_height = height; +#else + // Setup OpenGL_state.screen_width & OpenGL_state.screen_height & width & height + +#endif + // Get some info + opengl_GetInformation(); + + //Initialize the common buffer that will be shared across shaders. + opengl_InitCommonBuffer(); + + // Update framebuffer + opengl_UpdateFramebuffer(); + + mprintf((0, "Setting up multitexture...\n")); + + //In this shader world, multitexture is always supported. + UseMultitexture = true; + //TODO: Need to use standard statement + OpenGL_packed_pixels = false; + + opengl_InitCache(); + + if (UseMultitexture) + mprintf((0, "Using multitexture.")); + else + mprintf((0, "Not using multitexture.")); + + opengl_SetUploadBufferSize(256, 256); + opengl_SetDefaults(); + + // Default passthrough viewport. + opengl_SetViewport(); + + //g3_ForceTransformRefresh(); + + CHECK_ERROR(4); + + OpenGL_state.initted = 1; + + mprintf((0, "OpenGL initialization at %d x %d was successful.\n", OpenGL_state.screen_width, OpenGL_state.screen_height)); + +#ifdef WIN32 + if (dwglSwapIntervalEXT) + { + if (pref_state->vsync_on) + dwglSwapIntervalEXT(1); + else + dwglSwapIntervalEXT(0); + } +#endif + + return retval; +} + +// Releases the rendering context +void opengl_Close() +{ + CHECK_ERROR(5); + + opengl_FreeImages(); + opengl_CloseFramebuffer(); + +#if defined(WIN32) + wglMakeCurrent(NULL, NULL); + + wglDeleteContext(ResourceContext); + +#elif defined(__LINUX__) + // SDL_Quit() handles this for us. +#else + +#endif + + opengl_FreeUploadBuffers(); + + opengl_FreeCache(); + +#if defined(WIN32) + // I'm freeing the DC here - samir + ReleaseDC(hOpenGLWnd, hOpenGLDC); +#endif + + //mod_FreeModule (OpenGLDLLHandle); + OpenGL_state.initted = 0; +} diff --git a/renderer/gl_local.h b/renderer/gl_local.h new file mode 100644 index 000000000..60caee871 --- /dev/null +++ b/renderer/gl_local.h @@ -0,0 +1,150 @@ +/* +* Descent 3: Piccu Engine +* Copyright (C) 2024 Parallax Software +* Copyright (C) 2024 SaladBadger +* +* This program is free software: you can redistribute it and/or modify +* it under the terms of the GNU General Public License as published by +* the Free Software Foundation, either version 3 of the License, or +* (at your option) any later version. +* +* This program is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +* GNU General Public License for more details. +* +* You should have received a copy of the GNU General Public License +* along with this program. If not, see . +*/ +#pragma once + +#ifdef WIN32 +#define NOMINMAX +#include +#include "wglext.h" +#endif +#include +#include +#define DD_ACCESS_RING //need direct access to some stuff +#include "application.h" +#include "3d.h" +#include "renderer.h" +#include "vecmat.h" +#include "bitmap.h" +#include "lightmap.h" +#include "mem.h" +#include "mono.h" +#include "pserror.h" +#include "gl_shader.h" +#include "module.h" + +#define CHECK_ERROR(n) //need to decide what it does. + +#define GL_DEBUG + +#ifdef WIN32 +//typedef BOOL(WINAPI* PFNWGLSWAPINTERVALEXTPROC) (int interval); +extern PFNWGLSWAPINTERVALEXTPROC dwglSwapIntervalEXT; + +extern HWND hOpenGLWnd; +extern HDC hOpenGLDC; +#endif + +//gl_init.cpp +extern bool OpenGL_packed_pixels; +extern bool OpenGL_debugging_enabled; +int opengl_Init(oeApplication* app, renderer_preferred_state* pref_state); +void opengl_Close(); + +//gl_main.cpp +extern oeApplication* ParentApplication; +extern renderer_preferred_state OpenGL_preferred_state; +extern rendering_state OpenGL_state; +extern bool Fast_test_render; + +bool opengl_CheckExtension(char* extName); +void opengl_SetGammaValue(float val); +void opengl_UpdateFramebuffer(void); +void opengl_CloseFramebuffer(void); +void opengl_SetViewport(); +void opengl_UpdateWindow(); + + +//gl_image.cpp +extern int OpenGL_last_bound[2]; +extern int OpenGL_sets_this_frame[10]; +extern int OpenGL_uploads; +extern int Last_texel_unit_set; + +#define GET_WRAP_STATE(x) ((x>>2) & 0x03) +#define GET_MIP_STATE(x) ((x>>1) & 0x01); +#define GET_FILTER_STATE(x) (x & 0x01) + +#define SET_WRAP_STATE(x,s) {x&=0xF3; x|=(s<<2);} +#define SET_MIP_STATE(x,s) {x&=0xFD; x|=(s<<1);} +#define SET_FILTER_STATE(x,s) {x&=0xFE; x|=(s);} + +void opengl_InitImages(void); +void opengl_FreeImages(void); +int opengl_MakeTextureObject(int tn); +int opengl_MakeBitmapCurrent(int handle, int map_type, int tn); +void opengl_TranslateBitmapToOpenGL(int texnum, int bm_handle, int map_type, int replace, int tn); +void opengl_MakeWrapTypeCurrent(int handle, int map_type, int tn); +void opengl_MakeFilterTypeCurrent(int handle, int map_type, int tn); +int opengl_InitCache(void); +void opengl_ResetCache(void); +void opengl_FreeCache(void); +void opengl_SetUploadBufferSize(int width, int height); +void opengl_FreeUploadBuffers(void); + +//gl_draw.cpp +extern float OpenGL_Alpha_factor; +extern float Alpha_multiplier; +extern bool OpenGL_blending_on; +extern bool OpenGL_multitexture_state; +extern int OpenGL_polys_drawn; +extern int OpenGL_verts_processed; +extern module *OpenGLDLLHandle; + +void opengl_SetDrawDefaults(void); +void rend_SetLightingState(light_state state); +void rend_SetMipState(int8_t mipstate); +void opengl_DrawMultitexturePolygon3D(int handle, g3Point** p, int nv, int map_type); +void opengl_SetMultitextureBlendMode(bool state); +void opengl_DrawFlatPolygon3D(g3Point** p, int nv); +//Call to ensure that the draw VAO is always ready to go when changing VAOs. +void GL_UseDrawVAO(void); + +//gl_framebuffer.cpp +class Framebuffer +{ + GLuint m_name, m_subname; + GLuint m_colorname, m_subcolorname, m_depthname; + uint32_t m_width, m_height; + bool m_msaa; + + //Used when multisampling is enabled. Blits the multisample framebuffer to the non-multisample sub framebuffer + //Leaves the sub framebuffer bound for reading to finish the blit. + void SubColorBlit(); +public: + Framebuffer(); + void Update(int width, int height, bool msaa); + void Destroy(); + //Blits to the target framebuffer using glBlitFramebuffer. + //Will set current read framebuffer to m_name. + void BlitToRaw(GLuint target, unsigned int x, unsigned int y, unsigned int w, unsigned int h); + //Blits to the target framebuffer using a draw. Bind desired shader before calling. + //Will set current read framebuffer to m_name. Will not trash viewport. + void BlitTo(GLuint target, unsigned int x, unsigned int y, unsigned int w, unsigned int h); + + GLuint Handle() const + { + return m_name; + } +}; + +//temporary +void GL_InitFramebufferVAO(void); +void GL_DestroyFramebufferVAO(void); + +void GL_UpdateLegacyBlock(float* projection, float* modelview); diff --git a/renderer/gl_main.cpp b/renderer/gl_main.cpp new file mode 100644 index 000000000..6f6eec80a --- /dev/null +++ b/renderer/gl_main.cpp @@ -0,0 +1,1084 @@ +/* +* Descent 3: Piccu Engine +* Copyright (C) 2024 Parallax Software +* Copyright (C) 2024 SaladBadger +* +* This program is free software: you can redistribute it and/or modify +* it under the terms of the GNU General Public License as published by +* the Free Software Foundation, either version 3 of the License, or +* (at your option) any later version. +* +* This program is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +* GNU General Public License for more details. +* +* You should have received a copy of the GNU General Public License +* along with this program. If not, see . +*/ +#include "gl_local.h" +#include "rtperformance.h" +#include "gl_shader.h" + +#include + +oeApplication* ParentApplication = nullptr; + +bool Renderer_initted; +bool Renderer_close_flag; +bool UseHardware = true; +bool StateLimited; +bool NoLightmaps; +bool UseMultitexture; +renderer_type Renderer_type = RENDERER_OPENGL; + +bool OpenGL_multitexture_state; +bool OpenGL_packed_pixels; +bool Fast_test_render = false; +module *OpenGLDLLHandle = nullptr; + +constexpr int NUM_FBOS = 2; +Framebuffer framebuffers[NUM_FBOS]; +int framebuffer_current_draw; + +unsigned int framebuffer_blit_x, framebuffer_blit_y, framebuffer_blit_w, framebuffer_blit_h; + +ShaderProgram blitshader; +//Temp shader to test the shader systems. +ShaderProgram testshader; +GLint blitshader_gamma = -1; + +static float mat4_identity[16] = +{ 1, 0, 0, 0, + 0, 1, 0, 0, + 0, 0, 1, 0, + 0, 0, 0, 1 }; + + +// Init our renderer +int rend_Init(renderer_type state, oeApplication* app, renderer_preferred_state* pref_state) +{ +#ifndef DEDICATED_ONLY + int retval = 0; + rend_SetRendererType(state); + if (!Renderer_initted) + { + if (!Renderer_close_flag) + { + atexit(rend_Close); + Renderer_close_flag = 1; + } + + Renderer_initted = 1; + } + else + { + return 1; //[ISB] don't double dip on renderer initialization. This happens after an int3 + } + + mprintf((0, "Renderer init is set to %d\n", Renderer_initted)); + + retval = opengl_Init(app, pref_state); + + extern const char* blitVertexSrc; + extern const char* blitFragmentSrc; + blitshader.AttachSource(blitVertexSrc, blitFragmentSrc); + blitshader_gamma = blitshader.FindUniform("gamma"); + if (blitshader_gamma == -1) + Error("rend_Init: Failed to find gamma uniform!"); + + //Simple shader for testing, before everything is made to use shaders. + extern const char* testVertexSrc; + extern const char* testFragmentSrc; + testshader.AttachSource(testVertexSrc, testFragmentSrc); + + //[ISB] moved here.. stupid. + opengl_SetGammaValue(OpenGL_preferred_state.gamma); + + return retval; +#else + return 0; +#endif +} + +void rend_Close(void) +{ + mprintf((0, "CLOSE:Renderer init is set to %d\n", Renderer_initted)); + if (!Renderer_initted) + return; + + blitshader.Destroy(); + opengl_Close(); + + Renderer_initted = false; +} + +void GL_Ortho(float* mat, float left, float right, float bottom, float top, float znear, float zfar) +{ + memset(mat, 0, sizeof(float[16])); + mat[0] = 2 / (right - left); + mat[5] = 2 / (top - bottom); + mat[10] = -2 / (zfar - znear); + mat[12] = -((right + left) / (right - left)); + mat[13] = -((top + bottom) / (top - bottom)); + mat[14] = -((zfar + znear) / (zfar - znear)); + mat[15] = 1; + /* 2 / (right - left), 0, 0, 0, + 0, 2 / (top - bottom), 0, 0, + 0, 0, -2 / (zfar - znear), 0, + -((right + left) / (right - left)), -((top + bottom) / (top - bottom)), -((zfar + znear) / (zfar - znear)), 1*/ +} + +void opengl_UpdateWindow() +{ + int width, height; + if (!OpenGL_preferred_state.fullscreen) + { + SDL_SetWindowPosition(SDL_GL_GetCurrentWindow(), SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED); + int x, y; + SDL_GetWindowPosition(SDL_GL_GetCurrentWindow(), &x, &y); + SDL_GetWindowSize(SDL_GL_GetCurrentWindow(), &width, &height); + ParentApplication->set_sizepos(x, y, width, height); + ParentApplication->set_flags(OEAPP_WINDOWED); + } + else + { + ParentApplication->set_flags(OEAPP_FULLSCREEN); + + SDL_DisplayMode dm{}; + SDL_GetCurrentDisplayMode(0, &dm); + + OpenGL_state.view_width = dm.w; + OpenGL_state.view_height = dm.h; + + width = OpenGL_preferred_state.width; + height = OpenGL_preferred_state.height; + } + + float baseAspect = width / (float)height; + float trueAspect = OpenGL_state.view_width / (float)OpenGL_state.view_height; + + if (baseAspect < trueAspect) //base screen is less wide, so pillarbox it + { + framebuffer_blit_h = OpenGL_state.view_height; framebuffer_blit_y = 0; + framebuffer_blit_w = OpenGL_state.view_height * baseAspect; framebuffer_blit_x = (OpenGL_state.view_width - framebuffer_blit_w) / 2; + } + else //base screen is more wide, so letterbox it + { + framebuffer_blit_w = OpenGL_state.view_width; framebuffer_blit_x = 0; + framebuffer_blit_h = OpenGL_state.view_width / baseAspect; framebuffer_blit_y = (OpenGL_state.view_height - framebuffer_blit_h) / 2; + } + + OpenGL_state.screen_width = width; + OpenGL_state.screen_height = height; +} + +void opengl_SetViewport() +{ + //[ISB] the hardware t&l code is AWFUL and the software t&l code won't compile. + // Reverting it back to only ever using passthrough. + // Projection + //glMatrixMode(GL_PROJECTION); + //glLoadIdentity(); + //glOrtho((GLfloat)0.0f, (GLfloat)(OpenGL_preferred_state.width), (GLfloat)(OpenGL_preferred_state.height), (GLfloat)0.0f, 0.0f, 1.0f); + + float left = 0; + float right = OpenGL_preferred_state.width; + float bottom = OpenGL_preferred_state.height; + float top = 0; + float znear = 0; + float zfar = 1; + + float projection[16]; + GL_Ortho(projection, left, right, bottom, top, znear, zfar); + + GL_UpdateLegacyBlock(projection, mat4_identity); + // Viewport + glViewport(0, 0, OpenGL_preferred_state.width, OpenGL_preferred_state.height); + + // ModelView + //glMatrixMode(GL_MODELVIEW); + //glLoadIdentity(); +} + +// Sets some global preferences for the renderer +int rend_SetPreferredState(renderer_preferred_state* pref_state) +{ + int retval = 1; + renderer_preferred_state old_state = OpenGL_preferred_state; + + OpenGL_preferred_state = *pref_state; + if (OpenGL_state.initted) + { + int reinit = 0; + mprintf((0, "Inside pref state!\n")); + + // Change gamma if needed + /*if( pref_state->width!=OpenGL_state.screen_width || pref_state->height!=OpenGL_state.screen_height || old_state.bit_depth!=pref_state->bit_depth) + { + reinit=1; + } + + if( reinit ) + { + opengl_Close(); + retval = opengl_Init( NULL, &OpenGL_preferred_state ); + } + else + {*/ + + if (pref_state->width != OpenGL_state.screen_width || pref_state->height != OpenGL_state.screen_height + || pref_state->window_width != OpenGL_state.view_width || pref_state->window_height != OpenGL_state.view_height + || pref_state->fullscreen != old_state.fullscreen || pref_state->antialised != old_state.antialised) + { + opengl_UpdateWindow(); + opengl_SetViewport(); + opengl_UpdateFramebuffer(); + } + + if (old_state.gamma != pref_state->gamma) + { + opengl_SetGammaValue(pref_state->gamma); + } + +#ifdef WIN32 + if (dwglSwapIntervalEXT) + { + if (pref_state->vsync_on) + dwglSwapIntervalEXT(1); + else + dwglSwapIntervalEXT(0); + } +#endif + //} + } + else + { + OpenGL_preferred_state = *pref_state; + } + + return retval; +} + +void rend_StartFrame(int x1, int y1, int x2, int y2, int clear_flags) +{ + if (clear_flags & RF_CLEAR_ZBUFFER) + { + glClear(GL_DEPTH_BUFFER_BIT); + } + + OpenGL_state.clip_x1 = x1; + OpenGL_state.clip_y1 = y1; + OpenGL_state.clip_x2 = x2; + OpenGL_state.clip_y2 = y2; + + //[ISB] Use the viewport to constrain the clipping window so that the new hardware code + //can work with the legacy code. + float projection[16]; + GL_Ortho(projection, 0, x2 - x1, y2 - y1, 0, 0, 1); + + GL_UpdateLegacyBlock(projection, mat4_identity); + + glViewport(x1, OpenGL_state.screen_height - y2, x2 - x1, y2 - y1); +} + +static int OpenGL_last_frame_polys_drawn = 0; +static int OpenGL_last_frame_verts_processed = 0; +static int OpenGL_last_uploaded = 0; + +// Flips the screen +void rend_Flip(void) +{ +#ifndef NDEBUG + GLenum err = glGetError(); + if (err != GL_NO_ERROR) + { + mprintf((0, "Error entering flip: %d\n", err)); + } +#endif +#ifndef RELEASE + int i; + + RTP_INCRVALUE(texture_uploads, OpenGL_uploads); + RTP_INCRVALUE(polys_drawn, OpenGL_polys_drawn); + + mprintf_at((1, 1, 0, "Uploads=%d Polys=%d Verts=%d ", OpenGL_uploads, OpenGL_polys_drawn, OpenGL_verts_processed)); + mprintf_at((1, 2, 0, "Sets= 0:%d 1:%d 2:%d 3:%d ", OpenGL_sets_this_frame[0], OpenGL_sets_this_frame[1], OpenGL_sets_this_frame[2], OpenGL_sets_this_frame[3])); + mprintf_at((1, 3, 0, "Sets= 4:%d 5:%d ", OpenGL_sets_this_frame[4], OpenGL_sets_this_frame[5])); + for (i = 0; i < 10; i++) + { + OpenGL_sets_this_frame[i] = 0; + } +#endif + + OpenGL_last_frame_polys_drawn = OpenGL_polys_drawn; + OpenGL_last_frame_verts_processed = OpenGL_verts_processed; + OpenGL_last_uploaded = OpenGL_uploads; + + OpenGL_uploads = 0; + OpenGL_polys_drawn = 0; + OpenGL_verts_processed = 0; + + if (OpenGL_preferred_state.gamma == 1.0) + framebuffers[framebuffer_current_draw].BlitToRaw(0, framebuffer_blit_x, framebuffer_blit_y, framebuffer_blit_w, framebuffer_blit_h); + else + { + blitshader.Use(); + framebuffers[framebuffer_current_draw].BlitTo(0, framebuffer_blit_x, framebuffer_blit_y, framebuffer_blit_w, framebuffer_blit_h); + glUseProgram(0); + } + + glBindFramebuffer(GL_READ_FRAMEBUFFER, 0); + +#ifndef NDEBUG + err = glGetError(); + if (err != GL_NO_ERROR) + { + mprintf((0, "Error blitting to real framebuffer: %d\n", err)); + } +#endif + +#if defined(WIN32) + SwapBuffers((HDC)hOpenGLDC); +#elif defined(__LINUX__) + SDL_GL_SwapWindow(SDL_GL_GetCurrentWindow()); +#endif + + framebuffer_current_draw = (framebuffer_current_draw + 1) % NUM_FBOS; + glBindFramebuffer(GL_DRAW_FRAMEBUFFER, framebuffers[framebuffer_current_draw].Handle()); + +#ifndef NDEBUG + err = glGetError(); + if (err != GL_NO_ERROR) + { + mprintf((0, "Error setting framebuffer back: %d\n", err)); + } +#endif + +#ifdef __PERMIT_GL_LOGGING + if (__glLog == true) + { + DGL_LogNewFrame(); + } +#endif +} + +void rend_EndFrame(void) +{ +} + + +// returns true if the passed in extension name is supported +bool opengl_CheckExtension(char* extName) +{ + GLint extcount; + glGetIntegerv(GL_NUM_EXTENSIONS, &extcount); + for (int i = 0; i < extcount; i++) + { + const GLubyte* extname = glGetStringi(GL_EXTENSIONS, i); + if (!stricmp((const char*)extname, extName)) + return true; + } + + return false; +} + +void opengl_SetGammaValue(float val) +{ + blitshader.Use(); + + glUniform1f(blitshader_gamma, 1.f / val); + + glUseProgram(0); +} + +void rend_SetFlatColor(ddgr_color color) +{ + OpenGL_state.cur_color = color; +} + +// Sets the fog state to TRUE or FALSE +void rend_SetFogState(int8_t state) +{ + if (state == OpenGL_state.cur_fog_state) + return; + + OpenGL_state.cur_fog_state = state; + if (state == 1) + { + //TODO + //glEnable(GL_FOG); + } + else + { + //glDisable(GL_FOG); + } +} + +// Sets the near and far plane of fog +void rend_SetFogBorders(float nearz, float farz) +{ + // Sets the near and far plane of fog + float fogStart = nearz; + float fogEnd = farz; + + OpenGL_state.cur_fog_start = fogStart; + OpenGL_state.cur_fog_end = fogEnd; + + //glFogi(GL_FOG_MODE, GL_LINEAR); + //glFogf(GL_FOG_START, fogStart); + //glFogf(GL_FOG_END, fogEnd); +} + +void rend_SetLighting(light_state state) +{ + if (state == OpenGL_state.cur_light_state) + return; // No redundant state setting + if (UseMultitexture && Last_texel_unit_set != 0) + { + glActiveTexture(GL_TEXTURE0 + 0); + Last_texel_unit_set = 0; + } + + OpenGL_sets_this_frame[4]++; + + switch (state) + { + case LS_NONE: + //glShadeModel(GL_SMOOTH); + OpenGL_state.cur_light_state = LS_NONE; + break; + case LS_FLAT_GOURAUD: + //glShadeModel(GL_SMOOTH); + OpenGL_state.cur_light_state = LS_FLAT_GOURAUD; + break; + case LS_GOURAUD: + case LS_PHONG: + //glShadeModel(GL_SMOOTH); + OpenGL_state.cur_light_state = LS_GOURAUD; + break; + default: + Int3(); + break; + } + + CHECK_ERROR(13) +} + +void rend_SetRendererType(renderer_type state) +{ + Renderer_type = state; + mprintf((0, "RendererType is set to %d.\n", state)); +} + +void rend_SetColorModel(color_model state) +{ + switch (state) + { + case CM_MONO: + OpenGL_state.cur_color_model = CM_MONO; + break; + case CM_RGB: + OpenGL_state.cur_color_model = CM_RGB; + break; + default: + Int3(); + break; + } +} + +void rend_SetTextureType(texture_type state) +{ + if (state == OpenGL_state.cur_texture_type) + return; // No redundant state setting + if (UseMultitexture && Last_texel_unit_set != 0) + { + glActiveTexture(GL_TEXTURE0 + 0); + Last_texel_unit_set = 0; + } + OpenGL_sets_this_frame[3]++; + + switch (state) + { + case TT_FLAT: + OpenGL_state.cur_texture_quality = 0; + break; + case TT_LINEAR: + case TT_LINEAR_SPECIAL: + case TT_PERSPECTIVE: + case TT_PERSPECTIVE_SPECIAL: + OpenGL_state.cur_texture_quality = 2; + break; + default: + Int3(); // huh? Get Jason + break; + } + + CHECK_ERROR(12) + OpenGL_state.cur_texture_type = state; +} + +// Sets where the software renderer should write to +void rend_SetSoftwareParameters(float aspect, int width, int height, int pitch, uint8_t* framebuffer) +{ +} + +// Sets the state of bilinear filtering for our textures +void rend_SetFiltering(int8_t state) +{ + OpenGL_state.cur_bilinear_state = state; +} + +// Sets the state of z-buffering to on or off +void rend_SetZBufferState(int8_t state) +{ + if (state == OpenGL_state.cur_zbuffer_state) + return; // No redundant state setting + + OpenGL_sets_this_frame[5]++; + OpenGL_state.cur_zbuffer_state = state; + + // mprintf ((0,"OPENGL: Setting zbuffer state to %d.\n",state)); + + if (state) + { + glEnable(GL_DEPTH_TEST); + glDepthFunc(GL_LEQUAL); + } + else + { + glDisable(GL_DEPTH_TEST); + } + + CHECK_ERROR(14) +} + +// Sets the near and far planes for z buffer +void rend_SetZValues(float nearz, float farz) +{ + OpenGL_state.cur_near_z = nearz; + OpenGL_state.cur_far_z = farz; + // mprintf ((0,"OPENGL:Setting depth range to %f - %f\n",nearz,farz)); +} + +// Sets a bitmap as a overlay map to rendered on top of the next texture map +// a -1 value indicates no overlay map +void rend_SetOverlayMap(int handle) +{ + Overlay_map = handle; +} + +void rend_SetOverlayType(uint8_t type) +{ + Overlay_type = type; +} + +// Clears the display to a specified color +void rend_ClearScreen(ddgr_color color) +{ + int r = (color >> 16 & 0xFF); + int g = (color >> 8 & 0xFF); + int b = (color & 0xFF); + + glClearColor((float)r / 255.0f, (float)g / 255.0f, (float)b / 255.0f, 0); + + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); +} + +// Clears the zbuffer for the screen +void rend_ClearZBuffer(void) +{ + glClear(GL_DEPTH_BUFFER_BIT); +} + +// Clears the zbuffer for the screen +void rend_ResetCache(void) +{ + mprintf((0, "Resetting texture cache!\n")); + opengl_ResetCache(); +} + +// Sets the color of fog +void rend_SetFogColor(ddgr_color color) +{ + if (color == OpenGL_state.cur_fog_color) + return; + + float fc[4]; + fc[0] = GR_COLOR_RED(color); + fc[1] = GR_COLOR_GREEN(color); + fc[2] = GR_COLOR_BLUE(color); + fc[3] = 1; + + fc[0] /= 255.0f; + fc[1] /= 255.0f; + fc[2] /= 255.0f; + + //TODO: + //glFogfv(GL_FOG_COLOR, fc); +} + +// Sets the lighting state of opengl +void rend_SetLightingState(light_state state) +{ + if (state == OpenGL_state.cur_light_state) + return; // No redundant state setting + + if (UseMultitexture && Last_texel_unit_set != 0) + { + glActiveTexture(GL_TEXTURE0 + 0); + Last_texel_unit_set = 0; + } + + OpenGL_sets_this_frame[4]++; + + switch (state) + { + case LS_NONE: + //glShadeModel(GL_SMOOTH); + OpenGL_state.cur_light_state = LS_NONE; + break; + case LS_FLAT_GOURAUD: + //glShadeModel(GL_SMOOTH); + OpenGL_state.cur_light_state = LS_FLAT_GOURAUD; + break; + case LS_GOURAUD: + case LS_PHONG: + //glShadeModel(GL_SMOOTH); + OpenGL_state.cur_light_state = LS_GOURAUD; + break; + default: + Int3(); + break; + } + + CHECK_ERROR(13) +} +// returns the alpha that we should use +float opengl_GetAlphaMultiplier(void) +{ + switch (OpenGL_state.cur_alpha_type) + { + case AT_ALWAYS: + return 1.0; + case AT_CONSTANT: + return OpenGL_state.cur_alpha / 255.0; + case AT_TEXTURE: + return 1.0; + case AT_CONSTANT_TEXTURE: + return OpenGL_state.cur_alpha / 255.0; + case AT_VERTEX: + return 1.0; + case AT_CONSTANT_TEXTURE_VERTEX: + case AT_CONSTANT_VERTEX: + return OpenGL_state.cur_alpha / 255.0; + case AT_TEXTURE_VERTEX: + return 1.0; + case AT_LIGHTMAP_BLEND: + case AT_LIGHTMAP_BLEND_SATURATE: + return OpenGL_state.cur_alpha / 255.0; + case AT_SATURATE_TEXTURE: + return OpenGL_state.cur_alpha / 255.0; + case AT_SATURATE_VERTEX: + return 1.0; + case AT_SATURATE_CONSTANT_VERTEX: + return OpenGL_state.cur_alpha / 255.0; + case AT_SATURATE_TEXTURE_VERTEX: + return 1.0; + case AT_SPECULAR: + return 1.0; + default: + //Int3(); // no type defined,get jason + return 0; + } +} + + +void opengl_SetAlwaysAlpha(bool state) +{ + if (state && OpenGL_blending_on) + { + glDisable(GL_BLEND); + //glDisable(GL_ALPHA_TEST); + OpenGL_blending_on = false; + } + else if (!state) + { + glEnable(GL_BLEND); + //glEnable(GL_ALPHA_TEST); + OpenGL_blending_on = true; + } +} + +void rend_SetAlphaType(int8_t atype) +{ + if (atype == OpenGL_state.cur_alpha_type) + return; // don't set it redundantly + if (UseMultitexture && Last_texel_unit_set != 0) + { + glActiveTexture(GL_TEXTURE0 + 0); + Last_texel_unit_set = 0; + + } + OpenGL_sets_this_frame[6]++; + + switch (atype) + { + case AT_ALWAYS: + rend_SetAlphaValue(255); + opengl_SetAlwaysAlpha(true); + glBlendFunc(GL_ONE, GL_ZERO); + break; + case AT_CONSTANT: + opengl_SetAlwaysAlpha(false); + glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + break; + case AT_TEXTURE: + rend_SetAlphaValue(255); + opengl_SetAlwaysAlpha(true); + glBlendFunc(GL_ONE, GL_ZERO); + break; + case AT_CONSTANT_TEXTURE: + case AT_CONSTANT_TEXTURE_VERTEX: + case AT_TEXTURE_VERTEX: + opengl_SetAlwaysAlpha(false); + glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + break; + case AT_CONSTANT_VERTEX: + opengl_SetAlwaysAlpha(false); + glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + break; + case AT_VERTEX: + opengl_SetAlwaysAlpha(false); + glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + break; + case AT_LIGHTMAP_BLEND: + opengl_SetAlwaysAlpha(false); + glBlendFunc(GL_DST_COLOR, GL_ZERO); + break; + case AT_SATURATE_TEXTURE: + case AT_LIGHTMAP_BLEND_SATURATE: + opengl_SetAlwaysAlpha(false); + glBlendFunc(GL_SRC_ALPHA, GL_ONE); + break; + case AT_SATURATE_VERTEX: + opengl_SetAlwaysAlpha(false); + glBlendFunc(GL_SRC_ALPHA, GL_ONE); + break; + case AT_SATURATE_CONSTANT_VERTEX: + opengl_SetAlwaysAlpha(false); + glBlendFunc(GL_SRC_ALPHA, GL_ONE); + break; + case AT_SATURATE_TEXTURE_VERTEX: + opengl_SetAlwaysAlpha(false); + glBlendFunc(GL_SRC_ALPHA, GL_ONE); + break; + case AT_SPECULAR: + opengl_SetAlwaysAlpha(false); + glBlendFunc(GL_SRC_ALPHA, GL_ONE); + + //hack + OpenGL_state.cur_texture_quality = 2; + OpenGL_state.cur_texture_type = TT_PERSPECTIVE; + + break; + default: + Int3(); // no type defined,get jason + break; + } + OpenGL_state.cur_alpha_type = atype; + Alpha_multiplier = opengl_GetAlphaMultiplier(); + CHECK_ERROR(15) +} + +// Sets the alpha value for constant alpha +void rend_SetAlphaValue(uint8_t val) +{ + OpenGL_state.cur_alpha = val; + Alpha_multiplier = opengl_GetAlphaMultiplier(); +} + +// Sets the overall alpha scale factor (all alpha values are scaled by this value) +// usefull for motion blur effect +void rend_SetAlphaFactor(float val) +{ + if (val < 0.0f) val = 0.0f; + if (val > 1.0f) val = 1.0f; + OpenGL_Alpha_factor = val; +} + +// Returns the current Alpha factor +float rend_GetAlphaFactor(void) +{ + return OpenGL_Alpha_factor; +} + +// Sets the texture wrapping type +void rend_SetWrapType(wrap_type val) +{ + OpenGL_state.cur_wrap_type = val; +} + +void rend_SetZBias(float z_bias) +{ + if (Z_bias != z_bias) + { + Z_bias = z_bias; + } +} + +// Enables/disables writes the depth buffer +void rend_SetZBufferWriteMask(int state) +{ + OpenGL_sets_this_frame[5]++; + if (state) + { + glDepthMask(GL_TRUE); + } + else + { + glDepthMask(GL_FALSE); + } +} + +// Returns the aspect ratio of the physical screen +void rend_GetProjectionParameters(int* width, int* height) +{ + *width = OpenGL_state.clip_x2 - OpenGL_state.clip_x1; + *height = OpenGL_state.clip_y2 - OpenGL_state.clip_y1; +} + +void rend_GetProjectionScreenParameters(int& screenLX, int& screenTY, int& screenW, int& screenH) +{ + screenLX = OpenGL_state.clip_x1; + screenTY = OpenGL_state.clip_y1; + screenW = OpenGL_state.clip_x2 - OpenGL_state.clip_x1 + 1; + screenH = OpenGL_state.clip_y2 - OpenGL_state.clip_y1 + 1; +} + +// Returns the aspect ratio of the physical screen +float rend_GetAspectRatio(void) +{ + float aspect_ratio = (float)((3.0f * OpenGL_state.screen_width) / (4.0f * OpenGL_state.screen_height)); + return aspect_ratio; +} + +// Sets the hardware bias level for coplanar polygons +// This helps reduce z buffer artifacts +void rend_SetCoplanarPolygonOffset(float factor) +{ + if (factor == 0.0f) + { + glDisable(GL_POLYGON_OFFSET_FILL); + } + else + { + glEnable(GL_POLYGON_OFFSET_FILL); + glPolygonOffset(-1.0f, -1.0f); + } +} + +// Preuploads a texture to the video card +void rend_PreUploadTextureToCard(int handle, int map_type) +{ +} + +// Frees an uploaded texture from the video card +void rend_FreePreUploadedTexture(int handle, int map_type) +{ +} + +char Renderer_error_message[256]; +// Retrieves an error message +const char* rend_GetErrorMessage() +{ + return Renderer_error_message; +} + +// Sets an error message +void rend_SetErrorMessage(const char* str) +{ + ASSERT(strlen(str) < 256); + strcpy(Renderer_error_message, str); +} + +// Returns 1 if there is mid video memory, 2 if there is low vid memory, or 0 if there is large vid memory +int rend_LowVidMem(void) +{ + return 0; +} + +// Returns 1 if the renderer supports bumpmapping +int rend_SupportsBumpmapping(void) +{ + return 0; +} + +// Sets a bumpmap to be rendered, or turns off bumpmapping altogether +void rend_SetBumpmapReadyState(int state, int map) +{ +} + +// returns the direct draw object +void* rend_RetrieveDirectDrawObj(void** frontsurf, void** backsurf) +{ + *frontsurf = NULL; + *backsurf = NULL; + return NULL; +} + +// returns rendering statistics for the frame +void rend_GetStatistics(tRendererStats* stats) +{ + if (Renderer_initted) + { + stats->poly_count = OpenGL_last_frame_polys_drawn; + stats->vert_count = OpenGL_last_frame_verts_processed; + stats->texture_uploads = OpenGL_last_uploaded; + } + else + { + memset(stats, 0, sizeof(tRendererStats)); + } +} + +// Tells the software renderer whether or not to use mipping +void rend_SetMipState(int8_t mipstate) +{ + OpenGL_state.cur_mip_state = mipstate; +} + +void rend_TransformSetToPassthru(void) +{ +} + +void rend_TransformSetViewport(int lx, int ty, int width, int height) +{ +} + +void rend_TransformSetProjection(float trans[4][4]) +{ +} + +void rend_TransformSetModelView(float trans[4][4]) +{ +} + +// Fills in the passed in pointer with the current rendering state +void rend_GetRenderState(rendering_state* rstate) +{ + memcpy(rstate, &OpenGL_state, sizeof(rendering_state)); +} + +void rend_DLLGetRenderState(DLLrendering_state* rstate) +{ +#define COPY_ELEMENT(element) rstate->element = OpenGL_state.element; + COPY_ELEMENT(initted); + COPY_ELEMENT(cur_bilinear_state); + COPY_ELEMENT(cur_zbuffer_state); + COPY_ELEMENT(cur_fog_state); + COPY_ELEMENT(cur_mip_state); + COPY_ELEMENT(cur_texture_type); + COPY_ELEMENT(cur_color_model); + COPY_ELEMENT(cur_light_state); + COPY_ELEMENT(cur_alpha_type); + COPY_ELEMENT(cur_wrap_type); + COPY_ELEMENT(cur_fog_start); + COPY_ELEMENT(cur_fog_end); + COPY_ELEMENT(cur_near_z); + COPY_ELEMENT(cur_far_z); + COPY_ELEMENT(gamma_value); + COPY_ELEMENT(cur_alpha); + COPY_ELEMENT(cur_color); + COPY_ELEMENT(cur_fog_color); + COPY_ELEMENT(cur_texture_quality); + COPY_ELEMENT(clip_x1); + COPY_ELEMENT(clip_x2); + COPY_ELEMENT(clip_y1); + COPY_ELEMENT(clip_y2); + COPY_ELEMENT(screen_width); + COPY_ELEMENT(screen_height); +#undef COPY_ELEMENT +} + +// Takes a screenshot of the current frame and puts it into the handle passed +std::unique_ptr rend_Screenshot() { + uint16_t *dest_data; + uint32_t *temp_data; + + int total = OpenGL_state.screen_width * OpenGL_state.screen_height; + auto result = std::make_unique(OpenGL_state.screen_width, OpenGL_state.screen_height, PixelDataFormat::RGBA32, true); + + if (!result || result->getData() == nullptr) { + return nullptr; + } + + glad_glReadPixels(0, 0, OpenGL_state.screen_width, OpenGL_state.screen_height, GL_RGBA, GL_UNSIGNED_BYTE, + (GLvoid *)result->getData()); + + return result; +} + +// Takes a screenshot of the current frame and puts it into the handle passed +void rend_Screenshot(int bm_handle) { + auto screenshot = rend_Screenshot(); + auto *temp_data = reinterpret_cast(screenshot->getData()); + + uint32_t w, h; + screenshot->getSize(w, h); + + ASSERT((bm_w(bm_handle, 0)) == OpenGL_state.screen_width); + ASSERT((bm_h(bm_handle, 0)) == OpenGL_state.screen_height); + + uint16_t* dest_data = bm_data(bm_handle, 0); + + for (int i = 0; i < h; i++) { + for (int t = 0; t < w; t++) { + uint32_t spix = temp_data[i * w + t]; + + int r = spix & 0xff; + int g = (spix >> 8) & 0xff; + int b = (spix >> 16) & 0xff; + + dest_data[(((h - 1) - i) * w) + t] = GR_RGB16(r, g, b); + } + } +} + +void opengl_UpdateFramebuffer(void) +{ + for (int i = 0; i < NUM_FBOS; i++) + { + framebuffers[i].Update(OpenGL_state.screen_width, OpenGL_state.screen_height, OpenGL_preferred_state.antialised); + } + + framebuffer_current_draw = 0; + glBindFramebuffer(GL_DRAW_FRAMEBUFFER, framebuffers[0].Handle()); + //Unbind the read framebuffer so that OBS can capture the window properly + glBindFramebuffer(GL_READ_FRAMEBUFFER, 0); + + GL_InitFramebufferVAO(); +} + +void opengl_CloseFramebuffer(void) +{ + for (int i = 0; i < NUM_FBOS; i++) + { + framebuffers[i].Destroy(); + } + + glBindFramebuffer(GL_FRAMEBUFFER, 0); + + GL_DestroyFramebufferVAO(); +} + +//shader test +void rend_UseShaderTest(void) +{ + testshader.Use(); +} + +void rend_EndShaderTest(void) +{ + glUseProgram(0); +} diff --git a/renderer/gl_mesh.cpp b/renderer/gl_mesh.cpp new file mode 100644 index 000000000..70532a91a --- /dev/null +++ b/renderer/gl_mesh.cpp @@ -0,0 +1,229 @@ +/* +* Descent 3: Piccu Engine +* Copyright (C) 2024 SaladBadger +* +* This program is free software: you can redistribute it and/or modify +* it under the terms of the GNU General Public License as published by +* the Free Software Foundation, either version 3 of the License, or +* (at your option) any later version. +* +* This program is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +* GNU General Public License for more details. +* +* You should have received a copy of the GNU General Public License +* along with this program. If not, see . +*/ + +#include "gl_local.h" +#include "gl_mesh.h" + +MeshBuilder::MeshBuilder() +{ + m_handle = m_verthandle = m_indexhandle = 0; + m_initialized = false; +} + +void MeshBuilder::UpdateLastBatch() +{ + if (m_interactions.empty()) + return; + + MeshBatch& lastbatch = m_interactions.back(); + lastbatch.vertexcount = m_vertices.size() - lastbatch.vertexoffset; + lastbatch.indexcount = m_indicies.size() - lastbatch.indexoffset; +} + +void MeshBuilder::StartBatchSolid() +{ + UpdateLastBatch(); + + MeshBatch batch; + batch.primaryhandle = batch.secondaryhandle = -1; + batch.vertexoffset = m_vertices.size(); + batch.vertexcount = 0; + batch.indexoffset = m_indicies.size(); + batch.indexcount = 0; + m_interactions.push_back(batch); +} + +void MeshBuilder::StartBatchOneTex(int handle) +{ + UpdateLastBatch(); + + MeshBatch batch; + batch.primaryhandle = handle; + batch.secondaryhandle = -1; + batch.vertexoffset = m_vertices.size(); + batch.vertexcount = 0; + batch.indexoffset = m_indicies.size(); + batch.indexcount = 0; + m_interactions.push_back(batch); +} + +void MeshBuilder::StartBatchTwoTex(int handle, int handle2) +{ + UpdateLastBatch(); + + MeshBatch batch; + batch.primaryhandle = handle; + batch.secondaryhandle = handle2; + batch.vertexoffset = m_vertices.size(); + batch.vertexcount = 0; + batch.indexoffset = m_indicies.size(); + batch.indexcount = 0; + m_interactions.push_back(batch); +} + +void MeshBuilder::SetVertices(int numverts, RendVertex* vertices) +{ + //This needs some optimization + for (int i = 0; i < numverts; i++) + m_vertices.push_back(vertices[i]); +} + +void MeshBuilder::SetIndicies(int numindices, short* indicies) +{ + for (int i = 0; i < numindices; i++) + m_indicies.push_back(indicies[i]); +} + +void MeshBuilder::Build() +{ + if (m_handle) + Destroy(); + + UpdateLastBatch(); + + if (m_handle == 0) + glGenVertexArrays(1, &m_handle); + + glBindVertexArray(m_handle); + + if (m_verthandle == 0) + glGenBuffers(1, &m_verthandle); + + glBindBuffer(GL_ARRAY_BUFFER, m_verthandle); + glBufferData(GL_ARRAY_BUFFER, sizeof(RendVertex) * m_vertices.size(), m_vertices.data(), GL_STATIC_DRAW); + + if (!m_initialized) + { + //Create the standard vertex attributes + //Position + glEnableVertexAttribArray(0); + glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(RendVertex), (void*)offsetof(RendVertex, position)); + + //Color + glEnableVertexAttribArray(1); + glVertexAttribPointer(1, 4, GL_BYTE, GL_TRUE, sizeof(RendVertex), (void*)offsetof(RendVertex, r)); + + //Normal + glEnableVertexAttribArray(2); + glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE, sizeof(RendVertex), (void*)offsetof(RendVertex, normal)); + + //Lightmap page + glEnableVertexAttribArray(3); + glVertexAttribIPointer(3, 1, GL_INT, sizeof(RendVertex), (void*)offsetof(RendVertex, lmpage)); + + //Base UV + glEnableVertexAttribArray(4); + glVertexAttribPointer(4, 2, GL_FLOAT, GL_FALSE, sizeof(RendVertex), (void*)offsetof(RendVertex, u1)); + + //Overlay UV + glEnableVertexAttribArray(5); + glVertexAttribPointer(5, 2, GL_FLOAT, GL_FALSE, sizeof(RendVertex), (void*)offsetof(RendVertex, u2)); + + //UV slide + glEnableVertexAttribArray(6); + glVertexAttribPointer(6, 2, GL_FLOAT, GL_FALSE, sizeof(RendVertex), (void*)offsetof(RendVertex, u2)); + } + + //Check if indicies are being used + if (!m_indicies.empty()) + { + if (!m_indexhandle) + glGenBuffers(1, &m_indexhandle); + + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_indexhandle); + glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(short) * m_indicies.size(), m_indicies.data(), GL_STATIC_DRAW); + } + + //All the data is GPU side now, so no sense in keeping this around + m_vertices.clear(); + m_indicies.clear(); + + GL_UseDrawVAO(); + //TODO: Once everything is using GL 3.3 systems this shouldn't be done anymore + //glBindVertexArray(0); +} + +void MeshBuilder::Destroy() +{ + if (m_indexhandle) + { + glDeleteBuffers(1, &m_indexhandle); + m_indexhandle = 0; + } + + if (m_verthandle) + { + glDeleteBuffers(1, &m_verthandle); + m_verthandle = 0; + } + + if (m_handle) + { + glDeleteVertexArrays(1, &m_handle); + m_handle = 0; + } + + m_vertices.clear(); + m_indicies.clear(); + m_interactions.clear(); +} + +void MeshBuilder::Reset() +{ + m_vertices.clear(); + m_indicies.clear(); + m_interactions.clear(); +} + +void MeshBuilder::Draw() const +{ + glBindVertexArray(m_handle); + if (m_indexhandle) + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_indexhandle); + + for (const MeshBatch& batch : m_interactions) + { + //Why have I not made a "make bitmap current" function yet? + if (batch.primaryhandle >= 0) + { + opengl_MakeBitmapCurrent(batch.primaryhandle, MAP_TYPE_BITMAP, 0); + opengl_MakeWrapTypeCurrent(batch.primaryhandle, MAP_TYPE_BITMAP, 0); + opengl_MakeFilterTypeCurrent(batch.primaryhandle, MAP_TYPE_BITMAP, 0); + } + if (batch.secondaryhandle >= 0) + { + opengl_MakeBitmapCurrent(batch.secondaryhandle, MAP_TYPE_LIGHTMAP, 1); + opengl_MakeWrapTypeCurrent(batch.secondaryhandle, MAP_TYPE_LIGHTMAP, 1); + opengl_MakeFilterTypeCurrent(batch.secondaryhandle, MAP_TYPE_LIGHTMAP, 1); + } + //Eventually third overlay type for bump mapping? + + if (m_indexhandle) + glDrawElements(GL_TRIANGLES, batch.indexcount, GL_UNSIGNED_SHORT, (const void*)(batch.indexoffset * sizeof(uint16_t))); + else + glDrawArrays(GL_TRIANGLES, batch.vertexoffset, batch.vertexcount); + +#ifndef NDEBUG + GLenum err = glGetError(); + if (err != GL_NO_ERROR) + Int3(); +#endif + } + + GL_UseDrawVAO(); +} diff --git a/renderer/gl_mesh.h b/renderer/gl_mesh.h new file mode 100644 index 000000000..6c6e0c1d5 --- /dev/null +++ b/renderer/gl_mesh.h @@ -0,0 +1,109 @@ +/* +* Descent 3: Piccu Engine +* Copyright (C) 2024 SaladBadger +* +* This program is free software: you can redistribute it and/or modify +* it under the terms of the GNU General Public License as published by +* the Free Software Foundation, either version 3 of the License, or +* (at your option) any later version. +* +* This program is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +* GNU General Public License for more details. +* +* You should have received a copy of the GNU General Public License +* along with this program. If not, see . +*/ + +#pragma once + +#include +#include "pstypes.h" +#include "vecmat.h" + +//A sortable element is used to batch up elements by their texture and lightmap handle, if used. +struct SortableElement +{ + int element; + short texturehandle; + short lmhandle; + + friend bool operator<(const SortableElement& l, const SortableElement& r) + { + uint lh = l.texturehandle | l.lmhandle << 16; + uint rh = r.texturehandle | r.lmhandle << 16; + + return lh < rh; + } +}; + +struct RendVertex +{ + vector position; + uint8_t r, g, b, a; + vector normal; + int lmpage; + float u1, v1; + float u2, v2; + float uslide, vslide; //only slide uv1 for the moment +}; + +//A batch of 0-2 texture handles. +struct MeshBatch +{ + int primaryhandle; + int secondaryhandle; + int vertexoffset, vertexcount; + int indexoffset, indexcount; +}; + +class MeshBuilder +{ + unsigned int m_handle; + unsigned int m_verthandle, m_indexhandle; + bool m_initialized; + + std::vector m_interactions; + std::vector m_vertices; + std::vector m_indicies; + + //Updates the counts of the last batch if relevant. + void UpdateLastBatch(); +public: + MeshBuilder(); + + //Starts a solid batch with no textures. + //Do not mix this with any of the textured forms. + //These probably could take shader program numbers to deal with that but eh + void StartBatchSolid(); + + //Starts a textured batch with one texture. + void StartBatchOneTex(int handle); + //Starts a textured batch with two textures. + void StartBatchTwoTex(int handle, int handle2); + + //Sets the vertices for this mesh builder to use. + void SetVertices(int numverts, RendVertex* vertices); + + //Sets the indicies for this mesh builder to use. Optional. + //If set, drawing the mesh will use the index buffer while drawing. + void SetIndicies(int numindices, short* indicies); + + //Updates the buffer. When called for the first time, will create all the relevant state + //Can be called again to update the buffers. + void Build(); + + void Destroy(); + + //For dynamic meshes + void Reset(); + + //Draws the mesh with the currently bound shader. + void Draw() const; + + int NumVertices() const + { + return m_vertices.size(); + } +}; diff --git a/renderer/gl_shader.cpp b/renderer/gl_shader.cpp new file mode 100644 index 000000000..6cdeefb05 --- /dev/null +++ b/renderer/gl_shader.cpp @@ -0,0 +1,217 @@ +/* +* Piccu Engine +* Copyright (C) 2024 SaladBadger +* +* This program is free software: you can redistribute it and/or modify +* it under the terms of the GNU General Public License as published by +* the Free Software Foundation, either version 3 of the License, or +* (at your option) any later version. +* +* This program is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +* GNU General Public License for more details. +* +* You should have received a copy of the GNU General Public License +* along with this program. If not, see . +*/ +#include +#include +#include "gl_shader.h" +#include "pserror.h" + +GLuint commonbuffername; +GLuint legacycommonbuffername; + +void opengl_InitCommonBuffer(void) +{ + glGenBuffers(1, &commonbuffername); + glBindBuffer(GL_COPY_WRITE_BUFFER, commonbuffername); + glBufferData(GL_COPY_WRITE_BUFFER, sizeof(CommonBlock), nullptr, GL_DYNAMIC_READ); + glBindBufferBase(GL_UNIFORM_BUFFER, 0, commonbuffername); + + GLenum err = glGetError(); + if (err != GL_NO_ERROR) + Int3(); + + //Ensure this is always ready for usage later. + + //The legacy common buffer uses the ortho matrix as a passthrough. + glGenBuffers(1, &legacycommonbuffername); + glBindBuffer(GL_COPY_WRITE_BUFFER, legacycommonbuffername); + glBufferData(GL_COPY_WRITE_BUFFER, sizeof(CommonBlock), nullptr, GL_DYNAMIC_READ); + glBindBufferBase(GL_UNIFORM_BUFFER, 1, legacycommonbuffername); + + err = glGetError(); + if (err != GL_NO_ERROR) + Int3(); +} + +void rend_UpdateCommon(float* projection, float* modelview) +{ + CommonBlock newblock; + memcpy(newblock.projection, projection, sizeof(newblock.projection)); + memcpy(newblock.modelview, modelview, sizeof(newblock.modelview)); + + glBindBuffer(GL_COPY_WRITE_BUFFER, commonbuffername); + glBufferSubData(GL_COPY_WRITE_BUFFER, 0, sizeof(CommonBlock), &newblock); + + GLenum err = glGetError(); + if (err != GL_NO_ERROR) + Int3(); +} + +void GL_UpdateLegacyBlock(float* projection, float* modelview) +{ + CommonBlock newblock; + memcpy(newblock.projection, projection, sizeof(newblock.projection)); + memcpy(newblock.modelview, modelview, sizeof(newblock.modelview)); + + glBindBuffer(GL_COPY_WRITE_BUFFER, legacycommonbuffername); + glBufferSubData(GL_COPY_WRITE_BUFFER, 0, sizeof(CommonBlock), &newblock); + + GLenum err = glGetError(); + if (err != GL_NO_ERROR) + Int3(); +} + +static GLuint CompileShader(GLenum type, int numstrs, const char** src, GLint* lengths) +{ + GLuint name = glCreateShader(type); + glShaderSource(name, numstrs, src, lengths); + glCompileShader(name); + GLint status; + glGetShaderiv(name, GL_COMPILE_STATUS, &status); + if (status == GL_FALSE) + { + GLint length; + glGetShaderiv(name, GL_INFO_LOG_LENGTH, &length); + char* buf = new char[length]; + glGetShaderInfoLog(name, length, &length, buf); + + mprintf((1, "%s\n", buf)); + Error("CompileShader: Failed to compile shader! This error message needs more context..\n%s", buf); + } + + return name; +} + +void ShaderProgram::CreateCommonBindings(int bindindex) +{ + Use(); + + //Find colortexture + GLint index = glGetUniformLocation(m_name, "colortexture"); + if (index != -1) + glUniform1i(index, 0); //Set to GL_TEXTURE0 + + //Find lightmaptexture + index = glGetUniformLocation(m_name, "lightmaptexture"); + if (index != -1) + glUniform1i(index, 1); //Set to GL_TEXTURE1 + + //Find CommonBlock + GLuint uboindex = glGetUniformBlockIndex(m_name, "CommonBlock"); + if (uboindex != GL_INVALID_INDEX) + { + //Bind to GL_UNIFORM_BUFFER bindindex. This is so that "legacy" shaders can have the passthrough matricies. + glUniformBlockBinding(m_name, uboindex, bindindex); + } + + GLenum err = glGetError(); + if (err != GL_NO_ERROR) + Int3(); + + glUseProgram(0); +} + +void ShaderProgram::AttachSource(const char* vertexsource, const char* fragsource) +{ + GLint vertexsourcelen = strlen(vertexsource); + GLint fragsourcelen = strlen(fragsource); + GLuint vertexprog = CompileShader(GL_VERTEX_SHADER, 1, &vertexsource, &vertexsourcelen); + GLuint fragmentprog = CompileShader(GL_FRAGMENT_SHADER, 1, &fragsource, &fragsourcelen); + + m_name = glCreateProgram(); + glAttachShader(m_name, vertexprog); + glAttachShader(m_name, fragmentprog); + glLinkProgram(m_name); + GLint status; + glGetProgramiv(m_name, GL_LINK_STATUS, &status); + if (status == GL_FALSE) + { + GLint length; + glGetProgramiv(m_name, GL_INFO_LOG_LENGTH, &length); + char* buf = new char[length]; + glGetProgramInfoLog(m_name, length, &length, buf); + + Error("ShaderProgram::AttachSource: Failed to link program! This error message needs more context..\n%s", buf); + } + + glDeleteShader(vertexprog); + glDeleteShader(fragmentprog); + + CreateCommonBindings(0); +} + +void ShaderProgram::AttachSourcePreprocess(const char* vertexsource, const char* fragsource, bool textured, bool lightmapped, bool speculared) +{ + const char* vertexstrs[3]; + GLint vertexlens[3]; + const char* fragstrs[3]; + GLint fraglens[3]; + + vertexstrs[0] = fragstrs[0] = "#version 330 core\n"; + vertexlens[0] = fraglens[0] = strlen(vertexstrs[0]); + + std::string preprocessorstr; + if (textured) + preprocessorstr.append("#define USE_TEXTURING\n"); + if (lightmapped) + preprocessorstr.append("#define USE_LIGHTMAP\n"); + if (speculared) + preprocessorstr.append("#define USE_SPECULAR\n"); + + vertexstrs[1] = fragstrs[1] = preprocessorstr.c_str(); + vertexlens[1] = fraglens[1] = preprocessorstr.size(); + + vertexstrs[2] = vertexsource; vertexlens[2] = strlen(vertexsource); + fragstrs[2] = fragsource; fraglens[2] = strlen(fragsource); + + GLuint vertexprog = CompileShader(GL_VERTEX_SHADER, 3, vertexstrs, vertexlens); + GLuint fragmentprog = CompileShader(GL_FRAGMENT_SHADER, 3, fragstrs, fraglens); + + m_name = glCreateProgram(); + glAttachShader(m_name, vertexprog); + glAttachShader(m_name, fragmentprog); + glLinkProgram(m_name); + GLint status; + glGetProgramiv(m_name, GL_LINK_STATUS, &status); + if (status == GL_FALSE) + { + GLint length; + glGetProgramiv(m_name, GL_INFO_LOG_LENGTH, &length); + char* buf = new char[length]; + glGetProgramInfoLog(m_name, length, &length, buf); + + Error("ShaderProgram::AttachSource: Failed to link program! This error message needs more context..\n%s", buf); + } + + glDeleteShader(vertexprog); + glDeleteShader(fragmentprog); + + //Always use the legacy block with these preprocessed shaders, for now. + CreateCommonBindings(1); +} + +GLint ShaderProgram::FindUniform(const char* uniform) +{ + return glGetUniformLocation(m_name, uniform); +} + +void ShaderProgram::Destroy() +{ + glUseProgram(0); + glDeleteProgram(m_name); + m_name = 0; +} diff --git a/renderer/gl_shader.h b/renderer/gl_shader.h new file mode 100644 index 000000000..203689773 --- /dev/null +++ b/renderer/gl_shader.h @@ -0,0 +1,60 @@ +/* +* Piccu Engine +* Copyright (C) 2024 SaladBadger +* +* This program is free software: you can redistribute it and/or modify +* it under the terms of the GNU General Public License as published by +* the Free Software Foundation, either version 3 of the License, or +* (at your option) any later version. +* +* This program is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +* GNU General Public License for more details. +* +* You should have received a copy of the GNU General Public License +* along with this program. If not, see . +*/ +#pragma once +#include + +struct CommonBlock +{ + float projection[16]; + float modelview[16]; +}; + +void opengl_InitCommonBuffer(void); + +class ShaderProgram +{ + GLuint m_name; + //CreateCommonBindings will find common uniforms and set their default bindings. + //This includes the common block, which must be named "common", + //and sampler2Ds named "colortexture", "lightmaptexture", and others later. + void CreateCommonBindings(int bindindex); +public: + ShaderProgram() + { + m_name = 0; + } + + void AttachSource(const char* vertexsource, const char* fragsource); + //Attaches strings with some preprocessor statements. + //Defines USE_TEXTURING if textured is true. + //Defines USE_LIGHTMAP if lightmapped is true. + //Defines USE_SPECULAR if speculared is true. + void AttachSourcePreprocess(const char* vertexsource, const char* fragsource, bool textured, bool lightmapped, bool speculared); + GLint FindUniform(const char* uniform); + void Destroy(); + + void Use() + { + glUseProgram(m_name); + } + + GLuint Handle() const + { + return m_name; + } +}; diff --git a/renderer/gl_shadersource.cpp b/renderer/gl_shadersource.cpp new file mode 100644 index 000000000..40636eaab --- /dev/null +++ b/renderer/gl_shadersource.cpp @@ -0,0 +1,157 @@ +/* +* Piccu Engine +* Copyright (C) 2024 SaladBadger +* +* This program is free software: you can redistribute it and/or modify +* it under the terms of the GNU General Public License as published by +* the Free Software Foundation, either version 3 of the License, or +* (at your option) any later version. +* +* This program is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +* GNU General Public License for more details. +* +* You should have received a copy of the GNU General Public License +* along with this program. If not, see . +*/ + +const char* blitVertexSrc = +"#version 330 core\n" +"\n" +"layout(location = 0) in vec2 position;\n" +"layout(location = 1) in vec2 uv;\n" +"\n" +"out vec2 outuv;\n" +"\n" +"void main()\n" +"{\n" +"gl_Position = vec4(position, 0.0, 1.0);\n" +"outuv = uv;" +"}\n" +""; + +const char* blitFragmentSrc = +"#version 330 core\n" +"\n" +"in vec2 outuv;\n" +"\n" +"out vec4 color;\n" +"\n " +"uniform sampler2D heh;\n" +"uniform float gamma;\n" +"\n" +"void main()\n" +"{\n" +"vec4 sourcecolor = texture(heh, outuv);\n" +"color = vec4(pow(sourcecolor.rgb, vec3(gamma)), sourcecolor.a);\n" +"}\n" +""; + +const char* testVertexSrc = +"#version 330 core\n" +"\n" +"layout(std140) uniform CommonBlock\n" +"{\n" +" mat4 projection;\n" +" mat4 modelview;\n" +"} commons;\n" +"\n" +"layout(location = 0) in vec3 position;\n" +"layout(location = 4) in vec2 uv;\n" +"layout(location = 5) in vec2 uv2;\n" +"\n" +"out vec2 outuv;\n" +"out vec2 outuv2;\n" +"\n" +"void main()\n" +"{\n" +" vec4 temp = commons.modelview * vec4(position, 1.0);\n" +" gl_Position = commons.projection * vec4(temp.xy, -temp.z, temp.w);\n" +" outuv = uv;\n" +" outuv2 = uv2;\n" +"}\n" +""; + +const char* testFragmentSrc = +"#version 330 core\n" +"\n" +"uniform sampler2D colortexture;\n" +"uniform sampler2D lightmaptexture;\n" +"\n" +"in vec2 outuv;\n" +"in vec2 outuv2;\n" +"\n" +"out vec4 color;\n" +"\n" +"void main()\n" +"{\n" +" vec4 basecolor = texture(colortexture, outuv);\n" +" color = vec4(basecolor.rgb * texture(lightmaptexture, outuv2).rgb, basecolor.a);\n" +"}\n" +""; + +const char* genericVertexBody = +"layout(std140) uniform CommonBlock\n" +"{\n" +" mat4 projection;\n" +" mat4 modelview;\n" +"} commons;\n" +"\n" +"layout(location = 0) in vec3 position;\n" +"layout(location = 1) in vec4 color;\n" +"layout(location = 2) in vec4 uv;\n" +"layout(location = 3) in vec4 uv2;\n" +"\n" +"out vec4 outcolor;\n" +"#if defined(USE_TEXTURING)\n" +"out vec4 outuv;\n" +"#if defined(USE_LIGHTMAP)\n" +"out vec4 outuv2;\n" +"#endif\n" +"#endif\n" +"\n" +"void main()\n" +"{\n" +" gl_Position = commons.projection * commons.modelview * vec4(position, 1.0);\n" +" outcolor = color;\n" +" #if defined(USE_TEXTURING)\n" +" outuv = uv;\n" +" #if defined(USE_LIGHTMAP)\n" +" outuv2 = uv2;\n" +" #endif\n" +" #endif\n" +"}\n" +""; + +const char* genericFragBody = +"#if defined(USE_TEXTURING)\n" +"uniform sampler2D colortexture;\n" +"#if defined(USE_LIGHTMAP)\n" +"uniform sampler2D lightmaptexture;\n" +"#endif\n" +"#endif\n" +"\n" +"in vec4 outcolor;\n" +"#if defined(USE_TEXTURING)\n" +"in vec4 outuv;\n" +"#if defined(USE_LIGHTMAP)\n" +"in vec4 outuv2;\n" +"#endif\n" +"#endif\n" +"\n" +"out vec4 color;\n" +"\n" +"void main()\n" +"{\n" +" #if defined(USE_SPECULAR)\n" +" color = vec4(outcolor.rgb, texture(colortexture, outuv.xy / outuv.w).a * outcolor.a);\n" +" #elif defined(USE_TEXTURING) && defined(USE_LIGHTMAP)\n" +" color = texture(colortexture, outuv.xy / outuv.w) * texture(lightmaptexture, outuv2.xy / outuv2.w) * outcolor;\n" +" #elif defined(USE_TEXTURING)\n" +" color = texture(colortexture, outuv.xy / outuv.w) * outcolor;\n" +" #else\n" +" color = outcolor;\n" +" #endif\n" +"}\n" +""; \ No newline at end of file diff --git a/renderer/HardwareGlobalVars.cpp b/renderer/globalvars.cpp similarity index 66% rename from renderer/HardwareGlobalVars.cpp rename to renderer/globalvars.cpp index 439cee32e..ebe09a017 100644 --- a/renderer/HardwareGlobalVars.cpp +++ b/renderer/globalvars.cpp @@ -1,4 +1,4 @@ -/* +/* * Descent 3 * Copyright (C) 2024 Parallax Software * @@ -15,30 +15,29 @@ * You should have received a copy of the GNU General Public License * along with this program. If not, see . */ - #include "3d.h" #include "HardwareInternal.h" #include -vector View_position; -float View_zoom; +vector View_position; +float View_zoom; -float Far_clip_z = FLT_MAX; // set to a really really far distance initially +float Far_clip_z=FLT_MAX; // set to a really really far distance initially -uint8_t Clip_custom = 0; -float Clip_plane_distance = 0; -vector Clip_plane; +uint8_t Clip_custom=0; +float Clip_plane_distance=0; +vector Clip_plane; -matrix Unscaled_matrix; // before scaling -matrix View_matrix; +matrix Unscaled_matrix; //before scaling +matrix View_matrix; -vector Matrix_scale; // how the matrix is scaled, window_scale * zoom +vector Matrix_scale; //how the matrix is scaled, window_scale * zoom -int Window_width; // the actual width -int Window_height; // the actual height +int Window_width; //the actual width +int Window_height; //the actual height -float Window_w2; // width/2 -float Window_h2; // height/2 +float Window_w2; //width/2 +float Window_h2; //height/2 float gTransformViewPort[4][4]; float gTransformProjection[4][4]; diff --git a/renderer/instance.cpp b/renderer/instance.cpp new file mode 100644 index 000000000..c81dca161 --- /dev/null +++ b/renderer/instance.cpp @@ -0,0 +1,96 @@ +/* +* Descent 3 +* Copyright (C) 2024 Parallax Software +* +* This program is free software: you can redistribute it and/or modify +* it under the terms of the GNU General Public License as published by +* the Free Software Foundation, either version 3 of the License, or +* (at your option) any later version. +* +* This program is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +* GNU General Public License for more details. +* +* You should have received a copy of the GNU General Public License +* along with this program. If not, see . +*/ +#include "3d.h" +#include "HardwareInternal.h" +#include + +struct InstanceContext +{ + matrix m_viewMatrix; // matrix + matrix m_unscaledMatrix; // unscaled matrix + vector m_viewPosition; // position + float m_modelView[4][4]; // model/view transform +}; + +#define MAX_INSTANCE_DEPTH 30 +static InstanceContext sInstanceStack[MAX_INSTANCE_DEPTH]; +static int sInstanceDepth = 0; + +//instance at specified point with specified orientation +void g3_StartInstanceMatrix( vector *pos, matrix *orient ) +{ + ASSERT( orient != NULL ); + ASSERT( sInstanceDepth < MAX_INSTANCE_DEPTH ); + + sInstanceStack[sInstanceDepth].m_viewMatrix = View_matrix; + sInstanceStack[sInstanceDepth].m_viewPosition = View_position; + sInstanceStack[sInstanceDepth].m_unscaledMatrix = Unscaled_matrix; + memcpy( sInstanceStack[sInstanceDepth].m_modelView, gTransformModelView, sizeof(gTransformModelView) ); + ++sInstanceDepth; + + //step 1: subtract object position from view position + vector tempv = View_position - *pos; + + //step 2: rotate view vector through object matrix + View_position = tempv * *orient; + + //step 3: rotate object matrix through view_matrix (vm = ob * vm) + matrix tempm, tempm2 = ~*orient; + + tempm = tempm2 * View_matrix; + View_matrix = tempm; + + tempm = tempm2 * Unscaled_matrix; + Unscaled_matrix = tempm; + + // transform the model/view matrix + g3_GetModelViewMatrix( &View_position, &Unscaled_matrix, (float*)gTransformModelView ); + g3_UpdateFullTransform(); +} + + +//instance at specified point with specified orientation +void g3_StartInstanceAngles(vector *pos,angvec *angles) +{ + if( angles == NULL ) + { + matrix ident; + vm_MakeIdentity( &ident ); + g3_StartInstanceMatrix( pos, &ident ); + return; + } + + matrix tm; + vm_AnglesToMatrix( &tm, angles->p, angles->h, angles->b ); + + g3_StartInstanceMatrix( pos, &tm ); +} + + +//pops the old context +void g3_DoneInstance() +{ + --sInstanceDepth; + ASSERT( sInstanceDepth >= 0 ); + + View_position = sInstanceStack[sInstanceDepth].m_viewPosition; + View_matrix = sInstanceStack[sInstanceDepth].m_viewMatrix; + Unscaled_matrix = sInstanceStack[sInstanceDepth].m_unscaledMatrix; + memcpy( gTransformModelView, sInstanceStack[sInstanceDepth].m_modelView, sizeof(gTransformModelView) ); + g3_UpdateFullTransform(); +} \ No newline at end of file diff --git a/renderer/lnxscreenmode.cpp b/renderer/lnxscreenmode.cpp deleted file mode 100644 index dbba3281b..000000000 --- a/renderer/lnxscreenmode.cpp +++ /dev/null @@ -1,310 +0,0 @@ -/* -* Descent 3 -* Copyright (C) 2024 Parallax Software -* -* This program is free software: you can redistribute it and/or modify -* it under the terms of the GNU General Public License as published by -* the Free Software Foundation, either version 3 of the License, or -* (at your option) any later version. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -* GNU General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program. If not, see . - ---- HISTORICAL COMMENTS FOLLOW --- - - * $Logfile: /DescentIII/Main/renderer/lnxscreenmode.cpp $ - * $Revision: 1.6 $ - * $Date: 2000/06/29 18:48:13 $ - * $Author: icculus $ - * - * - * - * $Log: lnxscreenmode.cpp,v $ - * Revision 1.6 2000/06/29 18:48:13 icculus - * Dumb typo fixed. - * - * Revision 1.5 2000/06/29 06:41:24 icculus - * mad commits. - * - * Revision 1.4 2000/06/24 01:15:15 icculus - * patched to compile. - * - * Revision 1.3 2000/05/29 05:25:57 icculus - * Command line fix: Changed "--nofullscreen" to "--windowed" (or "-w"). - * - * Revision 1.2 2000/04/28 20:25:51 icculus - * Updates, cleanups, and SDLification. - * - * Revision 1.1.1.1 2000/04/18 00:00:49 icculus - * initial checkin - * - * - * 4 9/09/99 4:38p Jeff - * fixed crashes if lib not loaded - * - * 3 9/06/99 9:21p Jeff - * lock video mode switching, don't set viewport when restoring (causing a - * bunch of screen garbage) - * - * 2 9/05/99 9:41p Jeff - * first checkin of Linux Screen manager - * - * $NoKeywords: $ - */ - -#include -#include -#include -#include "lnxscreenmode.h" -#include "pserror.h" -#include "args.h" - -CLnxVideoModes LinuxVideoMode; - -/* -typedef Bool (*VidModeQueryExtension_fp)(Display* dpy,int* event_base,int* error_base); -typedef Bool (*VidModeGetAllModeLines_fp)(Display* dpy,int screen,int* modecount,XF86VidModeModeInfo*** modelinesPtr); -typedef Bool (*VidModeSwitchToMode_fp)(Display* dpy,int screen,XF86VidModeModeInfo* modeline); -typedef Bool (*VidModeSetViewPort_fp)(Display* dpy,int screen,int x,int y); -typedef void (*VidModeFreeData_fp)(int num_modes,XF86VidModeModeInfo** modelinePtr); -typedef Bool (*VidModeGetModeLine_fp)(Display* dpy,int screen,int* dotclock,XF86VidModeModeLine* modeline); -typedef Bool (*VidModeLockModeSwitch_fp)(Display* dpy,int screen,int lock); - -VidModeQueryExtension_fp VidModeQueryExtension; -VidModeGetAllModeLines_fp VidModeGetAllModeLines; -VidModeSwitchToMode_fp VidModeSwitchToMode; -VidModeSetViewPort_fp VidModeSetViewPort; -VidModeFreeData_fp VidModeFreeData; -VidModeGetModeLine_fp VidModeGetModeLine; -VidModeLockModeSwitch_fp VidModeLockModeSwitch; -*/ - -CLnxVideoModes::CLnxVideoModes() { - m_Inited = false; - m_NumVideoModes = 0; - m_ModeInfoList = NULL; - // m_Display = NULL; - m_VideoResolutionChanged = false; - /* - VidModeQueryExtension = NULL; - VidModeGetAllModeLines = NULL; - VidModeSwitchToMode = NULL; - VidModeSetViewPort = NULL; - VidModeFreeData = NULL; - VidModeGetModeLine = NULL; - VidModeLockModeSwitch = NULL; - */ -} - -CLnxVideoModes::~CLnxVideoModes() { - if (!m_Inited) - return; - - // shutdown and free the memory - RestoreVideoMode(); - - // VidModeFreeData(m_NumVideoModes,m_ModeInfoList); -} - -// enumerate all the possible video modes -bool CLnxVideoModes::Init(void) // Display *dpy,int screen) -{ -#if 0 // with SDL2, we'll just use FULLSCREEN_DESKTOP and never change the physical vidmode - if (m_Inited) - return true; - - // m_Display = dpy; - // m_Screen = screen; - m_NumVideoModes = 0; - m_ModeInfoList = NULL; - m_Inited = true; - sdlflags = 0; - /* - if(!LoadLibraries()) - { - m_Inited = false; - fprintf(stdout,"LoadLib: Unable to load VideoMode libraries\n"); - return false; - } - - int dummy; - if(!VidModeQueryExtension(dpy,&dummy,&dummy)) - return false; - - if(!VidModeGetAllModeLines(m_Display,m_Screen,&m_NumVideoModes,&m_ModeInfoList)) - { - m_NumVideoModes = 0; - }else - { - */ - - const SDL_VideoInfo *vidInfo = NULL; - - sdlflags = SDL_HWSURFACE | SDL_FULLSCREEN; - sdlflags = SDL_OPENGL | SDL_FULLSCREEN; - if (FindArgChar("-windowed", 'w')) - sdlflags &= ~SDL_FULLSCREEN; - - vidInfo = SDL_GetVideoInfo(); - - m_ModeInfoList = SDL_ListModes(vidInfo->vfmt, sdlflags); - if (m_ModeInfoList == NULL) { - sdlflags &= ~SDL_FULLSCREEN; - m_ModeInfoList = SDL_ListModes(vidInfo->vfmt, sdlflags); // try without fullscreen. - if (m_ModeInfoList == NULL) { - sdlflags = 0; - m_ModeInfoList = SDL_ListModes(vidInfo->vfmt, sdlflags); // give me ANYTHING. - if (m_ModeInfoList == NULL) { - fprintf(stderr, "SDL: SDL_ListModes() failed.\n"); - return -3; - } // if - } // if - } // if - - if (m_ModeInfoList == (SDL_Rect **)-1) // anything is fine. - { - mprintf(0, "Windowed surface is probably going to be used."); - m_NumVideoModes = 0; - } // if - else { - mprintf(0, "-------------------------\n"); - mprintf(0, "Supported Mode Lines:\n"); - for (int i = 0; m_ModeInfoList[i] != NULL; i++) { - //,m_ModeInfoList[i]->hdisplay,m_ModeInfoList[i]->vdisplay); - mprintf(0, " Mode %d: %dX%d\n", i, m_ModeInfoList[i]->w, m_ModeInfoList[i]->h); - m_NumVideoModes++; - } // for - mprintf(0, "-------------------------\n"); - } // else -#endif - - return true; -} - -bool CLnxVideoModes::SwitchResolution(int width, int height) { - /* - if(!m_Inited) - return false; - - int i; - for(i=0;ihdisplay==width && m_ModeInfoList[i]->vdisplay==height) - { - // found a matching resolution, try to change to it - if(SwitchToMode(m_ModeInfoList[i])) - { - fprintf(stdout,"Mode switch to %dX%d OK!\n",width,height); - m_VideoResolutionChanged = (i==0)?false:true; - return true; - } - } - } - - return false; - */ - return (true); -} - -void CLnxVideoModes::RestoreVideoMode(void) { - /* - if(!m_Inited) - return; - - if(!m_VideoResolutionChanged) - return; - - // index 0 is the original mode - if(m_NumVideoModes<=1) - return; - - m_VideoResolutionChanged = false; - - VidModeSwitchToMode(m_Display,m_Screen,m_ModeInfoList[0]); - */ - return; -} - -/* -bool CLnxVideoModes::SwitchToMode(XF86VidModeModeInfo *mode) -{ - if(!m_Inited) - return false; - - if(!VidModeSwitchToMode(m_Display,m_Screen,mode)) - { - fprintf(stdout,"Video: Unable to switch mode to %dX%d\n",mode->hdisplay,mode->vdisplay); - return false; - } - - VidModeSetViewPort(m_Display,m_Screen,0,0); - return true; -} - -bool CLnxVideoModes::QueryExtension(Display *dpy) -{ - if(!m_Inited) - return false; - - int dummy; - if(!VidModeQueryExtension(dpy,&dummy,&dummy)) - return false; - return true; -} - -void CLnxVideoModes::GetModeLine(Display *dpy,int screen,int *dotclock,XF86VidModeModeLine *modeline) -{ - if(!m_Inited) - return; - - VidModeGetModeLine(dpy,screen,dotclock,modeline); -} -*/ - -void CLnxVideoModes::Lock(bool lock) { - /* - if(!m_Inited) - return; - - VidModeLockModeSwitch(m_Display,m_Screen,(lock)?1:0); - */ -} - -bool CLnxVideoModes::LoadLibraries(void) { - /* - void *handle; - char *libname = "OutrageDynXLib.so"; - handle = dlopen(libname,RTLD_NOW|RTLD_GLOBAL); - if(!handle) - { - fprintf(stderr,"Library Load Failed: %s (%s)\n",libname,dlerror()); - return false; - } - - VidModeQueryExtension = (VidModeQueryExtension_fp)dlsym(handle,"VidModeQueryExtension"); - VidModeGetAllModeLines = (VidModeGetAllModeLines_fp)dlsym(handle,"VidModeGetAllModeLines"); - VidModeSwitchToMode = (VidModeSwitchToMode_fp)dlsym(handle,"VidModeSwitchToMode"); - VidModeSetViewPort = (VidModeSetViewPort_fp)dlsym(handle,"VidModeSetViewPort"); - VidModeFreeData = (VidModeFreeData_fp)dlsym(handle,"VidModeFreeData"); - VidModeGetModeLine = (VidModeGetModeLine_fp)dlsym(handle,"VidModeGetModeLine"); - VidModeLockModeSwitch = (VidModeLockModeSwitch_fp)dlsym(handle,"VidModeLockModeSwitch"); - - if( !VidModeQueryExtension || - !VidModeGetAllModeLines || - !VidModeSwitchToMode || - !VidModeSetViewPort || - !VidModeFreeData || - !VidModeGetModeLine || - !VidModeLockModeSwitch) - { - fprintf(stderr,"Symbol Resolve Error: %s\n",libname); - return false; - } - */ - return true; -} diff --git a/renderer/points.cpp b/renderer/points.cpp new file mode 100644 index 000000000..157455607 --- /dev/null +++ b/renderer/points.cpp @@ -0,0 +1,161 @@ +/* +* Descent 3 +* Copyright (C) 2024 Parallax Software +* +* This program is free software: you can redistribute it and/or modify +* it under the terms of the GNU General Public License as published by +* the Free Software Foundation, either version 3 of the License, or +* (at your option) any later version. +* +* This program is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +* GNU General Public License for more details. +* +* You should have received a copy of the GNU General Public License +* along with this program. If not, see . +*/ +#include "3d.h" +#include "HardwareInternal.h" +#include + +extern vector Clip_plane_point; +//code a point. fills in the p3_codes field of the point, and returns the codes +uint8_t g3_CodePoint(g3Point *p) +{ + uint8_t cc=0; + + if (p->p3_x > p->p3_z) + cc |= CC_OFF_RIGHT; + + if (p->p3_y > p->p3_z) + cc |= CC_OFF_TOP; + + if (p->p3_x < -p->p3_z) + cc |= CC_OFF_LEFT; + + if (p->p3_y < -p->p3_z) + cc |= CC_OFF_BOT; + + if (p->p3_z < 0) + cc |= CC_BEHIND; + + if (p->p3_z > Far_clip_z) + cc |=CC_OFF_FAR; + + // Check to see if we should be clipped to the custom plane + if (Clip_custom) + { + vector vec=p->p3_vec-Clip_plane_point; + vec.x/=Matrix_scale.x; + vec.y/=Matrix_scale.y; + vec.z/=Matrix_scale.z; + + float dp=vec*Clip_plane; + if( dp < -0.005f ) + { + cc |= CC_OFF_CUSTOM; + } + } + + return p->p3_codes = cc; + +} + +//rotates a point. returns codes. does not check if already rotated +uint8_t g3_RotatePoint(g3Point *dest,vector *src) +{ + // store the pre-rotated point + dest->p3_vecPreRot = *src; + + // find the point offset from the view/camera position + vector tempv = *src - View_position; + + // rotate the point by the view/camera's orientation + dest->p3_vec = tempv * View_matrix; + + // determine the flags for the point + dest->p3_flags = PF_ORIGPOINT; + return g3_CodePoint( dest ); +} + +//projects a point +void g3_ProjectPoint(g3Point *p) +{ + if (p->p3_flags & PF_PROJECTED || p->p3_codes & CC_BEHIND) + return; + + float one_over_z=1.0/p->p3_z; + p->p3_sx = Window_w2 + (p->p3_x * (Window_w2 * one_over_z)); + p->p3_sy = Window_h2 - (p->p3_y * (Window_h2 * one_over_z)); + p->p3_flags |= PF_PROJECTED; +} + +//from a 2d point, compute the vector through that point +void g3_Point2Vec(vector *v,short sx,short sy) +{ + vector tempv; + matrix tempm; + + tempv.x = (((sx - Window_w2) / Window_w2) * Matrix_scale.z / Matrix_scale.x); + tempv.y = -(((sy - Window_h2) / Window_h2) * Matrix_scale.z / Matrix_scale.y); + tempv.z = 1.0f; + + vm_NormalizeVector(&tempv); + + tempm = ~Unscaled_matrix; + + *v = tempv * tempm; +} + +//delta rotation functions +vector *g3_RotateDeltaX(vector *dest,float dx) +{ + dest->x = View_matrix.rvec.x * dx; + dest->y = View_matrix.uvec.x * dx; + dest->z = View_matrix.fvec.x * dx; + + return dest; +} + +vector *g3_RotateDeltaY(vector *dest,float dy) +{ + dest->x = View_matrix.rvec.y * dy; + dest->y = View_matrix.uvec.y * dy; + dest->z = View_matrix.fvec.y * dy; + + return dest; +} + +vector *g3_RotateDeltaZ(vector *dest,float dz) +{ + dest->x = View_matrix.rvec.z * dz; + dest->y = View_matrix.uvec.z * dz; + dest->z = View_matrix.fvec.z * dz; + + return dest; +} + +vector *g3_RotateDeltaVec(vector *dest,vector *src) +{ + *dest = *src * View_matrix; + + return dest; +} + +uint8_t g3_AddDeltaVec(g3Point *dest,g3Point *src,vector *deltav) +{ + dest->p3_vec = src->p3_vec + *deltav; + + dest->p3_flags = 0; //not projected + + return g3_CodePoint(dest); +} + +//calculate the depth of a point - returns the z coord of the rotated point +float g3_CalcPointDepth(vector *pnt) +{ + return ((pnt->x - View_position.x) * View_matrix.fvec.x) + + ((pnt->y - View_position.y) * View_matrix.fvec.y) + + ((pnt->z - View_position.z) * View_matrix.fvec.z); +} diff --git a/renderer/setup.cpp b/renderer/setup.cpp new file mode 100644 index 000000000..5ee4fe8e5 --- /dev/null +++ b/renderer/setup.cpp @@ -0,0 +1,200 @@ +/* +* Descent 3 +* Copyright (C) 2024 Parallax Software +* +* This program is free software: you can redistribute it and/or modify +* it under the terms of the GNU General Public License as published by +* the Free Software Foundation, either version 3 of the License, or +* (at your option) any later version. +* +* This program is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +* GNU General Public License for more details. +* +* You should have received a copy of the GNU General Public License +* along with this program. If not, see . +*/ +#include +#include +#include "3d.h" +#include "pserror.h" +#include "HardwareInternal.h" +#include "renderer.h" + +//User-specified aspect ratio, stored as w/h +static float sAspect = 0.0f; + +//initialize the 3d system +void g3_Init(void) +{ + atexit(g3_Close); +} + +//close down the 3d system +void g3_Close(void) +{ +} + +//allows the program to specify an aspect ratio that overrides the renderer's +//The parameter is the w/h of the screen pixels +void g3_SetAspectRatio(float aspect) +{ + sAspect = aspect; +} + +// returns the user-specified aspect ratio used to override the renderer's +float g3_GetAspectRatio() { return sAspect; } + +void g3_GetViewPortMatrix( float *viewMat ) +{ + // extract the viewport data from the renderer + int viewportWidth, viewportHeight; + int viewportX, viewportY; + rend_GetProjectionScreenParameters( viewportX, viewportY, viewportWidth, viewportHeight ); + + float viewportWidthOverTwo = ((float)viewportWidth) * 0.5f; + float viewportHeightOverTwo = ((float)viewportHeight) * 0.5f; + + // setup the matrix + memset( viewMat, 0, sizeof(float) * 16 ); + viewMat[0] = viewportWidthOverTwo; + viewMat[5] = -viewportHeightOverTwo; + viewMat[12] = viewportWidthOverTwo + (float)viewportX; + viewMat[13] = viewportHeightOverTwo + (float)viewportY; + viewMat[10] = viewMat[15] = 1.0f; +} + +void g3_GetProjectionMatrix( float zoom, float *projMat ) +{ + // get window size + int viewportWidth, viewportHeight; + rend_GetProjectionParameters( &viewportWidth, &viewportHeight ); + + float s = ((float)Window_width / Window_height); + + // setup the matrix + memset( projMat, 0, sizeof(float) * 16 ); + + // calculate 1/tan(fov) + //Convert zoom into vertical FOV for my convenience, since I'm locking the Y FOV when the screen gets wider. + zoom *= 3.f / 4.f; + + float oOT = 1.0f / zoom; + + float znear = 1.0f; + float zfar = 10000.f; //debug + + float C = -((zfar + znear) / (zfar - znear)); + float D = -((2 * zfar * znear) / (zfar - znear)); + + // fill in the matrix + if (s <= 1.0f) + { + projMat[0] = oOT; + projMat[5] = oOT * s; + } + else + { + projMat[0] = oOT / s; + projMat[5] = oOT; + } + projMat[10] = C; + projMat[11] = -1; + projMat[14] = D; + /*projMat[10] = 1.0f; + projMat[11] = 1.0f; + projMat[14] = -1.0f;*/ +} + +//start the frame +void g3_StartFrame(vector *view_pos,matrix *view_matrix,float zoom) +{ + // initialize the viewport transform + g3_GetViewPortMatrix( (float*)gTransformViewPort ); + g3_GetProjectionMatrix( zoom, (float*)gTransformProjection ); + g3_GetModelViewMatrix( view_pos, view_matrix, (float*)gTransformModelView ); + g3_UpdateFullTransform(); + + //[ISB] Update the common uniform block for all 3D shaders. + rend_UpdateCommon((float*)gTransformProjection, (float*)gTransformModelView); + + // get window size + rend_GetProjectionParameters( &Window_width, &Window_height ); + + //Set vars for projection + Window_w2 = ((float)Window_width) * 0.5f; + Window_h2 = ((float)Window_height) * 0.5f; + + //float s = screen_aspect * (float) Window_height / (float) Window_width; + //[ISB] Just use the aspect of the window, the screen aspect is not important since pixels are all square + float s = ((float)Window_width / Window_height);// / (4.f / 3.f); + + if( s <= 1.0f ) + { + //scale x + Matrix_scale.x = 1.0f; + Matrix_scale.y = s; + } + else + { + Matrix_scale.y = 1.0f; + Matrix_scale.x = 1.0f / s; + } + + //Convert zoom into vertical FOV for my convenience, since I'm locking the Y FOV when the screen gets wider. + zoom *= 3.f / 4.f; + + Matrix_scale.z = 1.0f; + + //Set the view variables + View_position = *view_pos; + View_zoom = zoom; + Unscaled_matrix = *view_matrix; + + //zoom by scaling x and y + //[ISB] This no longer will scale Z to apply FOV, since it causes problems with the depth ranges. + float oOZ = 1.0f / View_zoom; + Matrix_scale.x = Matrix_scale.x * oOZ; + Matrix_scale.y = Matrix_scale.y * oOZ; + + //Scale the matrix elements + View_matrix.rvec = Unscaled_matrix.rvec * Matrix_scale.x; + View_matrix.uvec = Unscaled_matrix.uvec * Matrix_scale.y; + View_matrix.fvec = Unscaled_matrix.fvec * Matrix_scale.z; + + //Reset the list of free points + InitFreePoints(); + + //Reset the far clip plane + g3_ResetFarClipZ(); +} + +//this doesn't do anything, but is here for completeness +void g3_EndFrame(void) +{ + //make sure temp points are free + CheckTempPoints(); +} + +//get the current view position +void g3_GetViewPosition(vector *vp) +{ + *vp = View_position; +} + +void g3_GetViewMatrix(matrix *mat) +{ + *mat = View_matrix; +} + +void g3_GetUnscaledMatrix(matrix *mat) +{ + *mat = Unscaled_matrix; +} + +// Gets the matrix scale vector +void g3_GetMatrixScale(vector *matrix_scale) +{ + *matrix_scale=Matrix_scale; +} diff --git a/renderer/transforms.cpp b/renderer/transforms.cpp new file mode 100644 index 000000000..97067d27e --- /dev/null +++ b/renderer/transforms.cpp @@ -0,0 +1,171 @@ +/* +* Descent 3 +* Copyright (C) 2024 Parallax Software +* +* This program is free software: you can redistribute it and/or modify +* it under the terms of the GNU General Public License as published by +* the Free Software Foundation, either version 3 of the License, or +* (at your option) any later version. +* +* This program is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +* GNU General Public License for more details. +* +* You should have received a copy of the GNU General Public License +* along with this program. If not, see . +*/ +#include "3d.h" +#include "pserror.h" +#include "HardwareInternal.h" +#include "renderer.h" +#include + +// Whether or not to use T&L transforms or the pass-thru ones +static int sUseTransformPassthru = -1; + +void Mat4Multiply(float* res, float* right) +{ + float left[16]; + memcpy(left, res, sizeof(left)); + + res[0] = left[0] * right[0] + left[4] * right[1] + left[8] * right[2] + left[12] * right[3]; //i1 j1 + res[1] = left[1] * right[0] + left[5] * right[1] + left[9] * right[2] + left[13] * right[3]; //i2 j1 + res[2] = left[2] * right[0] + left[6] * right[1] + left[10] * right[2] + left[14] * right[3]; //i3 j1 + res[3] = left[3] * right[0] + left[7] * right[1] + left[11] * right[2] + left[15] * right[3]; //14 j1 + + res[4] = left[0] * right[4] + left[4] * right[5] + left[8] * right[6] + left[12] * right[7]; //i1 j2 + res[5] = left[1] * right[4] + left[5] * right[5] + left[9] * right[6] + left[13] * right[7]; //i2 j2 + res[6] = left[2] * right[4] + left[6] * right[5] + left[10] * right[6] + left[14] * right[7]; //i3 j2 + res[7] = left[3] * right[4] + left[7] * right[5] + left[11] * right[6] + left[15] * right[7]; //i4 j2 + + res[8] = left[0] * right[8] + left[4] * right[9] + left[8] * right[10] + left[12] * right[11]; //i1 j3 + res[9] = left[1] * right[8] + left[5] * right[9] + left[9] * right[10] + left[13] * right[11]; //i2 j3 + res[10] = left[2] * right[8] + left[6] * right[9] + left[10] * right[10] + left[14] * right[11]; //i3 j3 + res[11] = left[3] * right[8] + left[7] * right[9] + left[11] * right[10] + left[15] * right[11]; //i4 j3 + + res[12] = left[0] * right[12] + left[4] * right[13] + left[8] * right[14] + left[12] * right[15]; //i1 j4 + res[13] = left[1] * right[12] + left[5] * right[13] + left[9] * right[14] + left[13] * right[15]; //i2 j4 + res[14] = left[2] * right[12] + left[6] * right[13] + left[10] * right[14] + left[14] * right[15]; //i3 j4 + res[15] = left[3] * right[12] + left[7] * right[13] + left[11] * right[14] + left[15] * right[15]; //i4 j4 +} + +extern float Z_bias; +void g3_GetModelViewMatrix( const vector *viewPos, const matrix *viewMatrix, float *mvMat ) +{ + matrix localOrient = (*viewMatrix); + vector localPos = -(*viewPos); + /*mvMat[0] = localOrient.rvec.x; + mvMat[4] = localOrient.uvec.x; + mvMat[8] = localOrient.fvec.x; + mvMat[3] = 0.0f; + mvMat[1] = localOrient.rvec.y; + mvMat[5] = localOrient.uvec.y; + mvMat[9] = localOrient.fvec.y; + mvMat[7] = 0.0f; + mvMat[2] = localOrient.rvec.z; + mvMat[6] = localOrient.uvec.z; + mvMat[10] = localOrient.fvec.z;*/ + mvMat[0] = localOrient.rvec.x; + mvMat[1] = localOrient.uvec.x; + mvMat[2] = localOrient.fvec.x; + mvMat[3] = 0.0f; + mvMat[4] = localOrient.rvec.y; + mvMat[5] = localOrient.uvec.y; + mvMat[6] = localOrient.fvec.y; + mvMat[7] = 0.0f; + mvMat[8] = localOrient.rvec.z; + mvMat[9] = localOrient.uvec.z; + mvMat[10] = localOrient.fvec.z; + mvMat[11] = 0.0f; + mvMat[12] = localPos * localOrient.rvec; + mvMat[13] = localPos * localOrient.uvec; + mvMat[14] = localPos * localOrient.fvec + Z_bias; + mvMat[15] = 1.0f; +} + +void g3_TransformVert( float res[4], float pt[4], float a[4][4] ) +{ + int y; + for( y = 0; y < 4; ++y ) + { + res[y] = (pt[0] * a[0][y]) + (pt[1] * a[1][y]) + (pt[2] * a[2][y]) + (pt[3] * a[3][y]); + } +} + +void g3_TransformMult( float res[4][4], float a[4][4], float b[4][4] ) +{ + float temp[4][4]; + + int x, y; + for( y = 0; y < 4; ++y ) + { + for( x = 0; x < 4; ++x ) + { + temp[y][x] = (a[y][0] * b[0][x]) + + (a[y][1] * b[1][x]) + + (a[y][2] * b[2][x]) + + (a[y][3] * b[3][x]); + } + } + memcpy( res, temp, 16 * sizeof(float) ); +} + +void g3_TransformTrans( float res[4][4], float t[4][4] ) +{ + float temp[4][4]; + int y; + for( y = 0; y < 4; ++y ) + { + int x; + for( x = 0; x < 4; ++x ) + { + temp[x][y] = t[y][x]; + } + } + memcpy( res, temp, 16 * sizeof(float) ); +} + +void g3_UpdateFullTransform() +{ + // ModelView -> projection + g3_TransformMult( gTransformFull, gTransformModelView, gTransformProjection ); + + // projection -> ViewPort + g3_TransformMult( gTransformFull, gTransformFull, gTransformViewPort ); +} + +void g3_ForceTransformRefresh(void) +{ + sUseTransformPassthru = -1; +} + +void g3_RefreshTransforms(bool usePassthru) +{ + /*if( sUseTransformPassthru == 1 && usePassthru ) + { + // we don't have to do anything because we are already setup for pass-thru + return; + } + + if( usePassthru ) + { + // setup OpenGL to use pass-thru + rend_TransformSetToPassthru(); + } + else + { + // extract the viewport data from the renderer + int viewportWidth, viewportHeight, viewportX, viewportY; + rend_GetProjectionScreenParameters( viewportX, viewportY, viewportWidth, viewportHeight ); + + // setup OpenGL to use full transform stack + // TODO: in the future we only need to set those that have changed + rend_TransformSetViewport( viewportX, viewportY, viewportWidth, viewportHeight ); + rend_TransformSetProjection( gTransformProjection ); + rend_TransformSetModelView( gTransformModelView ); + } + + // store the pass-thru + sUseTransformPassthru = (usePassthru) ? 1 : 0;*/ +} diff --git a/renderer/wgl.c b/renderer/wgl.c new file mode 100644 index 000000000..9fb9494e8 --- /dev/null +++ b/renderer/wgl.c @@ -0,0 +1,133 @@ +/** + * SPDX-License-Identifier: (WTFPL OR CC0-1.0) AND Apache-2.0 + */ +#include +#include +#include +#include + +#ifndef GLAD_IMPL_UTIL_C_ +#define GLAD_IMPL_UTIL_C_ + +#ifdef _MSC_VER +#define GLAD_IMPL_UTIL_SSCANF sscanf_s +#else +#define GLAD_IMPL_UTIL_SSCANF sscanf +#endif + +#endif /* GLAD_IMPL_UTIL_C_ */ + +#ifdef __cplusplus +extern "C" { +#endif + + + + int GLAD_WGL_VERSION_1_0 = 0; + int GLAD_WGL_ARB_extensions_string = 0; + int GLAD_WGL_EXT_extensions_string = 0; + + + + PFNWGLGETEXTENSIONSSTRINGARBPROC glad_wglGetExtensionsStringARB = NULL; + PFNWGLGETEXTENSIONSSTRINGEXTPROC glad_wglGetExtensionsStringEXT = NULL; + + + static void glad_wgl_load_WGL_ARB_extensions_string(GLADuserptrloadfunc load, void* userptr) { + if (!GLAD_WGL_ARB_extensions_string) return; + glad_wglGetExtensionsStringARB = (PFNWGLGETEXTENSIONSSTRINGARBPROC)load(userptr, "wglGetExtensionsStringARB"); + } + static void glad_wgl_load_WGL_EXT_extensions_string(GLADuserptrloadfunc load, void* userptr) { + if (!GLAD_WGL_EXT_extensions_string) return; + glad_wglGetExtensionsStringEXT = (PFNWGLGETEXTENSIONSSTRINGEXTPROC)load(userptr, "wglGetExtensionsStringEXT"); + } + + + + static int glad_wgl_has_extension(HDC hdc, const char* ext) { + const char* terminator; + const char* loc; + const char* extensions; + + if (wglGetExtensionsStringEXT == NULL && wglGetExtensionsStringARB == NULL) + return 0; + + if (wglGetExtensionsStringARB == NULL || hdc == INVALID_HANDLE_VALUE) + extensions = wglGetExtensionsStringEXT(); + else + extensions = wglGetExtensionsStringARB(hdc); + + if (extensions == NULL || ext == NULL) + return 0; + + while (1) { + loc = strstr(extensions, ext); + if (loc == NULL) + break; + + terminator = loc + strlen(ext); + if ((loc == extensions || *(loc - 1) == ' ') && + (*terminator == ' ' || *terminator == '\0')) + { + return 1; + } + extensions = terminator; + } + + return 0; + } + + static GLADapiproc glad_wgl_get_proc_from_userptr(void* userptr, const char* name) { + return (GLAD_GNUC_EXTENSION(GLADapiproc(*)(const char* name)) userptr)(name); + } + + static int glad_wgl_find_extensions_wgl(HDC hdc) { + GLAD_WGL_ARB_extensions_string = glad_wgl_has_extension(hdc, "WGL_ARB_extensions_string"); + GLAD_WGL_EXT_extensions_string = glad_wgl_has_extension(hdc, "WGL_EXT_extensions_string"); + return 1; + } + + static int glad_wgl_find_core_wgl(void) { + int major = 1, minor = 0; + GLAD_WGL_VERSION_1_0 = (major == 1 && minor >= 0) || major > 1; + return GLAD_MAKE_VERSION(major, minor); + } + + int gladLoadWGLUserPtr(HDC hdc, GLADuserptrloadfunc load, void* userptr) { + int version; + wglGetExtensionsStringARB = (PFNWGLGETEXTENSIONSSTRINGARBPROC)load(userptr, "wglGetExtensionsStringARB"); + wglGetExtensionsStringEXT = (PFNWGLGETEXTENSIONSSTRINGEXTPROC)load(userptr, "wglGetExtensionsStringEXT"); + if (wglGetExtensionsStringARB == NULL && wglGetExtensionsStringEXT == NULL) return 0; + version = glad_wgl_find_core_wgl(); + + + if (!glad_wgl_find_extensions_wgl(hdc)) return 0; + glad_wgl_load_WGL_ARB_extensions_string(load, userptr); + glad_wgl_load_WGL_EXT_extensions_string(load, userptr); + + + return version; + } + + int gladLoadWGL(HDC hdc, GLADloadfunc load) { + return gladLoadWGLUserPtr(hdc, glad_wgl_get_proc_from_userptr, GLAD_GNUC_EXTENSION(void*) load); + } + + +#ifdef GLAD_WGL + + static GLADapiproc glad_wgl_get_proc(void* vuserptr, const char* name) { + GLAD_UNUSED(vuserptr); + return GLAD_GNUC_EXTENSION(GLADapiproc) wglGetProcAddress(name); + } + + int gladLoaderLoadWGL(HDC hdc) { + return gladLoadWGLUserPtr(hdc, glad_wgl_get_proc, NULL); + } + + +#endif /* GLAD_WGL */ + +#ifdef __cplusplus +} +#endif diff --git a/win32/winapp.cpp b/win32/winapp.cpp index 60b17ea33..71b85f61f 100644 --- a/win32/winapp.cpp +++ b/win32/winapp.cpp @@ -374,6 +374,46 @@ void oeWin32Application::get_info(void *info) { appinfo->wnd_h = m_H; } +void oeWin32Application::change_window() +{ + if (m_Flags & OEAPP_FULLSCREEN) + { + SetWindowLongPtr((HWND)m_hWnd, GWL_STYLE, 0); + SetWindowLongPtr((HWND)m_hWnd, GWL_EXSTYLE, WS_EX_TOPMOST); + + RECT r{}; + GetWindowRect((HWND)m_hWnd, &r); + + m_X = r.left; + m_Y = r.top; + m_W = r.right - r.left; + m_H = r.bottom - r.top; + + int hehwidth = GetSystemMetrics(SM_CXSCREEN); + int hehheight = GetSystemMetrics(SM_CYSCREEN); + + SetWindowPos((HWND)m_hWnd, HWND_TOP, 0, 0, hehwidth, hehheight, SWP_NOZORDER | SWP_FRAMECHANGED); + ShowWindow((HWND)m_hWnd, SW_NORMAL); + } + else + { + SetWindowLongPtr((HWND)m_hWnd, GWL_STYLE, WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_BORDER | WS_MINIMIZEBOX); + SetWindowLongPtr((HWND)m_hWnd, GWL_EXSTYLE, 0); + + ShowWindow((HWND)m_hWnd, SW_NORMAL); + SetWindowPos((HWND)m_hWnd, HWND_TOP, m_X, m_Y, m_W, m_H, SWP_NOMOVE | SWP_NOZORDER | SWP_FRAMECHANGED); + } +} + +void oeWin32Application::set_flags(int newflags) +{ + int oldflags = m_Flags; + m_Flags = newflags; + + if (m_Flags != oldflags) + change_window(); +} + // Function to get the flags int oeWin32Application::flags(void) const { return m_Flags; }