├── .gitignore ├── Makefile ├── README.md ├── assets ├── .gitkeep ├── color.png ├── desert-color.png ├── desert-height.png ├── forest-watery-color.png ├── forest-watery-height.png ├── height.png ├── mountains-color.png ├── mountains-desert-color.png ├── mountains-desert-height.png ├── mountains-height.png ├── screenshot.png ├── shaders │ ├── default.fs │ └── default.vs ├── snow-watery-color.png └── snow-watery-height.png ├── libs ├── GLAD │ ├── include │ │ ├── KHR │ │ │ └── khrplatform.h │ │ ├── glad │ │ │ └── glad.h │ │ └── stb_image.h │ └── src │ │ └── glad.c └── include │ └── stb_image.h └── src ├── main.c └── program ├── camera ├── camera.c └── camera.h ├── core ├── array │ ├── array.h │ └── array_header.h ├── fonts │ └── fonts.c ├── graphics │ ├── graphics.c │ ├── graphics.h │ └── imageData │ │ ├── imageData.c │ │ └── imageData.h ├── input │ ├── input.h │ ├── keyboard.c │ ├── keyboard.h │ ├── mouse.c │ └── mouse.h ├── queue │ ├── queue.c │ └── queue.h ├── shader │ ├── shader.c │ └── shader.h └── sprite │ ├── sprite.c │ └── sprite.h ├── program.c ├── program.h ├── utils ├── utils.c └── utils.h └── vec3 ├── vec3.c └── vec3.h /.gitignore: -------------------------------------------------------------------------------- 1 | bin 2 | **/*.o 3 | **/*.kra 4 | -------------------------------------------------------------------------------- /Makefile: -------------------------------------------------------------------------------- 1 | SRC_F := $(shell find src -name *.c) $(shell find libs -name *.c) 2 | SRC_CPP := $(shell find libs/soloud/src -name *.cpp) 3 | OBJ_FOR_CLEAN_F := $(shell find ./src -name *.o) 4 | SRC_O := $(patsubst %.c,%.o,$(SRC_F)) 5 | SRC_CPP_O := $(patsubst %.cpp,%.o,$(SRC_CPP)) 6 | 7 | LIBS := -lpthread -lm -lglfw -lGL -lstdc++ -ldl -lasound 8 | 9 | FLAGS__DEBUG := -g3 -O0 10 | FLAGS_DEBUG := -O3 -fdata-sections -ffunction-sections 11 | FLAGS := -Wall -Wextra -Ilibs/include -Ilibs/soloud/include -Ilibs/GLAD/include 12 | 13 | TARGET := bin/main.bin 14 | .PONY: clean 15 | 16 | all: $(SRC_O) $(SRC_CPP_O) copy_assets 17 | clang $(FLAGS_DEBUG) $(FLAGS) $(SRC_O) $(SRC_CPP_O) -o $(TARGET) $(LIBS) 18 | 19 | run_main: clean all 20 | $(TARGET) 21 | 22 | %.o: %.c 23 | clang -c $(FLAGS_DEBUG) $(FLAGS) $^ -o $@ 24 | 25 | %.o: %.cpp 26 | gcc -c $(FLAGS_RELEASE) $(FLAGS) -lstdc++ -ldl -lasound -DWITH_ALSA=1 $^ -o $@ 27 | 28 | clean: 29 | rm -rf $(OBJ_FOR_CLEAN_F) 30 | rm -rf $(TARGET) 31 | rm -rf bin/assets 32 | 33 | deep_clean: clean 34 | rm -rf $(SRC_CPP_O) 35 | 36 | 37 | copy_assets: 38 | cp -r assets bin 39 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Old School Frame Buffer game engine 2 | Old school, MS-DOS golden era game engine where you create images by writing into a memory region, that is pushed to the video card. 3 | 4 | # Dependencies 5 | GLFW 6 | # Screenshots 7 | ![image](https://user-images.githubusercontent.com/808249/127040471-7ea12999-0d7c-4cec-a587-49ed1a26e8e5.png) 8 | 9 | 10 | # Usage 11 | Read the main.c, program.c (function mainLoop) and the graphics.h to get at basic understanding of how to use it(should be enough). 12 | -------------------------------------------------------------------------------- /assets/.gitkeep: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/WEREMSOFT/voxelspace-c99-opengl-linux/0235233ad8ad306af63fa1c5bdaa02c1f245a823/assets/.gitkeep -------------------------------------------------------------------------------- /assets/color.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/WEREMSOFT/voxelspace-c99-opengl-linux/0235233ad8ad306af63fa1c5bdaa02c1f245a823/assets/color.png -------------------------------------------------------------------------------- /assets/desert-color.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/WEREMSOFT/voxelspace-c99-opengl-linux/0235233ad8ad306af63fa1c5bdaa02c1f245a823/assets/desert-color.png -------------------------------------------------------------------------------- /assets/desert-height.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/WEREMSOFT/voxelspace-c99-opengl-linux/0235233ad8ad306af63fa1c5bdaa02c1f245a823/assets/desert-height.png -------------------------------------------------------------------------------- /assets/forest-watery-color.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/WEREMSOFT/voxelspace-c99-opengl-linux/0235233ad8ad306af63fa1c5bdaa02c1f245a823/assets/forest-watery-color.png -------------------------------------------------------------------------------- /assets/forest-watery-height.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/WEREMSOFT/voxelspace-c99-opengl-linux/0235233ad8ad306af63fa1c5bdaa02c1f245a823/assets/forest-watery-height.png -------------------------------------------------------------------------------- /assets/height.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/WEREMSOFT/voxelspace-c99-opengl-linux/0235233ad8ad306af63fa1c5bdaa02c1f245a823/assets/height.png -------------------------------------------------------------------------------- /assets/mountains-color.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/WEREMSOFT/voxelspace-c99-opengl-linux/0235233ad8ad306af63fa1c5bdaa02c1f245a823/assets/mountains-color.png -------------------------------------------------------------------------------- /assets/mountains-desert-color.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/WEREMSOFT/voxelspace-c99-opengl-linux/0235233ad8ad306af63fa1c5bdaa02c1f245a823/assets/mountains-desert-color.png -------------------------------------------------------------------------------- /assets/mountains-desert-height.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/WEREMSOFT/voxelspace-c99-opengl-linux/0235233ad8ad306af63fa1c5bdaa02c1f245a823/assets/mountains-desert-height.png -------------------------------------------------------------------------------- /assets/mountains-height.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/WEREMSOFT/voxelspace-c99-opengl-linux/0235233ad8ad306af63fa1c5bdaa02c1f245a823/assets/mountains-height.png -------------------------------------------------------------------------------- /assets/screenshot.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/WEREMSOFT/voxelspace-c99-opengl-linux/0235233ad8ad306af63fa1c5bdaa02c1f245a823/assets/screenshot.png -------------------------------------------------------------------------------- /assets/shaders/default.fs: -------------------------------------------------------------------------------- 1 | #version 330 core 2 | out vec4 FragColor; 3 | 4 | in vec2 textCoord; 5 | 6 | // texture sampler 7 | uniform sampler2D texture1; 8 | 9 | void main() 10 | { 11 | FragColor = texture(texture1, textCoord); 12 | } -------------------------------------------------------------------------------- /assets/shaders/default.vs: -------------------------------------------------------------------------------- 1 | #version 330 core 2 | 3 | layout (location = 0) in vec3 aPos; 4 | layout (location = 1) in vec2 aTextCoord; 5 | 6 | 7 | out vec2 textCoord; 8 | 9 | void main() 10 | { 11 | gl_Position = vec4(aPos, 1.0); 12 | textCoord = vec2(aTextCoord.x, aTextCoord.y); 13 | } -------------------------------------------------------------------------------- /assets/snow-watery-color.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/WEREMSOFT/voxelspace-c99-opengl-linux/0235233ad8ad306af63fa1c5bdaa02c1f245a823/assets/snow-watery-color.png -------------------------------------------------------------------------------- /assets/snow-watery-height.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/WEREMSOFT/voxelspace-c99-opengl-linux/0235233ad8ad306af63fa1c5bdaa02c1f245a823/assets/snow-watery-height.png -------------------------------------------------------------------------------- /libs/GLAD/include/KHR/khrplatform.h: -------------------------------------------------------------------------------- 1 | #ifndef __khrplatform_h_ 2 | #define __khrplatform_h_ 3 | 4 | /* 5 | ** Copyright (c) 2008-2018 The Khronos Group Inc. 6 | ** 7 | ** Permission is hereby granted, free of charge, to any person obtaining a 8 | ** copy of this software and/or associated documentation files (the 9 | ** "Materials"), to deal in the Materials without restriction, including 10 | ** without limitation the rights to use, copy, modify, merge, publish, 11 | ** distribute, sublicense, and/or sell copies of the Materials, and to 12 | ** permit persons to whom the Materials are furnished to do so, subject to 13 | ** the following conditions: 14 | ** 15 | ** The above copyright notice and this permission notice shall be included 16 | ** in all copies or substantial portions of the Materials. 17 | ** 18 | ** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 19 | ** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 20 | ** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 21 | ** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY 22 | ** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, 23 | ** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE 24 | ** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS. 25 | */ 26 | 27 | /* Khronos platform-specific types and definitions. 28 | * 29 | * The master copy of khrplatform.h is maintained in the Khronos EGL 30 | * Registry repository at https://github.com/KhronosGroup/EGL-Registry 31 | * The last semantic modification to khrplatform.h was at commit ID: 32 | * 67a3e0864c2d75ea5287b9f3d2eb74a745936692 33 | * 34 | * Adopters may modify this file to suit their platform. Adopters are 35 | * encouraged to submit platform specific modifications to the Khronos 36 | * group so that they can be included in future versions of this file. 37 | * Please submit changes by filing pull requests or issues on 38 | * the EGL Registry repository linked above. 39 | * 40 | * 41 | * See the Implementer's Guidelines for information about where this file 42 | * should be located on your system and for more details of its use: 43 | * http://www.khronos.org/registry/implementers_guide.pdf 44 | * 45 | * This file should be included as 46 | * #include 47 | * by Khronos client API header files that use its types and defines. 48 | * 49 | * The types in khrplatform.h should only be used to define API-specific types. 50 | * 51 | * Types defined in khrplatform.h: 52 | * khronos_int8_t signed 8 bit 53 | * khronos_uint8_t unsigned 8 bit 54 | * khronos_int16_t signed 16 bit 55 | * khronos_uint16_t unsigned 16 bit 56 | * khronos_int32_t signed 32 bit 57 | * khronos_uint32_t unsigned 32 bit 58 | * khronos_int64_t signed 64 bit 59 | * khronos_uint64_t unsigned 64 bit 60 | * khronos_intptr_t signed same number of bits as a pointer 61 | * khronos_uintptr_t unsigned same number of bits as a pointer 62 | * khronos_ssize_t signed size 63 | * khronos_usize_t unsigned size 64 | * khronos_float_t signed 32 bit floating point 65 | * khronos_time_ns_t unsigned 64 bit time in nanoseconds 66 | * khronos_utime_nanoseconds_t unsigned time interval or absolute time in 67 | * nanoseconds 68 | * khronos_stime_nanoseconds_t signed time interval in nanoseconds 69 | * khronos_boolean_enum_t enumerated boolean type. This should 70 | * only be used as a base type when a client API's boolean type is 71 | * an enum. Client APIs which use an integer or other type for 72 | * booleans cannot use this as the base type for their boolean. 73 | * 74 | * Tokens defined in khrplatform.h: 75 | * 76 | * KHRONOS_FALSE, KHRONOS_TRUE Enumerated boolean false/true values. 77 | * 78 | * KHRONOS_SUPPORT_INT64 is 1 if 64 bit integers are supported; otherwise 0. 79 | * KHRONOS_SUPPORT_FLOAT is 1 if floats are supported; otherwise 0. 80 | * 81 | * Calling convention macros defined in this file: 82 | * KHRONOS_APICALL 83 | * KHRONOS_APIENTRY 84 | * KHRONOS_APIATTRIBUTES 85 | * 86 | * These may be used in function prototypes as: 87 | * 88 | * KHRONOS_APICALL void KHRONOS_APIENTRY funcname( 89 | * int arg1, 90 | * int arg2) KHRONOS_APIATTRIBUTES; 91 | */ 92 | 93 | #if defined(__SCITECH_SNAP__) && !defined(KHRONOS_STATIC) 94 | # define KHRONOS_STATIC 1 95 | #endif 96 | 97 | /*------------------------------------------------------------------------- 98 | * Definition of KHRONOS_APICALL 99 | *------------------------------------------------------------------------- 100 | * This precedes the return type of the function in the function prototype. 101 | */ 102 | #if defined(KHRONOS_STATIC) 103 | /* If the preprocessor constant KHRONOS_STATIC is defined, make the 104 | * header compatible with static linking. */ 105 | # define KHRONOS_APICALL 106 | #elif defined(_WIN32) 107 | # define KHRONOS_APICALL __declspec(dllimport) 108 | #elif defined (__SYMBIAN32__) 109 | # define KHRONOS_APICALL IMPORT_C 110 | #elif defined(__ANDROID__) 111 | # define KHRONOS_APICALL __attribute__((visibility("default"))) 112 | #else 113 | # define KHRONOS_APICALL 114 | #endif 115 | 116 | /*------------------------------------------------------------------------- 117 | * Definition of KHRONOS_APIENTRY 118 | *------------------------------------------------------------------------- 119 | * This follows the return type of the function and precedes the function 120 | * name in the function prototype. 121 | */ 122 | #if defined(_WIN32) && !defined(_WIN32_WCE) && !defined(__SCITECH_SNAP__) 123 | /* Win32 but not WinCE */ 124 | # define KHRONOS_APIENTRY __stdcall 125 | #else 126 | # define KHRONOS_APIENTRY 127 | #endif 128 | 129 | /*------------------------------------------------------------------------- 130 | * Definition of KHRONOS_APIATTRIBUTES 131 | *------------------------------------------------------------------------- 132 | * This follows the closing parenthesis of the function prototype arguments. 133 | */ 134 | #if defined (__ARMCC_2__) 135 | #define KHRONOS_APIATTRIBUTES __softfp 136 | #else 137 | #define KHRONOS_APIATTRIBUTES 138 | #endif 139 | 140 | /*------------------------------------------------------------------------- 141 | * basic type definitions 142 | *-----------------------------------------------------------------------*/ 143 | #if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) || defined(__GNUC__) || defined(__SCO__) || defined(__USLC__) 144 | 145 | 146 | /* 147 | * Using 148 | */ 149 | #include 150 | typedef int32_t khronos_int32_t; 151 | typedef uint32_t khronos_uint32_t; 152 | typedef int64_t khronos_int64_t; 153 | typedef uint64_t khronos_uint64_t; 154 | #define KHRONOS_SUPPORT_INT64 1 155 | #define KHRONOS_SUPPORT_FLOAT 1 156 | 157 | #elif defined(__VMS ) || defined(__sgi) 158 | 159 | /* 160 | * Using 161 | */ 162 | #include 163 | typedef int32_t khronos_int32_t; 164 | typedef uint32_t khronos_uint32_t; 165 | typedef int64_t khronos_int64_t; 166 | typedef uint64_t khronos_uint64_t; 167 | #define KHRONOS_SUPPORT_INT64 1 168 | #define KHRONOS_SUPPORT_FLOAT 1 169 | 170 | #elif defined(_WIN32) && !defined(__SCITECH_SNAP__) 171 | 172 | /* 173 | * Win32 174 | */ 175 | typedef __int32 khronos_int32_t; 176 | typedef unsigned __int32 khronos_uint32_t; 177 | typedef __int64 khronos_int64_t; 178 | typedef unsigned __int64 khronos_uint64_t; 179 | #define KHRONOS_SUPPORT_INT64 1 180 | #define KHRONOS_SUPPORT_FLOAT 1 181 | 182 | #elif defined(__sun__) || defined(__digital__) 183 | 184 | /* 185 | * Sun or Digital 186 | */ 187 | typedef int khronos_int32_t; 188 | typedef unsigned int khronos_uint32_t; 189 | #if defined(__arch64__) || defined(_LP64) 190 | typedef long int khronos_int64_t; 191 | typedef unsigned long int khronos_uint64_t; 192 | #else 193 | typedef long long int khronos_int64_t; 194 | typedef unsigned long long int khronos_uint64_t; 195 | #endif /* __arch64__ */ 196 | #define KHRONOS_SUPPORT_INT64 1 197 | #define KHRONOS_SUPPORT_FLOAT 1 198 | 199 | #elif 0 200 | 201 | /* 202 | * Hypothetical platform with no float or int64 support 203 | */ 204 | typedef int khronos_int32_t; 205 | typedef unsigned int khronos_uint32_t; 206 | #define KHRONOS_SUPPORT_INT64 0 207 | #define KHRONOS_SUPPORT_FLOAT 0 208 | 209 | #else 210 | 211 | /* 212 | * Generic fallback 213 | */ 214 | #include 215 | typedef int32_t khronos_int32_t; 216 | typedef uint32_t khronos_uint32_t; 217 | typedef int64_t khronos_int64_t; 218 | typedef uint64_t khronos_uint64_t; 219 | #define KHRONOS_SUPPORT_INT64 1 220 | #define KHRONOS_SUPPORT_FLOAT 1 221 | 222 | #endif 223 | 224 | 225 | /* 226 | * Types that are (so far) the same on all platforms 227 | */ 228 | typedef signed char khronos_int8_t; 229 | typedef unsigned char khronos_uint8_t; 230 | typedef signed short int khronos_int16_t; 231 | typedef unsigned short int khronos_uint16_t; 232 | 233 | /* 234 | * Types that differ between LLP64 and LP64 architectures - in LLP64, 235 | * pointers are 64 bits, but 'long' is still 32 bits. Win64 appears 236 | * to be the only LLP64 architecture in current use. 237 | */ 238 | #ifdef _WIN64 239 | typedef signed long long int khronos_intptr_t; 240 | typedef unsigned long long int khronos_uintptr_t; 241 | typedef signed long long int khronos_ssize_t; 242 | typedef unsigned long long int khronos_usize_t; 243 | #else 244 | typedef signed long int khronos_intptr_t; 245 | typedef unsigned long int khronos_uintptr_t; 246 | typedef signed long int khronos_ssize_t; 247 | typedef unsigned long int khronos_usize_t; 248 | #endif 249 | 250 | #if KHRONOS_SUPPORT_FLOAT 251 | /* 252 | * Float type 253 | */ 254 | typedef float khronos_float_t; 255 | #endif 256 | 257 | #if KHRONOS_SUPPORT_INT64 258 | /* Time types 259 | * 260 | * These types can be used to represent a time interval in nanoseconds or 261 | * an absolute Unadjusted System Time. Unadjusted System Time is the number 262 | * of nanoseconds since some arbitrary system event (e.g. since the last 263 | * time the system booted). The Unadjusted System Time is an unsigned 264 | * 64 bit value that wraps back to 0 every 584 years. Time intervals 265 | * may be either signed or unsigned. 266 | */ 267 | typedef khronos_uint64_t khronos_utime_nanoseconds_t; 268 | typedef khronos_int64_t khronos_stime_nanoseconds_t; 269 | #endif 270 | 271 | /* 272 | * Dummy value used to pad enum types to 32 bits. 273 | */ 274 | #ifndef KHRONOS_MAX_ENUM 275 | #define KHRONOS_MAX_ENUM 0x7FFFFFFF 276 | #endif 277 | 278 | /* 279 | * Enumerated boolean type 280 | * 281 | * Values other than zero should be considered to be true. Therefore 282 | * comparisons should not be made against KHRONOS_TRUE. 283 | */ 284 | typedef enum { 285 | KHRONOS_FALSE = 0, 286 | KHRONOS_TRUE = 1, 287 | KHRONOS_BOOLEAN_ENUM_FORCE_SIZE = KHRONOS_MAX_ENUM 288 | } khronos_boolean_enum_t; 289 | 290 | #endif /* __khrplatform_h_ */ 291 | -------------------------------------------------------------------------------- /libs/GLAD/src/glad.c: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | OpenGL loader generated by glad 0.1.34 on Sat Jul 17 20:49:20 2021. 4 | 5 | Language/Generator: C/C++ 6 | Specification: gl 7 | APIs: gl=3.3 8 | Profile: compatibility 9 | Extensions: 10 | 11 | Loader: True 12 | Local files: False 13 | Omit khrplatform: False 14 | Reproducible: False 15 | 16 | Commandline: 17 | --profile="compatibility" --api="gl=3.3" --generator="c" --spec="gl" --extensions="" 18 | Online: 19 | https://glad.dav1d.de/#profile=compatibility&language=c&specification=gl&loader=on&api=gl%3D3.3 20 | */ 21 | 22 | #include 23 | #include 24 | #include 25 | #include 26 | 27 | static void* get_proc(const char *namez); 28 | 29 | #if defined(_WIN32) || defined(__CYGWIN__) 30 | #ifndef _WINDOWS_ 31 | #undef APIENTRY 32 | #endif 33 | #include 34 | static HMODULE libGL; 35 | 36 | typedef void* (APIENTRYP PFNWGLGETPROCADDRESSPROC_PRIVATE)(const char*); 37 | static PFNWGLGETPROCADDRESSPROC_PRIVATE gladGetProcAddressPtr; 38 | 39 | #ifdef _MSC_VER 40 | #ifdef __has_include 41 | #if __has_include() 42 | #define HAVE_WINAPIFAMILY 1 43 | #endif 44 | #elif _MSC_VER >= 1700 && !_USING_V110_SDK71_ 45 | #define HAVE_WINAPIFAMILY 1 46 | #endif 47 | #endif 48 | 49 | #ifdef HAVE_WINAPIFAMILY 50 | #include 51 | #if !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) && WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) 52 | #define IS_UWP 1 53 | #endif 54 | #endif 55 | 56 | static 57 | int open_gl(void) { 58 | #ifndef IS_UWP 59 | libGL = LoadLibraryW(L"opengl32.dll"); 60 | if(libGL != NULL) { 61 | void (* tmp)(void); 62 | tmp = (void(*)(void)) GetProcAddress(libGL, "wglGetProcAddress"); 63 | gladGetProcAddressPtr = (PFNWGLGETPROCADDRESSPROC_PRIVATE) tmp; 64 | return gladGetProcAddressPtr != NULL; 65 | } 66 | #endif 67 | 68 | return 0; 69 | } 70 | 71 | static 72 | void close_gl(void) { 73 | if(libGL != NULL) { 74 | FreeLibrary((HMODULE) libGL); 75 | libGL = NULL; 76 | } 77 | } 78 | #else 79 | #include 80 | static void* libGL; 81 | 82 | #if !defined(__APPLE__) && !defined(__HAIKU__) 83 | typedef void* (APIENTRYP PFNGLXGETPROCADDRESSPROC_PRIVATE)(const char*); 84 | static PFNGLXGETPROCADDRESSPROC_PRIVATE gladGetProcAddressPtr; 85 | #endif 86 | 87 | static 88 | int open_gl(void) { 89 | #ifdef __APPLE__ 90 | static const char *NAMES[] = { 91 | "../Frameworks/OpenGL.framework/OpenGL", 92 | "/Library/Frameworks/OpenGL.framework/OpenGL", 93 | "/System/Library/Frameworks/OpenGL.framework/OpenGL", 94 | "/System/Library/Frameworks/OpenGL.framework/Versions/Current/OpenGL" 95 | }; 96 | #else 97 | static const char *NAMES[] = {"libGL.so.1", "libGL.so"}; 98 | #endif 99 | 100 | unsigned int index = 0; 101 | for(index = 0; index < (sizeof(NAMES) / sizeof(NAMES[0])); index++) { 102 | libGL = dlopen(NAMES[index], RTLD_NOW | RTLD_GLOBAL); 103 | 104 | if(libGL != NULL) { 105 | #if defined(__APPLE__) || defined(__HAIKU__) 106 | return 1; 107 | #else 108 | gladGetProcAddressPtr = (PFNGLXGETPROCADDRESSPROC_PRIVATE)dlsym(libGL, 109 | "glXGetProcAddressARB"); 110 | return gladGetProcAddressPtr != NULL; 111 | #endif 112 | } 113 | } 114 | 115 | return 0; 116 | } 117 | 118 | static 119 | void close_gl(void) { 120 | if(libGL != NULL) { 121 | dlclose(libGL); 122 | libGL = NULL; 123 | } 124 | } 125 | #endif 126 | 127 | static 128 | void* get_proc(const char *namez) { 129 | void* result = NULL; 130 | if(libGL == NULL) return NULL; 131 | 132 | #if !defined(__APPLE__) && !defined(__HAIKU__) 133 | if(gladGetProcAddressPtr != NULL) { 134 | result = gladGetProcAddressPtr(namez); 135 | } 136 | #endif 137 | if(result == NULL) { 138 | #if defined(_WIN32) || defined(__CYGWIN__) 139 | result = (void*)GetProcAddress((HMODULE) libGL, namez); 140 | #else 141 | result = dlsym(libGL, namez); 142 | #endif 143 | } 144 | 145 | return result; 146 | } 147 | 148 | int gladLoadGL(void) { 149 | int status = 0; 150 | 151 | if(open_gl()) { 152 | status = gladLoadGLLoader(&get_proc); 153 | close_gl(); 154 | } 155 | 156 | return status; 157 | } 158 | 159 | struct gladGLversionStruct GLVersion = { 0, 0 }; 160 | 161 | #if defined(GL_ES_VERSION_3_0) || defined(GL_VERSION_3_0) 162 | #define _GLAD_IS_SOME_NEW_VERSION 1 163 | #endif 164 | 165 | static int max_loaded_major; 166 | static int max_loaded_minor; 167 | 168 | static const char *exts = NULL; 169 | static int num_exts_i = 0; 170 | static char **exts_i = NULL; 171 | 172 | static int get_exts(void) { 173 | #ifdef _GLAD_IS_SOME_NEW_VERSION 174 | if(max_loaded_major < 3) { 175 | #endif 176 | exts = (const char *)glGetString(GL_EXTENSIONS); 177 | #ifdef _GLAD_IS_SOME_NEW_VERSION 178 | } else { 179 | unsigned int index; 180 | 181 | num_exts_i = 0; 182 | glGetIntegerv(GL_NUM_EXTENSIONS, &num_exts_i); 183 | if (num_exts_i > 0) { 184 | exts_i = (char **)malloc((size_t)num_exts_i * (sizeof *exts_i)); 185 | } 186 | 187 | if (exts_i == NULL) { 188 | return 0; 189 | } 190 | 191 | for(index = 0; index < (unsigned)num_exts_i; index++) { 192 | const char *gl_str_tmp = (const char*)glGetStringi(GL_EXTENSIONS, index); 193 | size_t len = strlen(gl_str_tmp); 194 | 195 | char *local_str = (char*)malloc((len+1) * sizeof(char)); 196 | if(local_str != NULL) { 197 | memcpy(local_str, gl_str_tmp, (len+1) * sizeof(char)); 198 | } 199 | exts_i[index] = local_str; 200 | } 201 | } 202 | #endif 203 | return 1; 204 | } 205 | 206 | static void free_exts(void) { 207 | if (exts_i != NULL) { 208 | int index; 209 | for(index = 0; index < num_exts_i; index++) { 210 | free((char *)exts_i[index]); 211 | } 212 | free((void *)exts_i); 213 | exts_i = NULL; 214 | } 215 | } 216 | 217 | static int has_ext(const char *ext) { 218 | #ifdef _GLAD_IS_SOME_NEW_VERSION 219 | if(max_loaded_major < 3) { 220 | #endif 221 | const char *extensions; 222 | const char *loc; 223 | const char *terminator; 224 | extensions = exts; 225 | if(extensions == NULL || ext == NULL) { 226 | return 0; 227 | } 228 | 229 | while(1) { 230 | loc = strstr(extensions, ext); 231 | if(loc == NULL) { 232 | return 0; 233 | } 234 | 235 | terminator = loc + strlen(ext); 236 | if((loc == extensions || *(loc - 1) == ' ') && 237 | (*terminator == ' ' || *terminator == '\0')) { 238 | return 1; 239 | } 240 | extensions = terminator; 241 | } 242 | #ifdef _GLAD_IS_SOME_NEW_VERSION 243 | } else { 244 | int index; 245 | if(exts_i == NULL) return 0; 246 | for(index = 0; index < num_exts_i; index++) { 247 | const char *e = exts_i[index]; 248 | 249 | if(exts_i[index] != NULL && strcmp(e, ext) == 0) { 250 | return 1; 251 | } 252 | } 253 | } 254 | #endif 255 | 256 | return 0; 257 | } 258 | int GLAD_GL_VERSION_1_0 = 0; 259 | int GLAD_GL_VERSION_1_1 = 0; 260 | int GLAD_GL_VERSION_1_2 = 0; 261 | int GLAD_GL_VERSION_1_3 = 0; 262 | int GLAD_GL_VERSION_1_4 = 0; 263 | int GLAD_GL_VERSION_1_5 = 0; 264 | int GLAD_GL_VERSION_2_0 = 0; 265 | int GLAD_GL_VERSION_2_1 = 0; 266 | int GLAD_GL_VERSION_3_0 = 0; 267 | int GLAD_GL_VERSION_3_1 = 0; 268 | int GLAD_GL_VERSION_3_2 = 0; 269 | int GLAD_GL_VERSION_3_3 = 0; 270 | PFNGLACCUMPROC glad_glAccum = NULL; 271 | PFNGLACTIVETEXTUREPROC glad_glActiveTexture = NULL; 272 | PFNGLALPHAFUNCPROC glad_glAlphaFunc = NULL; 273 | PFNGLARETEXTURESRESIDENTPROC glad_glAreTexturesResident = NULL; 274 | PFNGLARRAYELEMENTPROC glad_glArrayElement = NULL; 275 | PFNGLATTACHSHADERPROC glad_glAttachShader = NULL; 276 | PFNGLBEGINPROC glad_glBegin = NULL; 277 | PFNGLBEGINCONDITIONALRENDERPROC glad_glBeginConditionalRender = NULL; 278 | PFNGLBEGINQUERYPROC glad_glBeginQuery = NULL; 279 | PFNGLBEGINTRANSFORMFEEDBACKPROC glad_glBeginTransformFeedback = NULL; 280 | PFNGLBINDATTRIBLOCATIONPROC glad_glBindAttribLocation = NULL; 281 | PFNGLBINDBUFFERPROC glad_glBindBuffer = NULL; 282 | PFNGLBINDBUFFERBASEPROC glad_glBindBufferBase = NULL; 283 | PFNGLBINDBUFFERRANGEPROC glad_glBindBufferRange = NULL; 284 | PFNGLBINDFRAGDATALOCATIONPROC glad_glBindFragDataLocation = NULL; 285 | PFNGLBINDFRAGDATALOCATIONINDEXEDPROC glad_glBindFragDataLocationIndexed = NULL; 286 | PFNGLBINDFRAMEBUFFERPROC glad_glBindFramebuffer = NULL; 287 | PFNGLBINDRENDERBUFFERPROC glad_glBindRenderbuffer = NULL; 288 | PFNGLBINDSAMPLERPROC glad_glBindSampler = NULL; 289 | PFNGLBINDTEXTUREPROC glad_glBindTexture = NULL; 290 | PFNGLBINDVERTEXARRAYPROC glad_glBindVertexArray = NULL; 291 | PFNGLBITMAPPROC glad_glBitmap = NULL; 292 | PFNGLBLENDCOLORPROC glad_glBlendColor = NULL; 293 | PFNGLBLENDEQUATIONPROC glad_glBlendEquation = NULL; 294 | PFNGLBLENDEQUATIONSEPARATEPROC glad_glBlendEquationSeparate = NULL; 295 | PFNGLBLENDFUNCPROC glad_glBlendFunc = NULL; 296 | PFNGLBLENDFUNCSEPARATEPROC glad_glBlendFuncSeparate = NULL; 297 | PFNGLBLITFRAMEBUFFERPROC glad_glBlitFramebuffer = NULL; 298 | PFNGLBUFFERDATAPROC glad_glBufferData = NULL; 299 | PFNGLBUFFERSUBDATAPROC glad_glBufferSubData = NULL; 300 | PFNGLCALLLISTPROC glad_glCallList = NULL; 301 | PFNGLCALLLISTSPROC glad_glCallLists = NULL; 302 | PFNGLCHECKFRAMEBUFFERSTATUSPROC glad_glCheckFramebufferStatus = NULL; 303 | PFNGLCLAMPCOLORPROC glad_glClampColor = NULL; 304 | PFNGLCLEARPROC glad_glClear = NULL; 305 | PFNGLCLEARACCUMPROC glad_glClearAccum = NULL; 306 | PFNGLCLEARBUFFERFIPROC glad_glClearBufferfi = NULL; 307 | PFNGLCLEARBUFFERFVPROC glad_glClearBufferfv = NULL; 308 | PFNGLCLEARBUFFERIVPROC glad_glClearBufferiv = NULL; 309 | PFNGLCLEARBUFFERUIVPROC glad_glClearBufferuiv = NULL; 310 | PFNGLCLEARCOLORPROC glad_glClearColor = NULL; 311 | PFNGLCLEARDEPTHPROC glad_glClearDepth = NULL; 312 | PFNGLCLEARINDEXPROC glad_glClearIndex = NULL; 313 | PFNGLCLEARSTENCILPROC glad_glClearStencil = NULL; 314 | PFNGLCLIENTACTIVETEXTUREPROC glad_glClientActiveTexture = NULL; 315 | PFNGLCLIENTWAITSYNCPROC glad_glClientWaitSync = NULL; 316 | PFNGLCLIPPLANEPROC glad_glClipPlane = NULL; 317 | PFNGLCOLOR3BPROC glad_glColor3b = NULL; 318 | PFNGLCOLOR3BVPROC glad_glColor3bv = NULL; 319 | PFNGLCOLOR3DPROC glad_glColor3d = NULL; 320 | PFNGLCOLOR3DVPROC glad_glColor3dv = NULL; 321 | PFNGLCOLOR3FPROC glad_glColor3f = NULL; 322 | PFNGLCOLOR3FVPROC glad_glColor3fv = NULL; 323 | PFNGLCOLOR3IPROC glad_glColor3i = NULL; 324 | PFNGLCOLOR3IVPROC glad_glColor3iv = NULL; 325 | PFNGLCOLOR3SPROC glad_glColor3s = NULL; 326 | PFNGLCOLOR3SVPROC glad_glColor3sv = NULL; 327 | PFNGLCOLOR3UBPROC glad_glColor3ub = NULL; 328 | PFNGLCOLOR3UBVPROC glad_glColor3ubv = NULL; 329 | PFNGLCOLOR3UIPROC glad_glColor3ui = NULL; 330 | PFNGLCOLOR3UIVPROC glad_glColor3uiv = NULL; 331 | PFNGLCOLOR3USPROC glad_glColor3us = NULL; 332 | PFNGLCOLOR3USVPROC glad_glColor3usv = NULL; 333 | PFNGLCOLOR4BPROC glad_glColor4b = NULL; 334 | PFNGLCOLOR4BVPROC glad_glColor4bv = NULL; 335 | PFNGLCOLOR4DPROC glad_glColor4d = NULL; 336 | PFNGLCOLOR4DVPROC glad_glColor4dv = NULL; 337 | PFNGLCOLOR4FPROC glad_glColor4f = NULL; 338 | PFNGLCOLOR4FVPROC glad_glColor4fv = NULL; 339 | PFNGLCOLOR4IPROC glad_glColor4i = NULL; 340 | PFNGLCOLOR4IVPROC glad_glColor4iv = NULL; 341 | PFNGLCOLOR4SPROC glad_glColor4s = NULL; 342 | PFNGLCOLOR4SVPROC glad_glColor4sv = NULL; 343 | PFNGLCOLOR4UBPROC glad_glColor4ub = NULL; 344 | PFNGLCOLOR4UBVPROC glad_glColor4ubv = NULL; 345 | PFNGLCOLOR4UIPROC glad_glColor4ui = NULL; 346 | PFNGLCOLOR4UIVPROC glad_glColor4uiv = NULL; 347 | PFNGLCOLOR4USPROC glad_glColor4us = NULL; 348 | PFNGLCOLOR4USVPROC glad_glColor4usv = NULL; 349 | PFNGLCOLORMASKPROC glad_glColorMask = NULL; 350 | PFNGLCOLORMASKIPROC glad_glColorMaski = NULL; 351 | PFNGLCOLORMATERIALPROC glad_glColorMaterial = NULL; 352 | PFNGLCOLORP3UIPROC glad_glColorP3ui = NULL; 353 | PFNGLCOLORP3UIVPROC glad_glColorP3uiv = NULL; 354 | PFNGLCOLORP4UIPROC glad_glColorP4ui = NULL; 355 | PFNGLCOLORP4UIVPROC glad_glColorP4uiv = NULL; 356 | PFNGLCOLORPOINTERPROC glad_glColorPointer = NULL; 357 | PFNGLCOMPILESHADERPROC glad_glCompileShader = NULL; 358 | PFNGLCOMPRESSEDTEXIMAGE1DPROC glad_glCompressedTexImage1D = NULL; 359 | PFNGLCOMPRESSEDTEXIMAGE2DPROC glad_glCompressedTexImage2D = NULL; 360 | PFNGLCOMPRESSEDTEXIMAGE3DPROC glad_glCompressedTexImage3D = NULL; 361 | PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC glad_glCompressedTexSubImage1D = NULL; 362 | PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC glad_glCompressedTexSubImage2D = NULL; 363 | PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC glad_glCompressedTexSubImage3D = NULL; 364 | PFNGLCOPYBUFFERSUBDATAPROC glad_glCopyBufferSubData = NULL; 365 | PFNGLCOPYPIXELSPROC glad_glCopyPixels = NULL; 366 | PFNGLCOPYTEXIMAGE1DPROC glad_glCopyTexImage1D = NULL; 367 | PFNGLCOPYTEXIMAGE2DPROC glad_glCopyTexImage2D = NULL; 368 | PFNGLCOPYTEXSUBIMAGE1DPROC glad_glCopyTexSubImage1D = NULL; 369 | PFNGLCOPYTEXSUBIMAGE2DPROC glad_glCopyTexSubImage2D = NULL; 370 | PFNGLCOPYTEXSUBIMAGE3DPROC glad_glCopyTexSubImage3D = NULL; 371 | PFNGLCREATEPROGRAMPROC glad_glCreateProgram = NULL; 372 | PFNGLCREATESHADERPROC glad_glCreateShader = NULL; 373 | PFNGLCULLFACEPROC glad_glCullFace = NULL; 374 | PFNGLDELETEBUFFERSPROC glad_glDeleteBuffers = NULL; 375 | PFNGLDELETEFRAMEBUFFERSPROC glad_glDeleteFramebuffers = NULL; 376 | PFNGLDELETELISTSPROC glad_glDeleteLists = NULL; 377 | PFNGLDELETEPROGRAMPROC glad_glDeleteProgram = NULL; 378 | PFNGLDELETEQUERIESPROC glad_glDeleteQueries = NULL; 379 | PFNGLDELETERENDERBUFFERSPROC glad_glDeleteRenderbuffers = NULL; 380 | PFNGLDELETESAMPLERSPROC glad_glDeleteSamplers = NULL; 381 | PFNGLDELETESHADERPROC glad_glDeleteShader = NULL; 382 | PFNGLDELETESYNCPROC glad_glDeleteSync = NULL; 383 | PFNGLDELETETEXTURESPROC glad_glDeleteTextures = NULL; 384 | PFNGLDELETEVERTEXARRAYSPROC glad_glDeleteVertexArrays = NULL; 385 | PFNGLDEPTHFUNCPROC glad_glDepthFunc = NULL; 386 | PFNGLDEPTHMASKPROC glad_glDepthMask = NULL; 387 | PFNGLDEPTHRANGEPROC glad_glDepthRange = NULL; 388 | PFNGLDETACHSHADERPROC glad_glDetachShader = NULL; 389 | PFNGLDISABLEPROC glad_glDisable = NULL; 390 | PFNGLDISABLECLIENTSTATEPROC glad_glDisableClientState = NULL; 391 | PFNGLDISABLEVERTEXATTRIBARRAYPROC glad_glDisableVertexAttribArray = NULL; 392 | PFNGLDISABLEIPROC glad_glDisablei = NULL; 393 | PFNGLDRAWARRAYSPROC glad_glDrawArrays = NULL; 394 | PFNGLDRAWARRAYSINSTANCEDPROC glad_glDrawArraysInstanced = NULL; 395 | PFNGLDRAWBUFFERPROC glad_glDrawBuffer = NULL; 396 | PFNGLDRAWBUFFERSPROC glad_glDrawBuffers = NULL; 397 | PFNGLDRAWELEMENTSPROC glad_glDrawElements = NULL; 398 | PFNGLDRAWELEMENTSBASEVERTEXPROC glad_glDrawElementsBaseVertex = NULL; 399 | PFNGLDRAWELEMENTSINSTANCEDPROC glad_glDrawElementsInstanced = NULL; 400 | PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC glad_glDrawElementsInstancedBaseVertex = NULL; 401 | PFNGLDRAWPIXELSPROC glad_glDrawPixels = NULL; 402 | PFNGLDRAWRANGEELEMENTSPROC glad_glDrawRangeElements = NULL; 403 | PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC glad_glDrawRangeElementsBaseVertex = NULL; 404 | PFNGLEDGEFLAGPROC glad_glEdgeFlag = NULL; 405 | PFNGLEDGEFLAGPOINTERPROC glad_glEdgeFlagPointer = NULL; 406 | PFNGLEDGEFLAGVPROC glad_glEdgeFlagv = NULL; 407 | PFNGLENABLEPROC glad_glEnable = NULL; 408 | PFNGLENABLECLIENTSTATEPROC glad_glEnableClientState = NULL; 409 | PFNGLENABLEVERTEXATTRIBARRAYPROC glad_glEnableVertexAttribArray = NULL; 410 | PFNGLENABLEIPROC glad_glEnablei = NULL; 411 | PFNGLENDPROC glad_glEnd = NULL; 412 | PFNGLENDCONDITIONALRENDERPROC glad_glEndConditionalRender = NULL; 413 | PFNGLENDLISTPROC glad_glEndList = NULL; 414 | PFNGLENDQUERYPROC glad_glEndQuery = NULL; 415 | PFNGLENDTRANSFORMFEEDBACKPROC glad_glEndTransformFeedback = NULL; 416 | PFNGLEVALCOORD1DPROC glad_glEvalCoord1d = NULL; 417 | PFNGLEVALCOORD1DVPROC glad_glEvalCoord1dv = NULL; 418 | PFNGLEVALCOORD1FPROC glad_glEvalCoord1f = NULL; 419 | PFNGLEVALCOORD1FVPROC glad_glEvalCoord1fv = NULL; 420 | PFNGLEVALCOORD2DPROC glad_glEvalCoord2d = NULL; 421 | PFNGLEVALCOORD2DVPROC glad_glEvalCoord2dv = NULL; 422 | PFNGLEVALCOORD2FPROC glad_glEvalCoord2f = NULL; 423 | PFNGLEVALCOORD2FVPROC glad_glEvalCoord2fv = NULL; 424 | PFNGLEVALMESH1PROC glad_glEvalMesh1 = NULL; 425 | PFNGLEVALMESH2PROC glad_glEvalMesh2 = NULL; 426 | PFNGLEVALPOINT1PROC glad_glEvalPoint1 = NULL; 427 | PFNGLEVALPOINT2PROC glad_glEvalPoint2 = NULL; 428 | PFNGLFEEDBACKBUFFERPROC glad_glFeedbackBuffer = NULL; 429 | PFNGLFENCESYNCPROC glad_glFenceSync = NULL; 430 | PFNGLFINISHPROC glad_glFinish = NULL; 431 | PFNGLFLUSHPROC glad_glFlush = NULL; 432 | PFNGLFLUSHMAPPEDBUFFERRANGEPROC glad_glFlushMappedBufferRange = NULL; 433 | PFNGLFOGCOORDPOINTERPROC glad_glFogCoordPointer = NULL; 434 | PFNGLFOGCOORDDPROC glad_glFogCoordd = NULL; 435 | PFNGLFOGCOORDDVPROC glad_glFogCoorddv = NULL; 436 | PFNGLFOGCOORDFPROC glad_glFogCoordf = NULL; 437 | PFNGLFOGCOORDFVPROC glad_glFogCoordfv = NULL; 438 | PFNGLFOGFPROC glad_glFogf = NULL; 439 | PFNGLFOGFVPROC glad_glFogfv = NULL; 440 | PFNGLFOGIPROC glad_glFogi = NULL; 441 | PFNGLFOGIVPROC glad_glFogiv = NULL; 442 | PFNGLFRAMEBUFFERRENDERBUFFERPROC glad_glFramebufferRenderbuffer = NULL; 443 | PFNGLFRAMEBUFFERTEXTUREPROC glad_glFramebufferTexture = NULL; 444 | PFNGLFRAMEBUFFERTEXTURE1DPROC glad_glFramebufferTexture1D = NULL; 445 | PFNGLFRAMEBUFFERTEXTURE2DPROC glad_glFramebufferTexture2D = NULL; 446 | PFNGLFRAMEBUFFERTEXTURE3DPROC glad_glFramebufferTexture3D = NULL; 447 | PFNGLFRAMEBUFFERTEXTURELAYERPROC glad_glFramebufferTextureLayer = NULL; 448 | PFNGLFRONTFACEPROC glad_glFrontFace = NULL; 449 | PFNGLFRUSTUMPROC glad_glFrustum = NULL; 450 | PFNGLGENBUFFERSPROC glad_glGenBuffers = NULL; 451 | PFNGLGENFRAMEBUFFERSPROC glad_glGenFramebuffers = NULL; 452 | PFNGLGENLISTSPROC glad_glGenLists = NULL; 453 | PFNGLGENQUERIESPROC glad_glGenQueries = NULL; 454 | PFNGLGENRENDERBUFFERSPROC glad_glGenRenderbuffers = NULL; 455 | PFNGLGENSAMPLERSPROC glad_glGenSamplers = NULL; 456 | PFNGLGENTEXTURESPROC glad_glGenTextures = NULL; 457 | PFNGLGENVERTEXARRAYSPROC glad_glGenVertexArrays = NULL; 458 | PFNGLGENERATEMIPMAPPROC glad_glGenerateMipmap = NULL; 459 | PFNGLGETACTIVEATTRIBPROC glad_glGetActiveAttrib = NULL; 460 | PFNGLGETACTIVEUNIFORMPROC glad_glGetActiveUniform = NULL; 461 | PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC glad_glGetActiveUniformBlockName = NULL; 462 | PFNGLGETACTIVEUNIFORMBLOCKIVPROC glad_glGetActiveUniformBlockiv = NULL; 463 | PFNGLGETACTIVEUNIFORMNAMEPROC glad_glGetActiveUniformName = NULL; 464 | PFNGLGETACTIVEUNIFORMSIVPROC glad_glGetActiveUniformsiv = NULL; 465 | PFNGLGETATTACHEDSHADERSPROC glad_glGetAttachedShaders = NULL; 466 | PFNGLGETATTRIBLOCATIONPROC glad_glGetAttribLocation = NULL; 467 | PFNGLGETBOOLEANI_VPROC glad_glGetBooleani_v = NULL; 468 | PFNGLGETBOOLEANVPROC glad_glGetBooleanv = NULL; 469 | PFNGLGETBUFFERPARAMETERI64VPROC glad_glGetBufferParameteri64v = NULL; 470 | PFNGLGETBUFFERPARAMETERIVPROC glad_glGetBufferParameteriv = NULL; 471 | PFNGLGETBUFFERPOINTERVPROC glad_glGetBufferPointerv = NULL; 472 | PFNGLGETBUFFERSUBDATAPROC glad_glGetBufferSubData = NULL; 473 | PFNGLGETCLIPPLANEPROC glad_glGetClipPlane = NULL; 474 | PFNGLGETCOMPRESSEDTEXIMAGEPROC glad_glGetCompressedTexImage = NULL; 475 | PFNGLGETDOUBLEVPROC glad_glGetDoublev = NULL; 476 | PFNGLGETERRORPROC glad_glGetError = NULL; 477 | PFNGLGETFLOATVPROC glad_glGetFloatv = NULL; 478 | PFNGLGETFRAGDATAINDEXPROC glad_glGetFragDataIndex = NULL; 479 | PFNGLGETFRAGDATALOCATIONPROC glad_glGetFragDataLocation = NULL; 480 | PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC glad_glGetFramebufferAttachmentParameteriv = NULL; 481 | PFNGLGETINTEGER64I_VPROC glad_glGetInteger64i_v = NULL; 482 | PFNGLGETINTEGER64VPROC glad_glGetInteger64v = NULL; 483 | PFNGLGETINTEGERI_VPROC glad_glGetIntegeri_v = NULL; 484 | PFNGLGETINTEGERVPROC glad_glGetIntegerv = NULL; 485 | PFNGLGETLIGHTFVPROC glad_glGetLightfv = NULL; 486 | PFNGLGETLIGHTIVPROC glad_glGetLightiv = NULL; 487 | PFNGLGETMAPDVPROC glad_glGetMapdv = NULL; 488 | PFNGLGETMAPFVPROC glad_glGetMapfv = NULL; 489 | PFNGLGETMAPIVPROC glad_glGetMapiv = NULL; 490 | PFNGLGETMATERIALFVPROC glad_glGetMaterialfv = NULL; 491 | PFNGLGETMATERIALIVPROC glad_glGetMaterialiv = NULL; 492 | PFNGLGETMULTISAMPLEFVPROC glad_glGetMultisamplefv = NULL; 493 | PFNGLGETPIXELMAPFVPROC glad_glGetPixelMapfv = NULL; 494 | PFNGLGETPIXELMAPUIVPROC glad_glGetPixelMapuiv = NULL; 495 | PFNGLGETPIXELMAPUSVPROC glad_glGetPixelMapusv = NULL; 496 | PFNGLGETPOINTERVPROC glad_glGetPointerv = NULL; 497 | PFNGLGETPOLYGONSTIPPLEPROC glad_glGetPolygonStipple = NULL; 498 | PFNGLGETPROGRAMINFOLOGPROC glad_glGetProgramInfoLog = NULL; 499 | PFNGLGETPROGRAMIVPROC glad_glGetProgramiv = NULL; 500 | PFNGLGETQUERYOBJECTI64VPROC glad_glGetQueryObjecti64v = NULL; 501 | PFNGLGETQUERYOBJECTIVPROC glad_glGetQueryObjectiv = NULL; 502 | PFNGLGETQUERYOBJECTUI64VPROC glad_glGetQueryObjectui64v = NULL; 503 | PFNGLGETQUERYOBJECTUIVPROC glad_glGetQueryObjectuiv = NULL; 504 | PFNGLGETQUERYIVPROC glad_glGetQueryiv = NULL; 505 | PFNGLGETRENDERBUFFERPARAMETERIVPROC glad_glGetRenderbufferParameteriv = NULL; 506 | PFNGLGETSAMPLERPARAMETERIIVPROC glad_glGetSamplerParameterIiv = NULL; 507 | PFNGLGETSAMPLERPARAMETERIUIVPROC glad_glGetSamplerParameterIuiv = NULL; 508 | PFNGLGETSAMPLERPARAMETERFVPROC glad_glGetSamplerParameterfv = NULL; 509 | PFNGLGETSAMPLERPARAMETERIVPROC glad_glGetSamplerParameteriv = NULL; 510 | PFNGLGETSHADERINFOLOGPROC glad_glGetShaderInfoLog = NULL; 511 | PFNGLGETSHADERSOURCEPROC glad_glGetShaderSource = NULL; 512 | PFNGLGETSHADERIVPROC glad_glGetShaderiv = NULL; 513 | PFNGLGETSTRINGPROC glad_glGetString = NULL; 514 | PFNGLGETSTRINGIPROC glad_glGetStringi = NULL; 515 | PFNGLGETSYNCIVPROC glad_glGetSynciv = NULL; 516 | PFNGLGETTEXENVFVPROC glad_glGetTexEnvfv = NULL; 517 | PFNGLGETTEXENVIVPROC glad_glGetTexEnviv = NULL; 518 | PFNGLGETTEXGENDVPROC glad_glGetTexGendv = NULL; 519 | PFNGLGETTEXGENFVPROC glad_glGetTexGenfv = NULL; 520 | PFNGLGETTEXGENIVPROC glad_glGetTexGeniv = NULL; 521 | PFNGLGETTEXIMAGEPROC glad_glGetTexImage = NULL; 522 | PFNGLGETTEXLEVELPARAMETERFVPROC glad_glGetTexLevelParameterfv = NULL; 523 | PFNGLGETTEXLEVELPARAMETERIVPROC glad_glGetTexLevelParameteriv = NULL; 524 | PFNGLGETTEXPARAMETERIIVPROC glad_glGetTexParameterIiv = NULL; 525 | PFNGLGETTEXPARAMETERIUIVPROC glad_glGetTexParameterIuiv = NULL; 526 | PFNGLGETTEXPARAMETERFVPROC glad_glGetTexParameterfv = NULL; 527 | PFNGLGETTEXPARAMETERIVPROC glad_glGetTexParameteriv = NULL; 528 | PFNGLGETTRANSFORMFEEDBACKVARYINGPROC glad_glGetTransformFeedbackVarying = NULL; 529 | PFNGLGETUNIFORMBLOCKINDEXPROC glad_glGetUniformBlockIndex = NULL; 530 | PFNGLGETUNIFORMINDICESPROC glad_glGetUniformIndices = NULL; 531 | PFNGLGETUNIFORMLOCATIONPROC glad_glGetUniformLocation = NULL; 532 | PFNGLGETUNIFORMFVPROC glad_glGetUniformfv = NULL; 533 | PFNGLGETUNIFORMIVPROC glad_glGetUniformiv = NULL; 534 | PFNGLGETUNIFORMUIVPROC glad_glGetUniformuiv = NULL; 535 | PFNGLGETVERTEXATTRIBIIVPROC glad_glGetVertexAttribIiv = NULL; 536 | PFNGLGETVERTEXATTRIBIUIVPROC glad_glGetVertexAttribIuiv = NULL; 537 | PFNGLGETVERTEXATTRIBPOINTERVPROC glad_glGetVertexAttribPointerv = NULL; 538 | PFNGLGETVERTEXATTRIBDVPROC glad_glGetVertexAttribdv = NULL; 539 | PFNGLGETVERTEXATTRIBFVPROC glad_glGetVertexAttribfv = NULL; 540 | PFNGLGETVERTEXATTRIBIVPROC glad_glGetVertexAttribiv = NULL; 541 | PFNGLHINTPROC glad_glHint = NULL; 542 | PFNGLINDEXMASKPROC glad_glIndexMask = NULL; 543 | PFNGLINDEXPOINTERPROC glad_glIndexPointer = NULL; 544 | PFNGLINDEXDPROC glad_glIndexd = NULL; 545 | PFNGLINDEXDVPROC glad_glIndexdv = NULL; 546 | PFNGLINDEXFPROC glad_glIndexf = NULL; 547 | PFNGLINDEXFVPROC glad_glIndexfv = NULL; 548 | PFNGLINDEXIPROC glad_glIndexi = NULL; 549 | PFNGLINDEXIVPROC glad_glIndexiv = NULL; 550 | PFNGLINDEXSPROC glad_glIndexs = NULL; 551 | PFNGLINDEXSVPROC glad_glIndexsv = NULL; 552 | PFNGLINDEXUBPROC glad_glIndexub = NULL; 553 | PFNGLINDEXUBVPROC glad_glIndexubv = NULL; 554 | PFNGLINITNAMESPROC glad_glInitNames = NULL; 555 | PFNGLINTERLEAVEDARRAYSPROC glad_glInterleavedArrays = NULL; 556 | PFNGLISBUFFERPROC glad_glIsBuffer = NULL; 557 | PFNGLISENABLEDPROC glad_glIsEnabled = NULL; 558 | PFNGLISENABLEDIPROC glad_glIsEnabledi = NULL; 559 | PFNGLISFRAMEBUFFERPROC glad_glIsFramebuffer = NULL; 560 | PFNGLISLISTPROC glad_glIsList = NULL; 561 | PFNGLISPROGRAMPROC glad_glIsProgram = NULL; 562 | PFNGLISQUERYPROC glad_glIsQuery = NULL; 563 | PFNGLISRENDERBUFFERPROC glad_glIsRenderbuffer = NULL; 564 | PFNGLISSAMPLERPROC glad_glIsSampler = NULL; 565 | PFNGLISSHADERPROC glad_glIsShader = NULL; 566 | PFNGLISSYNCPROC glad_glIsSync = NULL; 567 | PFNGLISTEXTUREPROC glad_glIsTexture = NULL; 568 | PFNGLISVERTEXARRAYPROC glad_glIsVertexArray = NULL; 569 | PFNGLLIGHTMODELFPROC glad_glLightModelf = NULL; 570 | PFNGLLIGHTMODELFVPROC glad_glLightModelfv = NULL; 571 | PFNGLLIGHTMODELIPROC glad_glLightModeli = NULL; 572 | PFNGLLIGHTMODELIVPROC glad_glLightModeliv = NULL; 573 | PFNGLLIGHTFPROC glad_glLightf = NULL; 574 | PFNGLLIGHTFVPROC glad_glLightfv = NULL; 575 | PFNGLLIGHTIPROC glad_glLighti = NULL; 576 | PFNGLLIGHTIVPROC glad_glLightiv = NULL; 577 | PFNGLLINESTIPPLEPROC glad_glLineStipple = NULL; 578 | PFNGLLINEWIDTHPROC glad_glLineWidth = NULL; 579 | PFNGLLINKPROGRAMPROC glad_glLinkProgram = NULL; 580 | PFNGLLISTBASEPROC glad_glListBase = NULL; 581 | PFNGLLOADIDENTITYPROC glad_glLoadIdentity = NULL; 582 | PFNGLLOADMATRIXDPROC glad_glLoadMatrixd = NULL; 583 | PFNGLLOADMATRIXFPROC glad_glLoadMatrixf = NULL; 584 | PFNGLLOADNAMEPROC glad_glLoadName = NULL; 585 | PFNGLLOADTRANSPOSEMATRIXDPROC glad_glLoadTransposeMatrixd = NULL; 586 | PFNGLLOADTRANSPOSEMATRIXFPROC glad_glLoadTransposeMatrixf = NULL; 587 | PFNGLLOGICOPPROC glad_glLogicOp = NULL; 588 | PFNGLMAP1DPROC glad_glMap1d = NULL; 589 | PFNGLMAP1FPROC glad_glMap1f = NULL; 590 | PFNGLMAP2DPROC glad_glMap2d = NULL; 591 | PFNGLMAP2FPROC glad_glMap2f = NULL; 592 | PFNGLMAPBUFFERPROC glad_glMapBuffer = NULL; 593 | PFNGLMAPBUFFERRANGEPROC glad_glMapBufferRange = NULL; 594 | PFNGLMAPGRID1DPROC glad_glMapGrid1d = NULL; 595 | PFNGLMAPGRID1FPROC glad_glMapGrid1f = NULL; 596 | PFNGLMAPGRID2DPROC glad_glMapGrid2d = NULL; 597 | PFNGLMAPGRID2FPROC glad_glMapGrid2f = NULL; 598 | PFNGLMATERIALFPROC glad_glMaterialf = NULL; 599 | PFNGLMATERIALFVPROC glad_glMaterialfv = NULL; 600 | PFNGLMATERIALIPROC glad_glMateriali = NULL; 601 | PFNGLMATERIALIVPROC glad_glMaterialiv = NULL; 602 | PFNGLMATRIXMODEPROC glad_glMatrixMode = NULL; 603 | PFNGLMULTMATRIXDPROC glad_glMultMatrixd = NULL; 604 | PFNGLMULTMATRIXFPROC glad_glMultMatrixf = NULL; 605 | PFNGLMULTTRANSPOSEMATRIXDPROC glad_glMultTransposeMatrixd = NULL; 606 | PFNGLMULTTRANSPOSEMATRIXFPROC glad_glMultTransposeMatrixf = NULL; 607 | PFNGLMULTIDRAWARRAYSPROC glad_glMultiDrawArrays = NULL; 608 | PFNGLMULTIDRAWELEMENTSPROC glad_glMultiDrawElements = NULL; 609 | PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC glad_glMultiDrawElementsBaseVertex = NULL; 610 | PFNGLMULTITEXCOORD1DPROC glad_glMultiTexCoord1d = NULL; 611 | PFNGLMULTITEXCOORD1DVPROC glad_glMultiTexCoord1dv = NULL; 612 | PFNGLMULTITEXCOORD1FPROC glad_glMultiTexCoord1f = NULL; 613 | PFNGLMULTITEXCOORD1FVPROC glad_glMultiTexCoord1fv = NULL; 614 | PFNGLMULTITEXCOORD1IPROC glad_glMultiTexCoord1i = NULL; 615 | PFNGLMULTITEXCOORD1IVPROC glad_glMultiTexCoord1iv = NULL; 616 | PFNGLMULTITEXCOORD1SPROC glad_glMultiTexCoord1s = NULL; 617 | PFNGLMULTITEXCOORD1SVPROC glad_glMultiTexCoord1sv = NULL; 618 | PFNGLMULTITEXCOORD2DPROC glad_glMultiTexCoord2d = NULL; 619 | PFNGLMULTITEXCOORD2DVPROC glad_glMultiTexCoord2dv = NULL; 620 | PFNGLMULTITEXCOORD2FPROC glad_glMultiTexCoord2f = NULL; 621 | PFNGLMULTITEXCOORD2FVPROC glad_glMultiTexCoord2fv = NULL; 622 | PFNGLMULTITEXCOORD2IPROC glad_glMultiTexCoord2i = NULL; 623 | PFNGLMULTITEXCOORD2IVPROC glad_glMultiTexCoord2iv = NULL; 624 | PFNGLMULTITEXCOORD2SPROC glad_glMultiTexCoord2s = NULL; 625 | PFNGLMULTITEXCOORD2SVPROC glad_glMultiTexCoord2sv = NULL; 626 | PFNGLMULTITEXCOORD3DPROC glad_glMultiTexCoord3d = NULL; 627 | PFNGLMULTITEXCOORD3DVPROC glad_glMultiTexCoord3dv = NULL; 628 | PFNGLMULTITEXCOORD3FPROC glad_glMultiTexCoord3f = NULL; 629 | PFNGLMULTITEXCOORD3FVPROC glad_glMultiTexCoord3fv = NULL; 630 | PFNGLMULTITEXCOORD3IPROC glad_glMultiTexCoord3i = NULL; 631 | PFNGLMULTITEXCOORD3IVPROC glad_glMultiTexCoord3iv = NULL; 632 | PFNGLMULTITEXCOORD3SPROC glad_glMultiTexCoord3s = NULL; 633 | PFNGLMULTITEXCOORD3SVPROC glad_glMultiTexCoord3sv = NULL; 634 | PFNGLMULTITEXCOORD4DPROC glad_glMultiTexCoord4d = NULL; 635 | PFNGLMULTITEXCOORD4DVPROC glad_glMultiTexCoord4dv = NULL; 636 | PFNGLMULTITEXCOORD4FPROC glad_glMultiTexCoord4f = NULL; 637 | PFNGLMULTITEXCOORD4FVPROC glad_glMultiTexCoord4fv = NULL; 638 | PFNGLMULTITEXCOORD4IPROC glad_glMultiTexCoord4i = NULL; 639 | PFNGLMULTITEXCOORD4IVPROC glad_glMultiTexCoord4iv = NULL; 640 | PFNGLMULTITEXCOORD4SPROC glad_glMultiTexCoord4s = NULL; 641 | PFNGLMULTITEXCOORD4SVPROC glad_glMultiTexCoord4sv = NULL; 642 | PFNGLMULTITEXCOORDP1UIPROC glad_glMultiTexCoordP1ui = NULL; 643 | PFNGLMULTITEXCOORDP1UIVPROC glad_glMultiTexCoordP1uiv = NULL; 644 | PFNGLMULTITEXCOORDP2UIPROC glad_glMultiTexCoordP2ui = NULL; 645 | PFNGLMULTITEXCOORDP2UIVPROC glad_glMultiTexCoordP2uiv = NULL; 646 | PFNGLMULTITEXCOORDP3UIPROC glad_glMultiTexCoordP3ui = NULL; 647 | PFNGLMULTITEXCOORDP3UIVPROC glad_glMultiTexCoordP3uiv = NULL; 648 | PFNGLMULTITEXCOORDP4UIPROC glad_glMultiTexCoordP4ui = NULL; 649 | PFNGLMULTITEXCOORDP4UIVPROC glad_glMultiTexCoordP4uiv = NULL; 650 | PFNGLNEWLISTPROC glad_glNewList = NULL; 651 | PFNGLNORMAL3BPROC glad_glNormal3b = NULL; 652 | PFNGLNORMAL3BVPROC glad_glNormal3bv = NULL; 653 | PFNGLNORMAL3DPROC glad_glNormal3d = NULL; 654 | PFNGLNORMAL3DVPROC glad_glNormal3dv = NULL; 655 | PFNGLNORMAL3FPROC glad_glNormal3f = NULL; 656 | PFNGLNORMAL3FVPROC glad_glNormal3fv = NULL; 657 | PFNGLNORMAL3IPROC glad_glNormal3i = NULL; 658 | PFNGLNORMAL3IVPROC glad_glNormal3iv = NULL; 659 | PFNGLNORMAL3SPROC glad_glNormal3s = NULL; 660 | PFNGLNORMAL3SVPROC glad_glNormal3sv = NULL; 661 | PFNGLNORMALP3UIPROC glad_glNormalP3ui = NULL; 662 | PFNGLNORMALP3UIVPROC glad_glNormalP3uiv = NULL; 663 | PFNGLNORMALPOINTERPROC glad_glNormalPointer = NULL; 664 | PFNGLORTHOPROC glad_glOrtho = NULL; 665 | PFNGLPASSTHROUGHPROC glad_glPassThrough = NULL; 666 | PFNGLPIXELMAPFVPROC glad_glPixelMapfv = NULL; 667 | PFNGLPIXELMAPUIVPROC glad_glPixelMapuiv = NULL; 668 | PFNGLPIXELMAPUSVPROC glad_glPixelMapusv = NULL; 669 | PFNGLPIXELSTOREFPROC glad_glPixelStoref = NULL; 670 | PFNGLPIXELSTOREIPROC glad_glPixelStorei = NULL; 671 | PFNGLPIXELTRANSFERFPROC glad_glPixelTransferf = NULL; 672 | PFNGLPIXELTRANSFERIPROC glad_glPixelTransferi = NULL; 673 | PFNGLPIXELZOOMPROC glad_glPixelZoom = NULL; 674 | PFNGLPOINTPARAMETERFPROC glad_glPointParameterf = NULL; 675 | PFNGLPOINTPARAMETERFVPROC glad_glPointParameterfv = NULL; 676 | PFNGLPOINTPARAMETERIPROC glad_glPointParameteri = NULL; 677 | PFNGLPOINTPARAMETERIVPROC glad_glPointParameteriv = NULL; 678 | PFNGLPOINTSIZEPROC glad_glPointSize = NULL; 679 | PFNGLPOLYGONMODEPROC glad_glPolygonMode = NULL; 680 | PFNGLPOLYGONOFFSETPROC glad_glPolygonOffset = NULL; 681 | PFNGLPOLYGONSTIPPLEPROC glad_glPolygonStipple = NULL; 682 | PFNGLPOPATTRIBPROC glad_glPopAttrib = NULL; 683 | PFNGLPOPCLIENTATTRIBPROC glad_glPopClientAttrib = NULL; 684 | PFNGLPOPMATRIXPROC glad_glPopMatrix = NULL; 685 | PFNGLPOPNAMEPROC glad_glPopName = NULL; 686 | PFNGLPRIMITIVERESTARTINDEXPROC glad_glPrimitiveRestartIndex = NULL; 687 | PFNGLPRIORITIZETEXTURESPROC glad_glPrioritizeTextures = NULL; 688 | PFNGLPROVOKINGVERTEXPROC glad_glProvokingVertex = NULL; 689 | PFNGLPUSHATTRIBPROC glad_glPushAttrib = NULL; 690 | PFNGLPUSHCLIENTATTRIBPROC glad_glPushClientAttrib = NULL; 691 | PFNGLPUSHMATRIXPROC glad_glPushMatrix = NULL; 692 | PFNGLPUSHNAMEPROC glad_glPushName = NULL; 693 | PFNGLQUERYCOUNTERPROC glad_glQueryCounter = NULL; 694 | PFNGLRASTERPOS2DPROC glad_glRasterPos2d = NULL; 695 | PFNGLRASTERPOS2DVPROC glad_glRasterPos2dv = NULL; 696 | PFNGLRASTERPOS2FPROC glad_glRasterPos2f = NULL; 697 | PFNGLRASTERPOS2FVPROC glad_glRasterPos2fv = NULL; 698 | PFNGLRASTERPOS2IPROC glad_glRasterPos2i = NULL; 699 | PFNGLRASTERPOS2IVPROC glad_glRasterPos2iv = NULL; 700 | PFNGLRASTERPOS2SPROC glad_glRasterPos2s = NULL; 701 | PFNGLRASTERPOS2SVPROC glad_glRasterPos2sv = NULL; 702 | PFNGLRASTERPOS3DPROC glad_glRasterPos3d = NULL; 703 | PFNGLRASTERPOS3DVPROC glad_glRasterPos3dv = NULL; 704 | PFNGLRASTERPOS3FPROC glad_glRasterPos3f = NULL; 705 | PFNGLRASTERPOS3FVPROC glad_glRasterPos3fv = NULL; 706 | PFNGLRASTERPOS3IPROC glad_glRasterPos3i = NULL; 707 | PFNGLRASTERPOS3IVPROC glad_glRasterPos3iv = NULL; 708 | PFNGLRASTERPOS3SPROC glad_glRasterPos3s = NULL; 709 | PFNGLRASTERPOS3SVPROC glad_glRasterPos3sv = NULL; 710 | PFNGLRASTERPOS4DPROC glad_glRasterPos4d = NULL; 711 | PFNGLRASTERPOS4DVPROC glad_glRasterPos4dv = NULL; 712 | PFNGLRASTERPOS4FPROC glad_glRasterPos4f = NULL; 713 | PFNGLRASTERPOS4FVPROC glad_glRasterPos4fv = NULL; 714 | PFNGLRASTERPOS4IPROC glad_glRasterPos4i = NULL; 715 | PFNGLRASTERPOS4IVPROC glad_glRasterPos4iv = NULL; 716 | PFNGLRASTERPOS4SPROC glad_glRasterPos4s = NULL; 717 | PFNGLRASTERPOS4SVPROC glad_glRasterPos4sv = NULL; 718 | PFNGLREADBUFFERPROC glad_glReadBuffer = NULL; 719 | PFNGLREADPIXELSPROC glad_glReadPixels = NULL; 720 | PFNGLRECTDPROC glad_glRectd = NULL; 721 | PFNGLRECTDVPROC glad_glRectdv = NULL; 722 | PFNGLRECTFPROC glad_glRectf = NULL; 723 | PFNGLRECTFVPROC glad_glRectfv = NULL; 724 | PFNGLRECTIPROC glad_glRecti = NULL; 725 | PFNGLRECTIVPROC glad_glRectiv = NULL; 726 | PFNGLRECTSPROC glad_glRects = NULL; 727 | PFNGLRECTSVPROC glad_glRectsv = NULL; 728 | PFNGLRENDERMODEPROC glad_glRenderMode = NULL; 729 | PFNGLRENDERBUFFERSTORAGEPROC glad_glRenderbufferStorage = NULL; 730 | PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC glad_glRenderbufferStorageMultisample = NULL; 731 | PFNGLROTATEDPROC glad_glRotated = NULL; 732 | PFNGLROTATEFPROC glad_glRotatef = NULL; 733 | PFNGLSAMPLECOVERAGEPROC glad_glSampleCoverage = NULL; 734 | PFNGLSAMPLEMASKIPROC glad_glSampleMaski = NULL; 735 | PFNGLSAMPLERPARAMETERIIVPROC glad_glSamplerParameterIiv = NULL; 736 | PFNGLSAMPLERPARAMETERIUIVPROC glad_glSamplerParameterIuiv = NULL; 737 | PFNGLSAMPLERPARAMETERFPROC glad_glSamplerParameterf = NULL; 738 | PFNGLSAMPLERPARAMETERFVPROC glad_glSamplerParameterfv = NULL; 739 | PFNGLSAMPLERPARAMETERIPROC glad_glSamplerParameteri = NULL; 740 | PFNGLSAMPLERPARAMETERIVPROC glad_glSamplerParameteriv = NULL; 741 | PFNGLSCALEDPROC glad_glScaled = NULL; 742 | PFNGLSCALEFPROC glad_glScalef = NULL; 743 | PFNGLSCISSORPROC glad_glScissor = NULL; 744 | PFNGLSECONDARYCOLOR3BPROC glad_glSecondaryColor3b = NULL; 745 | PFNGLSECONDARYCOLOR3BVPROC glad_glSecondaryColor3bv = NULL; 746 | PFNGLSECONDARYCOLOR3DPROC glad_glSecondaryColor3d = NULL; 747 | PFNGLSECONDARYCOLOR3DVPROC glad_glSecondaryColor3dv = NULL; 748 | PFNGLSECONDARYCOLOR3FPROC glad_glSecondaryColor3f = NULL; 749 | PFNGLSECONDARYCOLOR3FVPROC glad_glSecondaryColor3fv = NULL; 750 | PFNGLSECONDARYCOLOR3IPROC glad_glSecondaryColor3i = NULL; 751 | PFNGLSECONDARYCOLOR3IVPROC glad_glSecondaryColor3iv = NULL; 752 | PFNGLSECONDARYCOLOR3SPROC glad_glSecondaryColor3s = NULL; 753 | PFNGLSECONDARYCOLOR3SVPROC glad_glSecondaryColor3sv = NULL; 754 | PFNGLSECONDARYCOLOR3UBPROC glad_glSecondaryColor3ub = NULL; 755 | PFNGLSECONDARYCOLOR3UBVPROC glad_glSecondaryColor3ubv = NULL; 756 | PFNGLSECONDARYCOLOR3UIPROC glad_glSecondaryColor3ui = NULL; 757 | PFNGLSECONDARYCOLOR3UIVPROC glad_glSecondaryColor3uiv = NULL; 758 | PFNGLSECONDARYCOLOR3USPROC glad_glSecondaryColor3us = NULL; 759 | PFNGLSECONDARYCOLOR3USVPROC glad_glSecondaryColor3usv = NULL; 760 | PFNGLSECONDARYCOLORP3UIPROC glad_glSecondaryColorP3ui = NULL; 761 | PFNGLSECONDARYCOLORP3UIVPROC glad_glSecondaryColorP3uiv = NULL; 762 | PFNGLSECONDARYCOLORPOINTERPROC glad_glSecondaryColorPointer = NULL; 763 | PFNGLSELECTBUFFERPROC glad_glSelectBuffer = NULL; 764 | PFNGLSHADEMODELPROC glad_glShadeModel = NULL; 765 | PFNGLSHADERSOURCEPROC glad_glShaderSource = NULL; 766 | PFNGLSTENCILFUNCPROC glad_glStencilFunc = NULL; 767 | PFNGLSTENCILFUNCSEPARATEPROC glad_glStencilFuncSeparate = NULL; 768 | PFNGLSTENCILMASKPROC glad_glStencilMask = NULL; 769 | PFNGLSTENCILMASKSEPARATEPROC glad_glStencilMaskSeparate = NULL; 770 | PFNGLSTENCILOPPROC glad_glStencilOp = NULL; 771 | PFNGLSTENCILOPSEPARATEPROC glad_glStencilOpSeparate = NULL; 772 | PFNGLTEXBUFFERPROC glad_glTexBuffer = NULL; 773 | PFNGLTEXCOORD1DPROC glad_glTexCoord1d = NULL; 774 | PFNGLTEXCOORD1DVPROC glad_glTexCoord1dv = NULL; 775 | PFNGLTEXCOORD1FPROC glad_glTexCoord1f = NULL; 776 | PFNGLTEXCOORD1FVPROC glad_glTexCoord1fv = NULL; 777 | PFNGLTEXCOORD1IPROC glad_glTexCoord1i = NULL; 778 | PFNGLTEXCOORD1IVPROC glad_glTexCoord1iv = NULL; 779 | PFNGLTEXCOORD1SPROC glad_glTexCoord1s = NULL; 780 | PFNGLTEXCOORD1SVPROC glad_glTexCoord1sv = NULL; 781 | PFNGLTEXCOORD2DPROC glad_glTexCoord2d = NULL; 782 | PFNGLTEXCOORD2DVPROC glad_glTexCoord2dv = NULL; 783 | PFNGLTEXCOORD2FPROC glad_glTexCoord2f = NULL; 784 | PFNGLTEXCOORD2FVPROC glad_glTexCoord2fv = NULL; 785 | PFNGLTEXCOORD2IPROC glad_glTexCoord2i = NULL; 786 | PFNGLTEXCOORD2IVPROC glad_glTexCoord2iv = NULL; 787 | PFNGLTEXCOORD2SPROC glad_glTexCoord2s = NULL; 788 | PFNGLTEXCOORD2SVPROC glad_glTexCoord2sv = NULL; 789 | PFNGLTEXCOORD3DPROC glad_glTexCoord3d = NULL; 790 | PFNGLTEXCOORD3DVPROC glad_glTexCoord3dv = NULL; 791 | PFNGLTEXCOORD3FPROC glad_glTexCoord3f = NULL; 792 | PFNGLTEXCOORD3FVPROC glad_glTexCoord3fv = NULL; 793 | PFNGLTEXCOORD3IPROC glad_glTexCoord3i = NULL; 794 | PFNGLTEXCOORD3IVPROC glad_glTexCoord3iv = NULL; 795 | PFNGLTEXCOORD3SPROC glad_glTexCoord3s = NULL; 796 | PFNGLTEXCOORD3SVPROC glad_glTexCoord3sv = NULL; 797 | PFNGLTEXCOORD4DPROC glad_glTexCoord4d = NULL; 798 | PFNGLTEXCOORD4DVPROC glad_glTexCoord4dv = NULL; 799 | PFNGLTEXCOORD4FPROC glad_glTexCoord4f = NULL; 800 | PFNGLTEXCOORD4FVPROC glad_glTexCoord4fv = NULL; 801 | PFNGLTEXCOORD4IPROC glad_glTexCoord4i = NULL; 802 | PFNGLTEXCOORD4IVPROC glad_glTexCoord4iv = NULL; 803 | PFNGLTEXCOORD4SPROC glad_glTexCoord4s = NULL; 804 | PFNGLTEXCOORD4SVPROC glad_glTexCoord4sv = NULL; 805 | PFNGLTEXCOORDP1UIPROC glad_glTexCoordP1ui = NULL; 806 | PFNGLTEXCOORDP1UIVPROC glad_glTexCoordP1uiv = NULL; 807 | PFNGLTEXCOORDP2UIPROC glad_glTexCoordP2ui = NULL; 808 | PFNGLTEXCOORDP2UIVPROC glad_glTexCoordP2uiv = NULL; 809 | PFNGLTEXCOORDP3UIPROC glad_glTexCoordP3ui = NULL; 810 | PFNGLTEXCOORDP3UIVPROC glad_glTexCoordP3uiv = NULL; 811 | PFNGLTEXCOORDP4UIPROC glad_glTexCoordP4ui = NULL; 812 | PFNGLTEXCOORDP4UIVPROC glad_glTexCoordP4uiv = NULL; 813 | PFNGLTEXCOORDPOINTERPROC glad_glTexCoordPointer = NULL; 814 | PFNGLTEXENVFPROC glad_glTexEnvf = NULL; 815 | PFNGLTEXENVFVPROC glad_glTexEnvfv = NULL; 816 | PFNGLTEXENVIPROC glad_glTexEnvi = NULL; 817 | PFNGLTEXENVIVPROC glad_glTexEnviv = NULL; 818 | PFNGLTEXGENDPROC glad_glTexGend = NULL; 819 | PFNGLTEXGENDVPROC glad_glTexGendv = NULL; 820 | PFNGLTEXGENFPROC glad_glTexGenf = NULL; 821 | PFNGLTEXGENFVPROC glad_glTexGenfv = NULL; 822 | PFNGLTEXGENIPROC glad_glTexGeni = NULL; 823 | PFNGLTEXGENIVPROC glad_glTexGeniv = NULL; 824 | PFNGLTEXIMAGE1DPROC glad_glTexImage1D = NULL; 825 | PFNGLTEXIMAGE2DPROC glad_glTexImage2D = NULL; 826 | PFNGLTEXIMAGE2DMULTISAMPLEPROC glad_glTexImage2DMultisample = NULL; 827 | PFNGLTEXIMAGE3DPROC glad_glTexImage3D = NULL; 828 | PFNGLTEXIMAGE3DMULTISAMPLEPROC glad_glTexImage3DMultisample = NULL; 829 | PFNGLTEXPARAMETERIIVPROC glad_glTexParameterIiv = NULL; 830 | PFNGLTEXPARAMETERIUIVPROC glad_glTexParameterIuiv = NULL; 831 | PFNGLTEXPARAMETERFPROC glad_glTexParameterf = NULL; 832 | PFNGLTEXPARAMETERFVPROC glad_glTexParameterfv = NULL; 833 | PFNGLTEXPARAMETERIPROC glad_glTexParameteri = NULL; 834 | PFNGLTEXPARAMETERIVPROC glad_glTexParameteriv = NULL; 835 | PFNGLTEXSUBIMAGE1DPROC glad_glTexSubImage1D = NULL; 836 | PFNGLTEXSUBIMAGE2DPROC glad_glTexSubImage2D = NULL; 837 | PFNGLTEXSUBIMAGE3DPROC glad_glTexSubImage3D = NULL; 838 | PFNGLTRANSFORMFEEDBACKVARYINGSPROC glad_glTransformFeedbackVaryings = NULL; 839 | PFNGLTRANSLATEDPROC glad_glTranslated = NULL; 840 | PFNGLTRANSLATEFPROC glad_glTranslatef = NULL; 841 | PFNGLUNIFORM1FPROC glad_glUniform1f = NULL; 842 | PFNGLUNIFORM1FVPROC glad_glUniform1fv = NULL; 843 | PFNGLUNIFORM1IPROC glad_glUniform1i = NULL; 844 | PFNGLUNIFORM1IVPROC glad_glUniform1iv = NULL; 845 | PFNGLUNIFORM1UIPROC glad_glUniform1ui = NULL; 846 | PFNGLUNIFORM1UIVPROC glad_glUniform1uiv = NULL; 847 | PFNGLUNIFORM2FPROC glad_glUniform2f = NULL; 848 | PFNGLUNIFORM2FVPROC glad_glUniform2fv = NULL; 849 | PFNGLUNIFORM2IPROC glad_glUniform2i = NULL; 850 | PFNGLUNIFORM2IVPROC glad_glUniform2iv = NULL; 851 | PFNGLUNIFORM2UIPROC glad_glUniform2ui = NULL; 852 | PFNGLUNIFORM2UIVPROC glad_glUniform2uiv = NULL; 853 | PFNGLUNIFORM3FPROC glad_glUniform3f = NULL; 854 | PFNGLUNIFORM3FVPROC glad_glUniform3fv = NULL; 855 | PFNGLUNIFORM3IPROC glad_glUniform3i = NULL; 856 | PFNGLUNIFORM3IVPROC glad_glUniform3iv = NULL; 857 | PFNGLUNIFORM3UIPROC glad_glUniform3ui = NULL; 858 | PFNGLUNIFORM3UIVPROC glad_glUniform3uiv = NULL; 859 | PFNGLUNIFORM4FPROC glad_glUniform4f = NULL; 860 | PFNGLUNIFORM4FVPROC glad_glUniform4fv = NULL; 861 | PFNGLUNIFORM4IPROC glad_glUniform4i = NULL; 862 | PFNGLUNIFORM4IVPROC glad_glUniform4iv = NULL; 863 | PFNGLUNIFORM4UIPROC glad_glUniform4ui = NULL; 864 | PFNGLUNIFORM4UIVPROC glad_glUniform4uiv = NULL; 865 | PFNGLUNIFORMBLOCKBINDINGPROC glad_glUniformBlockBinding = NULL; 866 | PFNGLUNIFORMMATRIX2FVPROC glad_glUniformMatrix2fv = NULL; 867 | PFNGLUNIFORMMATRIX2X3FVPROC glad_glUniformMatrix2x3fv = NULL; 868 | PFNGLUNIFORMMATRIX2X4FVPROC glad_glUniformMatrix2x4fv = NULL; 869 | PFNGLUNIFORMMATRIX3FVPROC glad_glUniformMatrix3fv = NULL; 870 | PFNGLUNIFORMMATRIX3X2FVPROC glad_glUniformMatrix3x2fv = NULL; 871 | PFNGLUNIFORMMATRIX3X4FVPROC glad_glUniformMatrix3x4fv = NULL; 872 | PFNGLUNIFORMMATRIX4FVPROC glad_glUniformMatrix4fv = NULL; 873 | PFNGLUNIFORMMATRIX4X2FVPROC glad_glUniformMatrix4x2fv = NULL; 874 | PFNGLUNIFORMMATRIX4X3FVPROC glad_glUniformMatrix4x3fv = NULL; 875 | PFNGLUNMAPBUFFERPROC glad_glUnmapBuffer = NULL; 876 | PFNGLUSEPROGRAMPROC glad_glUseProgram = NULL; 877 | PFNGLVALIDATEPROGRAMPROC glad_glValidateProgram = NULL; 878 | PFNGLVERTEX2DPROC glad_glVertex2d = NULL; 879 | PFNGLVERTEX2DVPROC glad_glVertex2dv = NULL; 880 | PFNGLVERTEX2FPROC glad_glVertex2f = NULL; 881 | PFNGLVERTEX2FVPROC glad_glVertex2fv = NULL; 882 | PFNGLVERTEX2IPROC glad_glVertex2i = NULL; 883 | PFNGLVERTEX2IVPROC glad_glVertex2iv = NULL; 884 | PFNGLVERTEX2SPROC glad_glVertex2s = NULL; 885 | PFNGLVERTEX2SVPROC glad_glVertex2sv = NULL; 886 | PFNGLVERTEX3DPROC glad_glVertex3d = NULL; 887 | PFNGLVERTEX3DVPROC glad_glVertex3dv = NULL; 888 | PFNGLVERTEX3FPROC glad_glVertex3f = NULL; 889 | PFNGLVERTEX3FVPROC glad_glVertex3fv = NULL; 890 | PFNGLVERTEX3IPROC glad_glVertex3i = NULL; 891 | PFNGLVERTEX3IVPROC glad_glVertex3iv = NULL; 892 | PFNGLVERTEX3SPROC glad_glVertex3s = NULL; 893 | PFNGLVERTEX3SVPROC glad_glVertex3sv = NULL; 894 | PFNGLVERTEX4DPROC glad_glVertex4d = NULL; 895 | PFNGLVERTEX4DVPROC glad_glVertex4dv = NULL; 896 | PFNGLVERTEX4FPROC glad_glVertex4f = NULL; 897 | PFNGLVERTEX4FVPROC glad_glVertex4fv = NULL; 898 | PFNGLVERTEX4IPROC glad_glVertex4i = NULL; 899 | PFNGLVERTEX4IVPROC glad_glVertex4iv = NULL; 900 | PFNGLVERTEX4SPROC glad_glVertex4s = NULL; 901 | PFNGLVERTEX4SVPROC glad_glVertex4sv = NULL; 902 | PFNGLVERTEXATTRIB1DPROC glad_glVertexAttrib1d = NULL; 903 | PFNGLVERTEXATTRIB1DVPROC glad_glVertexAttrib1dv = NULL; 904 | PFNGLVERTEXATTRIB1FPROC glad_glVertexAttrib1f = NULL; 905 | PFNGLVERTEXATTRIB1FVPROC glad_glVertexAttrib1fv = NULL; 906 | PFNGLVERTEXATTRIB1SPROC glad_glVertexAttrib1s = NULL; 907 | PFNGLVERTEXATTRIB1SVPROC glad_glVertexAttrib1sv = NULL; 908 | PFNGLVERTEXATTRIB2DPROC glad_glVertexAttrib2d = NULL; 909 | PFNGLVERTEXATTRIB2DVPROC glad_glVertexAttrib2dv = NULL; 910 | PFNGLVERTEXATTRIB2FPROC glad_glVertexAttrib2f = NULL; 911 | PFNGLVERTEXATTRIB2FVPROC glad_glVertexAttrib2fv = NULL; 912 | PFNGLVERTEXATTRIB2SPROC glad_glVertexAttrib2s = NULL; 913 | PFNGLVERTEXATTRIB2SVPROC glad_glVertexAttrib2sv = NULL; 914 | PFNGLVERTEXATTRIB3DPROC glad_glVertexAttrib3d = NULL; 915 | PFNGLVERTEXATTRIB3DVPROC glad_glVertexAttrib3dv = NULL; 916 | PFNGLVERTEXATTRIB3FPROC glad_glVertexAttrib3f = NULL; 917 | PFNGLVERTEXATTRIB3FVPROC glad_glVertexAttrib3fv = NULL; 918 | PFNGLVERTEXATTRIB3SPROC glad_glVertexAttrib3s = NULL; 919 | PFNGLVERTEXATTRIB3SVPROC glad_glVertexAttrib3sv = NULL; 920 | PFNGLVERTEXATTRIB4NBVPROC glad_glVertexAttrib4Nbv = NULL; 921 | PFNGLVERTEXATTRIB4NIVPROC glad_glVertexAttrib4Niv = NULL; 922 | PFNGLVERTEXATTRIB4NSVPROC glad_glVertexAttrib4Nsv = NULL; 923 | PFNGLVERTEXATTRIB4NUBPROC glad_glVertexAttrib4Nub = NULL; 924 | PFNGLVERTEXATTRIB4NUBVPROC glad_glVertexAttrib4Nubv = NULL; 925 | PFNGLVERTEXATTRIB4NUIVPROC glad_glVertexAttrib4Nuiv = NULL; 926 | PFNGLVERTEXATTRIB4NUSVPROC glad_glVertexAttrib4Nusv = NULL; 927 | PFNGLVERTEXATTRIB4BVPROC glad_glVertexAttrib4bv = NULL; 928 | PFNGLVERTEXATTRIB4DPROC glad_glVertexAttrib4d = NULL; 929 | PFNGLVERTEXATTRIB4DVPROC glad_glVertexAttrib4dv = NULL; 930 | PFNGLVERTEXATTRIB4FPROC glad_glVertexAttrib4f = NULL; 931 | PFNGLVERTEXATTRIB4FVPROC glad_glVertexAttrib4fv = NULL; 932 | PFNGLVERTEXATTRIB4IVPROC glad_glVertexAttrib4iv = NULL; 933 | PFNGLVERTEXATTRIB4SPROC glad_glVertexAttrib4s = NULL; 934 | PFNGLVERTEXATTRIB4SVPROC glad_glVertexAttrib4sv = NULL; 935 | PFNGLVERTEXATTRIB4UBVPROC glad_glVertexAttrib4ubv = NULL; 936 | PFNGLVERTEXATTRIB4UIVPROC glad_glVertexAttrib4uiv = NULL; 937 | PFNGLVERTEXATTRIB4USVPROC glad_glVertexAttrib4usv = NULL; 938 | PFNGLVERTEXATTRIBDIVISORPROC glad_glVertexAttribDivisor = NULL; 939 | PFNGLVERTEXATTRIBI1IPROC glad_glVertexAttribI1i = NULL; 940 | PFNGLVERTEXATTRIBI1IVPROC glad_glVertexAttribI1iv = NULL; 941 | PFNGLVERTEXATTRIBI1UIPROC glad_glVertexAttribI1ui = NULL; 942 | PFNGLVERTEXATTRIBI1UIVPROC glad_glVertexAttribI1uiv = NULL; 943 | PFNGLVERTEXATTRIBI2IPROC glad_glVertexAttribI2i = NULL; 944 | PFNGLVERTEXATTRIBI2IVPROC glad_glVertexAttribI2iv = NULL; 945 | PFNGLVERTEXATTRIBI2UIPROC glad_glVertexAttribI2ui = NULL; 946 | PFNGLVERTEXATTRIBI2UIVPROC glad_glVertexAttribI2uiv = NULL; 947 | PFNGLVERTEXATTRIBI3IPROC glad_glVertexAttribI3i = NULL; 948 | PFNGLVERTEXATTRIBI3IVPROC glad_glVertexAttribI3iv = NULL; 949 | PFNGLVERTEXATTRIBI3UIPROC glad_glVertexAttribI3ui = NULL; 950 | PFNGLVERTEXATTRIBI3UIVPROC glad_glVertexAttribI3uiv = NULL; 951 | PFNGLVERTEXATTRIBI4BVPROC glad_glVertexAttribI4bv = NULL; 952 | PFNGLVERTEXATTRIBI4IPROC glad_glVertexAttribI4i = NULL; 953 | PFNGLVERTEXATTRIBI4IVPROC glad_glVertexAttribI4iv = NULL; 954 | PFNGLVERTEXATTRIBI4SVPROC glad_glVertexAttribI4sv = NULL; 955 | PFNGLVERTEXATTRIBI4UBVPROC glad_glVertexAttribI4ubv = NULL; 956 | PFNGLVERTEXATTRIBI4UIPROC glad_glVertexAttribI4ui = NULL; 957 | PFNGLVERTEXATTRIBI4UIVPROC glad_glVertexAttribI4uiv = NULL; 958 | PFNGLVERTEXATTRIBI4USVPROC glad_glVertexAttribI4usv = NULL; 959 | PFNGLVERTEXATTRIBIPOINTERPROC glad_glVertexAttribIPointer = NULL; 960 | PFNGLVERTEXATTRIBP1UIPROC glad_glVertexAttribP1ui = NULL; 961 | PFNGLVERTEXATTRIBP1UIVPROC glad_glVertexAttribP1uiv = NULL; 962 | PFNGLVERTEXATTRIBP2UIPROC glad_glVertexAttribP2ui = NULL; 963 | PFNGLVERTEXATTRIBP2UIVPROC glad_glVertexAttribP2uiv = NULL; 964 | PFNGLVERTEXATTRIBP3UIPROC glad_glVertexAttribP3ui = NULL; 965 | PFNGLVERTEXATTRIBP3UIVPROC glad_glVertexAttribP3uiv = NULL; 966 | PFNGLVERTEXATTRIBP4UIPROC glad_glVertexAttribP4ui = NULL; 967 | PFNGLVERTEXATTRIBP4UIVPROC glad_glVertexAttribP4uiv = NULL; 968 | PFNGLVERTEXATTRIBPOINTERPROC glad_glVertexAttribPointer = NULL; 969 | PFNGLVERTEXP2UIPROC glad_glVertexP2ui = NULL; 970 | PFNGLVERTEXP2UIVPROC glad_glVertexP2uiv = NULL; 971 | PFNGLVERTEXP3UIPROC glad_glVertexP3ui = NULL; 972 | PFNGLVERTEXP3UIVPROC glad_glVertexP3uiv = NULL; 973 | PFNGLVERTEXP4UIPROC glad_glVertexP4ui = NULL; 974 | PFNGLVERTEXP4UIVPROC glad_glVertexP4uiv = NULL; 975 | PFNGLVERTEXPOINTERPROC glad_glVertexPointer = NULL; 976 | PFNGLVIEWPORTPROC glad_glViewport = NULL; 977 | PFNGLWAITSYNCPROC glad_glWaitSync = NULL; 978 | PFNGLWINDOWPOS2DPROC glad_glWindowPos2d = NULL; 979 | PFNGLWINDOWPOS2DVPROC glad_glWindowPos2dv = NULL; 980 | PFNGLWINDOWPOS2FPROC glad_glWindowPos2f = NULL; 981 | PFNGLWINDOWPOS2FVPROC glad_glWindowPos2fv = NULL; 982 | PFNGLWINDOWPOS2IPROC glad_glWindowPos2i = NULL; 983 | PFNGLWINDOWPOS2IVPROC glad_glWindowPos2iv = NULL; 984 | PFNGLWINDOWPOS2SPROC glad_glWindowPos2s = NULL; 985 | PFNGLWINDOWPOS2SVPROC glad_glWindowPos2sv = NULL; 986 | PFNGLWINDOWPOS3DPROC glad_glWindowPos3d = NULL; 987 | PFNGLWINDOWPOS3DVPROC glad_glWindowPos3dv = NULL; 988 | PFNGLWINDOWPOS3FPROC glad_glWindowPos3f = NULL; 989 | PFNGLWINDOWPOS3FVPROC glad_glWindowPos3fv = NULL; 990 | PFNGLWINDOWPOS3IPROC glad_glWindowPos3i = NULL; 991 | PFNGLWINDOWPOS3IVPROC glad_glWindowPos3iv = NULL; 992 | PFNGLWINDOWPOS3SPROC glad_glWindowPos3s = NULL; 993 | PFNGLWINDOWPOS3SVPROC glad_glWindowPos3sv = NULL; 994 | static void load_GL_VERSION_1_0(GLADloadproc load) { 995 | if(!GLAD_GL_VERSION_1_0) return; 996 | glad_glCullFace = (PFNGLCULLFACEPROC)load("glCullFace"); 997 | glad_glFrontFace = (PFNGLFRONTFACEPROC)load("glFrontFace"); 998 | glad_glHint = (PFNGLHINTPROC)load("glHint"); 999 | glad_glLineWidth = (PFNGLLINEWIDTHPROC)load("glLineWidth"); 1000 | glad_glPointSize = (PFNGLPOINTSIZEPROC)load("glPointSize"); 1001 | glad_glPolygonMode = (PFNGLPOLYGONMODEPROC)load("glPolygonMode"); 1002 | glad_glScissor = (PFNGLSCISSORPROC)load("glScissor"); 1003 | glad_glTexParameterf = (PFNGLTEXPARAMETERFPROC)load("glTexParameterf"); 1004 | glad_glTexParameterfv = (PFNGLTEXPARAMETERFVPROC)load("glTexParameterfv"); 1005 | glad_glTexParameteri = (PFNGLTEXPARAMETERIPROC)load("glTexParameteri"); 1006 | glad_glTexParameteriv = (PFNGLTEXPARAMETERIVPROC)load("glTexParameteriv"); 1007 | glad_glTexImage1D = (PFNGLTEXIMAGE1DPROC)load("glTexImage1D"); 1008 | glad_glTexImage2D = (PFNGLTEXIMAGE2DPROC)load("glTexImage2D"); 1009 | glad_glDrawBuffer = (PFNGLDRAWBUFFERPROC)load("glDrawBuffer"); 1010 | glad_glClear = (PFNGLCLEARPROC)load("glClear"); 1011 | glad_glClearColor = (PFNGLCLEARCOLORPROC)load("glClearColor"); 1012 | glad_glClearStencil = (PFNGLCLEARSTENCILPROC)load("glClearStencil"); 1013 | glad_glClearDepth = (PFNGLCLEARDEPTHPROC)load("glClearDepth"); 1014 | glad_glStencilMask = (PFNGLSTENCILMASKPROC)load("glStencilMask"); 1015 | glad_glColorMask = (PFNGLCOLORMASKPROC)load("glColorMask"); 1016 | glad_glDepthMask = (PFNGLDEPTHMASKPROC)load("glDepthMask"); 1017 | glad_glDisable = (PFNGLDISABLEPROC)load("glDisable"); 1018 | glad_glEnable = (PFNGLENABLEPROC)load("glEnable"); 1019 | glad_glFinish = (PFNGLFINISHPROC)load("glFinish"); 1020 | glad_glFlush = (PFNGLFLUSHPROC)load("glFlush"); 1021 | glad_glBlendFunc = (PFNGLBLENDFUNCPROC)load("glBlendFunc"); 1022 | glad_glLogicOp = (PFNGLLOGICOPPROC)load("glLogicOp"); 1023 | glad_glStencilFunc = (PFNGLSTENCILFUNCPROC)load("glStencilFunc"); 1024 | glad_glStencilOp = (PFNGLSTENCILOPPROC)load("glStencilOp"); 1025 | glad_glDepthFunc = (PFNGLDEPTHFUNCPROC)load("glDepthFunc"); 1026 | glad_glPixelStoref = (PFNGLPIXELSTOREFPROC)load("glPixelStoref"); 1027 | glad_glPixelStorei = (PFNGLPIXELSTOREIPROC)load("glPixelStorei"); 1028 | glad_glReadBuffer = (PFNGLREADBUFFERPROC)load("glReadBuffer"); 1029 | glad_glReadPixels = (PFNGLREADPIXELSPROC)load("glReadPixels"); 1030 | glad_glGetBooleanv = (PFNGLGETBOOLEANVPROC)load("glGetBooleanv"); 1031 | glad_glGetDoublev = (PFNGLGETDOUBLEVPROC)load("glGetDoublev"); 1032 | glad_glGetError = (PFNGLGETERRORPROC)load("glGetError"); 1033 | glad_glGetFloatv = (PFNGLGETFLOATVPROC)load("glGetFloatv"); 1034 | glad_glGetIntegerv = (PFNGLGETINTEGERVPROC)load("glGetIntegerv"); 1035 | glad_glGetString = (PFNGLGETSTRINGPROC)load("glGetString"); 1036 | glad_glGetTexImage = (PFNGLGETTEXIMAGEPROC)load("glGetTexImage"); 1037 | glad_glGetTexParameterfv = (PFNGLGETTEXPARAMETERFVPROC)load("glGetTexParameterfv"); 1038 | glad_glGetTexParameteriv = (PFNGLGETTEXPARAMETERIVPROC)load("glGetTexParameteriv"); 1039 | glad_glGetTexLevelParameterfv = (PFNGLGETTEXLEVELPARAMETERFVPROC)load("glGetTexLevelParameterfv"); 1040 | glad_glGetTexLevelParameteriv = (PFNGLGETTEXLEVELPARAMETERIVPROC)load("glGetTexLevelParameteriv"); 1041 | glad_glIsEnabled = (PFNGLISENABLEDPROC)load("glIsEnabled"); 1042 | glad_glDepthRange = (PFNGLDEPTHRANGEPROC)load("glDepthRange"); 1043 | glad_glViewport = (PFNGLVIEWPORTPROC)load("glViewport"); 1044 | glad_glNewList = (PFNGLNEWLISTPROC)load("glNewList"); 1045 | glad_glEndList = (PFNGLENDLISTPROC)load("glEndList"); 1046 | glad_glCallList = (PFNGLCALLLISTPROC)load("glCallList"); 1047 | glad_glCallLists = (PFNGLCALLLISTSPROC)load("glCallLists"); 1048 | glad_glDeleteLists = (PFNGLDELETELISTSPROC)load("glDeleteLists"); 1049 | glad_glGenLists = (PFNGLGENLISTSPROC)load("glGenLists"); 1050 | glad_glListBase = (PFNGLLISTBASEPROC)load("glListBase"); 1051 | glad_glBegin = (PFNGLBEGINPROC)load("glBegin"); 1052 | glad_glBitmap = (PFNGLBITMAPPROC)load("glBitmap"); 1053 | glad_glColor3b = (PFNGLCOLOR3BPROC)load("glColor3b"); 1054 | glad_glColor3bv = (PFNGLCOLOR3BVPROC)load("glColor3bv"); 1055 | glad_glColor3d = (PFNGLCOLOR3DPROC)load("glColor3d"); 1056 | glad_glColor3dv = (PFNGLCOLOR3DVPROC)load("glColor3dv"); 1057 | glad_glColor3f = (PFNGLCOLOR3FPROC)load("glColor3f"); 1058 | glad_glColor3fv = (PFNGLCOLOR3FVPROC)load("glColor3fv"); 1059 | glad_glColor3i = (PFNGLCOLOR3IPROC)load("glColor3i"); 1060 | glad_glColor3iv = (PFNGLCOLOR3IVPROC)load("glColor3iv"); 1061 | glad_glColor3s = (PFNGLCOLOR3SPROC)load("glColor3s"); 1062 | glad_glColor3sv = (PFNGLCOLOR3SVPROC)load("glColor3sv"); 1063 | glad_glColor3ub = (PFNGLCOLOR3UBPROC)load("glColor3ub"); 1064 | glad_glColor3ubv = (PFNGLCOLOR3UBVPROC)load("glColor3ubv"); 1065 | glad_glColor3ui = (PFNGLCOLOR3UIPROC)load("glColor3ui"); 1066 | glad_glColor3uiv = (PFNGLCOLOR3UIVPROC)load("glColor3uiv"); 1067 | glad_glColor3us = (PFNGLCOLOR3USPROC)load("glColor3us"); 1068 | glad_glColor3usv = (PFNGLCOLOR3USVPROC)load("glColor3usv"); 1069 | glad_glColor4b = (PFNGLCOLOR4BPROC)load("glColor4b"); 1070 | glad_glColor4bv = (PFNGLCOLOR4BVPROC)load("glColor4bv"); 1071 | glad_glColor4d = (PFNGLCOLOR4DPROC)load("glColor4d"); 1072 | glad_glColor4dv = (PFNGLCOLOR4DVPROC)load("glColor4dv"); 1073 | glad_glColor4f = (PFNGLCOLOR4FPROC)load("glColor4f"); 1074 | glad_glColor4fv = (PFNGLCOLOR4FVPROC)load("glColor4fv"); 1075 | glad_glColor4i = (PFNGLCOLOR4IPROC)load("glColor4i"); 1076 | glad_glColor4iv = (PFNGLCOLOR4IVPROC)load("glColor4iv"); 1077 | glad_glColor4s = (PFNGLCOLOR4SPROC)load("glColor4s"); 1078 | glad_glColor4sv = (PFNGLCOLOR4SVPROC)load("glColor4sv"); 1079 | glad_glColor4ub = (PFNGLCOLOR4UBPROC)load("glColor4ub"); 1080 | glad_glColor4ubv = (PFNGLCOLOR4UBVPROC)load("glColor4ubv"); 1081 | glad_glColor4ui = (PFNGLCOLOR4UIPROC)load("glColor4ui"); 1082 | glad_glColor4uiv = (PFNGLCOLOR4UIVPROC)load("glColor4uiv"); 1083 | glad_glColor4us = (PFNGLCOLOR4USPROC)load("glColor4us"); 1084 | glad_glColor4usv = (PFNGLCOLOR4USVPROC)load("glColor4usv"); 1085 | glad_glEdgeFlag = (PFNGLEDGEFLAGPROC)load("glEdgeFlag"); 1086 | glad_glEdgeFlagv = (PFNGLEDGEFLAGVPROC)load("glEdgeFlagv"); 1087 | glad_glEnd = (PFNGLENDPROC)load("glEnd"); 1088 | glad_glIndexd = (PFNGLINDEXDPROC)load("glIndexd"); 1089 | glad_glIndexdv = (PFNGLINDEXDVPROC)load("glIndexdv"); 1090 | glad_glIndexf = (PFNGLINDEXFPROC)load("glIndexf"); 1091 | glad_glIndexfv = (PFNGLINDEXFVPROC)load("glIndexfv"); 1092 | glad_glIndexi = (PFNGLINDEXIPROC)load("glIndexi"); 1093 | glad_glIndexiv = (PFNGLINDEXIVPROC)load("glIndexiv"); 1094 | glad_glIndexs = (PFNGLINDEXSPROC)load("glIndexs"); 1095 | glad_glIndexsv = (PFNGLINDEXSVPROC)load("glIndexsv"); 1096 | glad_glNormal3b = (PFNGLNORMAL3BPROC)load("glNormal3b"); 1097 | glad_glNormal3bv = (PFNGLNORMAL3BVPROC)load("glNormal3bv"); 1098 | glad_glNormal3d = (PFNGLNORMAL3DPROC)load("glNormal3d"); 1099 | glad_glNormal3dv = (PFNGLNORMAL3DVPROC)load("glNormal3dv"); 1100 | glad_glNormal3f = (PFNGLNORMAL3FPROC)load("glNormal3f"); 1101 | glad_glNormal3fv = (PFNGLNORMAL3FVPROC)load("glNormal3fv"); 1102 | glad_glNormal3i = (PFNGLNORMAL3IPROC)load("glNormal3i"); 1103 | glad_glNormal3iv = (PFNGLNORMAL3IVPROC)load("glNormal3iv"); 1104 | glad_glNormal3s = (PFNGLNORMAL3SPROC)load("glNormal3s"); 1105 | glad_glNormal3sv = (PFNGLNORMAL3SVPROC)load("glNormal3sv"); 1106 | glad_glRasterPos2d = (PFNGLRASTERPOS2DPROC)load("glRasterPos2d"); 1107 | glad_glRasterPos2dv = (PFNGLRASTERPOS2DVPROC)load("glRasterPos2dv"); 1108 | glad_glRasterPos2f = (PFNGLRASTERPOS2FPROC)load("glRasterPos2f"); 1109 | glad_glRasterPos2fv = (PFNGLRASTERPOS2FVPROC)load("glRasterPos2fv"); 1110 | glad_glRasterPos2i = (PFNGLRASTERPOS2IPROC)load("glRasterPos2i"); 1111 | glad_glRasterPos2iv = (PFNGLRASTERPOS2IVPROC)load("glRasterPos2iv"); 1112 | glad_glRasterPos2s = (PFNGLRASTERPOS2SPROC)load("glRasterPos2s"); 1113 | glad_glRasterPos2sv = (PFNGLRASTERPOS2SVPROC)load("glRasterPos2sv"); 1114 | glad_glRasterPos3d = (PFNGLRASTERPOS3DPROC)load("glRasterPos3d"); 1115 | glad_glRasterPos3dv = (PFNGLRASTERPOS3DVPROC)load("glRasterPos3dv"); 1116 | glad_glRasterPos3f = (PFNGLRASTERPOS3FPROC)load("glRasterPos3f"); 1117 | glad_glRasterPos3fv = (PFNGLRASTERPOS3FVPROC)load("glRasterPos3fv"); 1118 | glad_glRasterPos3i = (PFNGLRASTERPOS3IPROC)load("glRasterPos3i"); 1119 | glad_glRasterPos3iv = (PFNGLRASTERPOS3IVPROC)load("glRasterPos3iv"); 1120 | glad_glRasterPos3s = (PFNGLRASTERPOS3SPROC)load("glRasterPos3s"); 1121 | glad_glRasterPos3sv = (PFNGLRASTERPOS3SVPROC)load("glRasterPos3sv"); 1122 | glad_glRasterPos4d = (PFNGLRASTERPOS4DPROC)load("glRasterPos4d"); 1123 | glad_glRasterPos4dv = (PFNGLRASTERPOS4DVPROC)load("glRasterPos4dv"); 1124 | glad_glRasterPos4f = (PFNGLRASTERPOS4FPROC)load("glRasterPos4f"); 1125 | glad_glRasterPos4fv = (PFNGLRASTERPOS4FVPROC)load("glRasterPos4fv"); 1126 | glad_glRasterPos4i = (PFNGLRASTERPOS4IPROC)load("glRasterPos4i"); 1127 | glad_glRasterPos4iv = (PFNGLRASTERPOS4IVPROC)load("glRasterPos4iv"); 1128 | glad_glRasterPos4s = (PFNGLRASTERPOS4SPROC)load("glRasterPos4s"); 1129 | glad_glRasterPos4sv = (PFNGLRASTERPOS4SVPROC)load("glRasterPos4sv"); 1130 | glad_glRectd = (PFNGLRECTDPROC)load("glRectd"); 1131 | glad_glRectdv = (PFNGLRECTDVPROC)load("glRectdv"); 1132 | glad_glRectf = (PFNGLRECTFPROC)load("glRectf"); 1133 | glad_glRectfv = (PFNGLRECTFVPROC)load("glRectfv"); 1134 | glad_glRecti = (PFNGLRECTIPROC)load("glRecti"); 1135 | glad_glRectiv = (PFNGLRECTIVPROC)load("glRectiv"); 1136 | glad_glRects = (PFNGLRECTSPROC)load("glRects"); 1137 | glad_glRectsv = (PFNGLRECTSVPROC)load("glRectsv"); 1138 | glad_glTexCoord1d = (PFNGLTEXCOORD1DPROC)load("glTexCoord1d"); 1139 | glad_glTexCoord1dv = (PFNGLTEXCOORD1DVPROC)load("glTexCoord1dv"); 1140 | glad_glTexCoord1f = (PFNGLTEXCOORD1FPROC)load("glTexCoord1f"); 1141 | glad_glTexCoord1fv = (PFNGLTEXCOORD1FVPROC)load("glTexCoord1fv"); 1142 | glad_glTexCoord1i = (PFNGLTEXCOORD1IPROC)load("glTexCoord1i"); 1143 | glad_glTexCoord1iv = (PFNGLTEXCOORD1IVPROC)load("glTexCoord1iv"); 1144 | glad_glTexCoord1s = (PFNGLTEXCOORD1SPROC)load("glTexCoord1s"); 1145 | glad_glTexCoord1sv = (PFNGLTEXCOORD1SVPROC)load("glTexCoord1sv"); 1146 | glad_glTexCoord2d = (PFNGLTEXCOORD2DPROC)load("glTexCoord2d"); 1147 | glad_glTexCoord2dv = (PFNGLTEXCOORD2DVPROC)load("glTexCoord2dv"); 1148 | glad_glTexCoord2f = (PFNGLTEXCOORD2FPROC)load("glTexCoord2f"); 1149 | glad_glTexCoord2fv = (PFNGLTEXCOORD2FVPROC)load("glTexCoord2fv"); 1150 | glad_glTexCoord2i = (PFNGLTEXCOORD2IPROC)load("glTexCoord2i"); 1151 | glad_glTexCoord2iv = (PFNGLTEXCOORD2IVPROC)load("glTexCoord2iv"); 1152 | glad_glTexCoord2s = (PFNGLTEXCOORD2SPROC)load("glTexCoord2s"); 1153 | glad_glTexCoord2sv = (PFNGLTEXCOORD2SVPROC)load("glTexCoord2sv"); 1154 | glad_glTexCoord3d = (PFNGLTEXCOORD3DPROC)load("glTexCoord3d"); 1155 | glad_glTexCoord3dv = (PFNGLTEXCOORD3DVPROC)load("glTexCoord3dv"); 1156 | glad_glTexCoord3f = (PFNGLTEXCOORD3FPROC)load("glTexCoord3f"); 1157 | glad_glTexCoord3fv = (PFNGLTEXCOORD3FVPROC)load("glTexCoord3fv"); 1158 | glad_glTexCoord3i = (PFNGLTEXCOORD3IPROC)load("glTexCoord3i"); 1159 | glad_glTexCoord3iv = (PFNGLTEXCOORD3IVPROC)load("glTexCoord3iv"); 1160 | glad_glTexCoord3s = (PFNGLTEXCOORD3SPROC)load("glTexCoord3s"); 1161 | glad_glTexCoord3sv = (PFNGLTEXCOORD3SVPROC)load("glTexCoord3sv"); 1162 | glad_glTexCoord4d = (PFNGLTEXCOORD4DPROC)load("glTexCoord4d"); 1163 | glad_glTexCoord4dv = (PFNGLTEXCOORD4DVPROC)load("glTexCoord4dv"); 1164 | glad_glTexCoord4f = (PFNGLTEXCOORD4FPROC)load("glTexCoord4f"); 1165 | glad_glTexCoord4fv = (PFNGLTEXCOORD4FVPROC)load("glTexCoord4fv"); 1166 | glad_glTexCoord4i = (PFNGLTEXCOORD4IPROC)load("glTexCoord4i"); 1167 | glad_glTexCoord4iv = (PFNGLTEXCOORD4IVPROC)load("glTexCoord4iv"); 1168 | glad_glTexCoord4s = (PFNGLTEXCOORD4SPROC)load("glTexCoord4s"); 1169 | glad_glTexCoord4sv = (PFNGLTEXCOORD4SVPROC)load("glTexCoord4sv"); 1170 | glad_glVertex2d = (PFNGLVERTEX2DPROC)load("glVertex2d"); 1171 | glad_glVertex2dv = (PFNGLVERTEX2DVPROC)load("glVertex2dv"); 1172 | glad_glVertex2f = (PFNGLVERTEX2FPROC)load("glVertex2f"); 1173 | glad_glVertex2fv = (PFNGLVERTEX2FVPROC)load("glVertex2fv"); 1174 | glad_glVertex2i = (PFNGLVERTEX2IPROC)load("glVertex2i"); 1175 | glad_glVertex2iv = (PFNGLVERTEX2IVPROC)load("glVertex2iv"); 1176 | glad_glVertex2s = (PFNGLVERTEX2SPROC)load("glVertex2s"); 1177 | glad_glVertex2sv = (PFNGLVERTEX2SVPROC)load("glVertex2sv"); 1178 | glad_glVertex3d = (PFNGLVERTEX3DPROC)load("glVertex3d"); 1179 | glad_glVertex3dv = (PFNGLVERTEX3DVPROC)load("glVertex3dv"); 1180 | glad_glVertex3f = (PFNGLVERTEX3FPROC)load("glVertex3f"); 1181 | glad_glVertex3fv = (PFNGLVERTEX3FVPROC)load("glVertex3fv"); 1182 | glad_glVertex3i = (PFNGLVERTEX3IPROC)load("glVertex3i"); 1183 | glad_glVertex3iv = (PFNGLVERTEX3IVPROC)load("glVertex3iv"); 1184 | glad_glVertex3s = (PFNGLVERTEX3SPROC)load("glVertex3s"); 1185 | glad_glVertex3sv = (PFNGLVERTEX3SVPROC)load("glVertex3sv"); 1186 | glad_glVertex4d = (PFNGLVERTEX4DPROC)load("glVertex4d"); 1187 | glad_glVertex4dv = (PFNGLVERTEX4DVPROC)load("glVertex4dv"); 1188 | glad_glVertex4f = (PFNGLVERTEX4FPROC)load("glVertex4f"); 1189 | glad_glVertex4fv = (PFNGLVERTEX4FVPROC)load("glVertex4fv"); 1190 | glad_glVertex4i = (PFNGLVERTEX4IPROC)load("glVertex4i"); 1191 | glad_glVertex4iv = (PFNGLVERTEX4IVPROC)load("glVertex4iv"); 1192 | glad_glVertex4s = (PFNGLVERTEX4SPROC)load("glVertex4s"); 1193 | glad_glVertex4sv = (PFNGLVERTEX4SVPROC)load("glVertex4sv"); 1194 | glad_glClipPlane = (PFNGLCLIPPLANEPROC)load("glClipPlane"); 1195 | glad_glColorMaterial = (PFNGLCOLORMATERIALPROC)load("glColorMaterial"); 1196 | glad_glFogf = (PFNGLFOGFPROC)load("glFogf"); 1197 | glad_glFogfv = (PFNGLFOGFVPROC)load("glFogfv"); 1198 | glad_glFogi = (PFNGLFOGIPROC)load("glFogi"); 1199 | glad_glFogiv = (PFNGLFOGIVPROC)load("glFogiv"); 1200 | glad_glLightf = (PFNGLLIGHTFPROC)load("glLightf"); 1201 | glad_glLightfv = (PFNGLLIGHTFVPROC)load("glLightfv"); 1202 | glad_glLighti = (PFNGLLIGHTIPROC)load("glLighti"); 1203 | glad_glLightiv = (PFNGLLIGHTIVPROC)load("glLightiv"); 1204 | glad_glLightModelf = (PFNGLLIGHTMODELFPROC)load("glLightModelf"); 1205 | glad_glLightModelfv = (PFNGLLIGHTMODELFVPROC)load("glLightModelfv"); 1206 | glad_glLightModeli = (PFNGLLIGHTMODELIPROC)load("glLightModeli"); 1207 | glad_glLightModeliv = (PFNGLLIGHTMODELIVPROC)load("glLightModeliv"); 1208 | glad_glLineStipple = (PFNGLLINESTIPPLEPROC)load("glLineStipple"); 1209 | glad_glMaterialf = (PFNGLMATERIALFPROC)load("glMaterialf"); 1210 | glad_glMaterialfv = (PFNGLMATERIALFVPROC)load("glMaterialfv"); 1211 | glad_glMateriali = (PFNGLMATERIALIPROC)load("glMateriali"); 1212 | glad_glMaterialiv = (PFNGLMATERIALIVPROC)load("glMaterialiv"); 1213 | glad_glPolygonStipple = (PFNGLPOLYGONSTIPPLEPROC)load("glPolygonStipple"); 1214 | glad_glShadeModel = (PFNGLSHADEMODELPROC)load("glShadeModel"); 1215 | glad_glTexEnvf = (PFNGLTEXENVFPROC)load("glTexEnvf"); 1216 | glad_glTexEnvfv = (PFNGLTEXENVFVPROC)load("glTexEnvfv"); 1217 | glad_glTexEnvi = (PFNGLTEXENVIPROC)load("glTexEnvi"); 1218 | glad_glTexEnviv = (PFNGLTEXENVIVPROC)load("glTexEnviv"); 1219 | glad_glTexGend = (PFNGLTEXGENDPROC)load("glTexGend"); 1220 | glad_glTexGendv = (PFNGLTEXGENDVPROC)load("glTexGendv"); 1221 | glad_glTexGenf = (PFNGLTEXGENFPROC)load("glTexGenf"); 1222 | glad_glTexGenfv = (PFNGLTEXGENFVPROC)load("glTexGenfv"); 1223 | glad_glTexGeni = (PFNGLTEXGENIPROC)load("glTexGeni"); 1224 | glad_glTexGeniv = (PFNGLTEXGENIVPROC)load("glTexGeniv"); 1225 | glad_glFeedbackBuffer = (PFNGLFEEDBACKBUFFERPROC)load("glFeedbackBuffer"); 1226 | glad_glSelectBuffer = (PFNGLSELECTBUFFERPROC)load("glSelectBuffer"); 1227 | glad_glRenderMode = (PFNGLRENDERMODEPROC)load("glRenderMode"); 1228 | glad_glInitNames = (PFNGLINITNAMESPROC)load("glInitNames"); 1229 | glad_glLoadName = (PFNGLLOADNAMEPROC)load("glLoadName"); 1230 | glad_glPassThrough = (PFNGLPASSTHROUGHPROC)load("glPassThrough"); 1231 | glad_glPopName = (PFNGLPOPNAMEPROC)load("glPopName"); 1232 | glad_glPushName = (PFNGLPUSHNAMEPROC)load("glPushName"); 1233 | glad_glClearAccum = (PFNGLCLEARACCUMPROC)load("glClearAccum"); 1234 | glad_glClearIndex = (PFNGLCLEARINDEXPROC)load("glClearIndex"); 1235 | glad_glIndexMask = (PFNGLINDEXMASKPROC)load("glIndexMask"); 1236 | glad_glAccum = (PFNGLACCUMPROC)load("glAccum"); 1237 | glad_glPopAttrib = (PFNGLPOPATTRIBPROC)load("glPopAttrib"); 1238 | glad_glPushAttrib = (PFNGLPUSHATTRIBPROC)load("glPushAttrib"); 1239 | glad_glMap1d = (PFNGLMAP1DPROC)load("glMap1d"); 1240 | glad_glMap1f = (PFNGLMAP1FPROC)load("glMap1f"); 1241 | glad_glMap2d = (PFNGLMAP2DPROC)load("glMap2d"); 1242 | glad_glMap2f = (PFNGLMAP2FPROC)load("glMap2f"); 1243 | glad_glMapGrid1d = (PFNGLMAPGRID1DPROC)load("glMapGrid1d"); 1244 | glad_glMapGrid1f = (PFNGLMAPGRID1FPROC)load("glMapGrid1f"); 1245 | glad_glMapGrid2d = (PFNGLMAPGRID2DPROC)load("glMapGrid2d"); 1246 | glad_glMapGrid2f = (PFNGLMAPGRID2FPROC)load("glMapGrid2f"); 1247 | glad_glEvalCoord1d = (PFNGLEVALCOORD1DPROC)load("glEvalCoord1d"); 1248 | glad_glEvalCoord1dv = (PFNGLEVALCOORD1DVPROC)load("glEvalCoord1dv"); 1249 | glad_glEvalCoord1f = (PFNGLEVALCOORD1FPROC)load("glEvalCoord1f"); 1250 | glad_glEvalCoord1fv = (PFNGLEVALCOORD1FVPROC)load("glEvalCoord1fv"); 1251 | glad_glEvalCoord2d = (PFNGLEVALCOORD2DPROC)load("glEvalCoord2d"); 1252 | glad_glEvalCoord2dv = (PFNGLEVALCOORD2DVPROC)load("glEvalCoord2dv"); 1253 | glad_glEvalCoord2f = (PFNGLEVALCOORD2FPROC)load("glEvalCoord2f"); 1254 | glad_glEvalCoord2fv = (PFNGLEVALCOORD2FVPROC)load("glEvalCoord2fv"); 1255 | glad_glEvalMesh1 = (PFNGLEVALMESH1PROC)load("glEvalMesh1"); 1256 | glad_glEvalPoint1 = (PFNGLEVALPOINT1PROC)load("glEvalPoint1"); 1257 | glad_glEvalMesh2 = (PFNGLEVALMESH2PROC)load("glEvalMesh2"); 1258 | glad_glEvalPoint2 = (PFNGLEVALPOINT2PROC)load("glEvalPoint2"); 1259 | glad_glAlphaFunc = (PFNGLALPHAFUNCPROC)load("glAlphaFunc"); 1260 | glad_glPixelZoom = (PFNGLPIXELZOOMPROC)load("glPixelZoom"); 1261 | glad_glPixelTransferf = (PFNGLPIXELTRANSFERFPROC)load("glPixelTransferf"); 1262 | glad_glPixelTransferi = (PFNGLPIXELTRANSFERIPROC)load("glPixelTransferi"); 1263 | glad_glPixelMapfv = (PFNGLPIXELMAPFVPROC)load("glPixelMapfv"); 1264 | glad_glPixelMapuiv = (PFNGLPIXELMAPUIVPROC)load("glPixelMapuiv"); 1265 | glad_glPixelMapusv = (PFNGLPIXELMAPUSVPROC)load("glPixelMapusv"); 1266 | glad_glCopyPixels = (PFNGLCOPYPIXELSPROC)load("glCopyPixels"); 1267 | glad_glDrawPixels = (PFNGLDRAWPIXELSPROC)load("glDrawPixels"); 1268 | glad_glGetClipPlane = (PFNGLGETCLIPPLANEPROC)load("glGetClipPlane"); 1269 | glad_glGetLightfv = (PFNGLGETLIGHTFVPROC)load("glGetLightfv"); 1270 | glad_glGetLightiv = (PFNGLGETLIGHTIVPROC)load("glGetLightiv"); 1271 | glad_glGetMapdv = (PFNGLGETMAPDVPROC)load("glGetMapdv"); 1272 | glad_glGetMapfv = (PFNGLGETMAPFVPROC)load("glGetMapfv"); 1273 | glad_glGetMapiv = (PFNGLGETMAPIVPROC)load("glGetMapiv"); 1274 | glad_glGetMaterialfv = (PFNGLGETMATERIALFVPROC)load("glGetMaterialfv"); 1275 | glad_glGetMaterialiv = (PFNGLGETMATERIALIVPROC)load("glGetMaterialiv"); 1276 | glad_glGetPixelMapfv = (PFNGLGETPIXELMAPFVPROC)load("glGetPixelMapfv"); 1277 | glad_glGetPixelMapuiv = (PFNGLGETPIXELMAPUIVPROC)load("glGetPixelMapuiv"); 1278 | glad_glGetPixelMapusv = (PFNGLGETPIXELMAPUSVPROC)load("glGetPixelMapusv"); 1279 | glad_glGetPolygonStipple = (PFNGLGETPOLYGONSTIPPLEPROC)load("glGetPolygonStipple"); 1280 | glad_glGetTexEnvfv = (PFNGLGETTEXENVFVPROC)load("glGetTexEnvfv"); 1281 | glad_glGetTexEnviv = (PFNGLGETTEXENVIVPROC)load("glGetTexEnviv"); 1282 | glad_glGetTexGendv = (PFNGLGETTEXGENDVPROC)load("glGetTexGendv"); 1283 | glad_glGetTexGenfv = (PFNGLGETTEXGENFVPROC)load("glGetTexGenfv"); 1284 | glad_glGetTexGeniv = (PFNGLGETTEXGENIVPROC)load("glGetTexGeniv"); 1285 | glad_glIsList = (PFNGLISLISTPROC)load("glIsList"); 1286 | glad_glFrustum = (PFNGLFRUSTUMPROC)load("glFrustum"); 1287 | glad_glLoadIdentity = (PFNGLLOADIDENTITYPROC)load("glLoadIdentity"); 1288 | glad_glLoadMatrixf = (PFNGLLOADMATRIXFPROC)load("glLoadMatrixf"); 1289 | glad_glLoadMatrixd = (PFNGLLOADMATRIXDPROC)load("glLoadMatrixd"); 1290 | glad_glMatrixMode = (PFNGLMATRIXMODEPROC)load("glMatrixMode"); 1291 | glad_glMultMatrixf = (PFNGLMULTMATRIXFPROC)load("glMultMatrixf"); 1292 | glad_glMultMatrixd = (PFNGLMULTMATRIXDPROC)load("glMultMatrixd"); 1293 | glad_glOrtho = (PFNGLORTHOPROC)load("glOrtho"); 1294 | glad_glPopMatrix = (PFNGLPOPMATRIXPROC)load("glPopMatrix"); 1295 | glad_glPushMatrix = (PFNGLPUSHMATRIXPROC)load("glPushMatrix"); 1296 | glad_glRotated = (PFNGLROTATEDPROC)load("glRotated"); 1297 | glad_glRotatef = (PFNGLROTATEFPROC)load("glRotatef"); 1298 | glad_glScaled = (PFNGLSCALEDPROC)load("glScaled"); 1299 | glad_glScalef = (PFNGLSCALEFPROC)load("glScalef"); 1300 | glad_glTranslated = (PFNGLTRANSLATEDPROC)load("glTranslated"); 1301 | glad_glTranslatef = (PFNGLTRANSLATEFPROC)load("glTranslatef"); 1302 | } 1303 | static void load_GL_VERSION_1_1(GLADloadproc load) { 1304 | if(!GLAD_GL_VERSION_1_1) return; 1305 | glad_glDrawArrays = (PFNGLDRAWARRAYSPROC)load("glDrawArrays"); 1306 | glad_glDrawElements = (PFNGLDRAWELEMENTSPROC)load("glDrawElements"); 1307 | glad_glGetPointerv = (PFNGLGETPOINTERVPROC)load("glGetPointerv"); 1308 | glad_glPolygonOffset = (PFNGLPOLYGONOFFSETPROC)load("glPolygonOffset"); 1309 | glad_glCopyTexImage1D = (PFNGLCOPYTEXIMAGE1DPROC)load("glCopyTexImage1D"); 1310 | glad_glCopyTexImage2D = (PFNGLCOPYTEXIMAGE2DPROC)load("glCopyTexImage2D"); 1311 | glad_glCopyTexSubImage1D = (PFNGLCOPYTEXSUBIMAGE1DPROC)load("glCopyTexSubImage1D"); 1312 | glad_glCopyTexSubImage2D = (PFNGLCOPYTEXSUBIMAGE2DPROC)load("glCopyTexSubImage2D"); 1313 | glad_glTexSubImage1D = (PFNGLTEXSUBIMAGE1DPROC)load("glTexSubImage1D"); 1314 | glad_glTexSubImage2D = (PFNGLTEXSUBIMAGE2DPROC)load("glTexSubImage2D"); 1315 | glad_glBindTexture = (PFNGLBINDTEXTUREPROC)load("glBindTexture"); 1316 | glad_glDeleteTextures = (PFNGLDELETETEXTURESPROC)load("glDeleteTextures"); 1317 | glad_glGenTextures = (PFNGLGENTEXTURESPROC)load("glGenTextures"); 1318 | glad_glIsTexture = (PFNGLISTEXTUREPROC)load("glIsTexture"); 1319 | glad_glArrayElement = (PFNGLARRAYELEMENTPROC)load("glArrayElement"); 1320 | glad_glColorPointer = (PFNGLCOLORPOINTERPROC)load("glColorPointer"); 1321 | glad_glDisableClientState = (PFNGLDISABLECLIENTSTATEPROC)load("glDisableClientState"); 1322 | glad_glEdgeFlagPointer = (PFNGLEDGEFLAGPOINTERPROC)load("glEdgeFlagPointer"); 1323 | glad_glEnableClientState = (PFNGLENABLECLIENTSTATEPROC)load("glEnableClientState"); 1324 | glad_glIndexPointer = (PFNGLINDEXPOINTERPROC)load("glIndexPointer"); 1325 | glad_glInterleavedArrays = (PFNGLINTERLEAVEDARRAYSPROC)load("glInterleavedArrays"); 1326 | glad_glNormalPointer = (PFNGLNORMALPOINTERPROC)load("glNormalPointer"); 1327 | glad_glTexCoordPointer = (PFNGLTEXCOORDPOINTERPROC)load("glTexCoordPointer"); 1328 | glad_glVertexPointer = (PFNGLVERTEXPOINTERPROC)load("glVertexPointer"); 1329 | glad_glAreTexturesResident = (PFNGLARETEXTURESRESIDENTPROC)load("glAreTexturesResident"); 1330 | glad_glPrioritizeTextures = (PFNGLPRIORITIZETEXTURESPROC)load("glPrioritizeTextures"); 1331 | glad_glIndexub = (PFNGLINDEXUBPROC)load("glIndexub"); 1332 | glad_glIndexubv = (PFNGLINDEXUBVPROC)load("glIndexubv"); 1333 | glad_glPopClientAttrib = (PFNGLPOPCLIENTATTRIBPROC)load("glPopClientAttrib"); 1334 | glad_glPushClientAttrib = (PFNGLPUSHCLIENTATTRIBPROC)load("glPushClientAttrib"); 1335 | } 1336 | static void load_GL_VERSION_1_2(GLADloadproc load) { 1337 | if(!GLAD_GL_VERSION_1_2) return; 1338 | glad_glDrawRangeElements = (PFNGLDRAWRANGEELEMENTSPROC)load("glDrawRangeElements"); 1339 | glad_glTexImage3D = (PFNGLTEXIMAGE3DPROC)load("glTexImage3D"); 1340 | glad_glTexSubImage3D = (PFNGLTEXSUBIMAGE3DPROC)load("glTexSubImage3D"); 1341 | glad_glCopyTexSubImage3D = (PFNGLCOPYTEXSUBIMAGE3DPROC)load("glCopyTexSubImage3D"); 1342 | } 1343 | static void load_GL_VERSION_1_3(GLADloadproc load) { 1344 | if(!GLAD_GL_VERSION_1_3) return; 1345 | glad_glActiveTexture = (PFNGLACTIVETEXTUREPROC)load("glActiveTexture"); 1346 | glad_glSampleCoverage = (PFNGLSAMPLECOVERAGEPROC)load("glSampleCoverage"); 1347 | glad_glCompressedTexImage3D = (PFNGLCOMPRESSEDTEXIMAGE3DPROC)load("glCompressedTexImage3D"); 1348 | glad_glCompressedTexImage2D = (PFNGLCOMPRESSEDTEXIMAGE2DPROC)load("glCompressedTexImage2D"); 1349 | glad_glCompressedTexImage1D = (PFNGLCOMPRESSEDTEXIMAGE1DPROC)load("glCompressedTexImage1D"); 1350 | glad_glCompressedTexSubImage3D = (PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC)load("glCompressedTexSubImage3D"); 1351 | glad_glCompressedTexSubImage2D = (PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC)load("glCompressedTexSubImage2D"); 1352 | glad_glCompressedTexSubImage1D = (PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC)load("glCompressedTexSubImage1D"); 1353 | glad_glGetCompressedTexImage = (PFNGLGETCOMPRESSEDTEXIMAGEPROC)load("glGetCompressedTexImage"); 1354 | glad_glClientActiveTexture = (PFNGLCLIENTACTIVETEXTUREPROC)load("glClientActiveTexture"); 1355 | glad_glMultiTexCoord1d = (PFNGLMULTITEXCOORD1DPROC)load("glMultiTexCoord1d"); 1356 | glad_glMultiTexCoord1dv = (PFNGLMULTITEXCOORD1DVPROC)load("glMultiTexCoord1dv"); 1357 | glad_glMultiTexCoord1f = (PFNGLMULTITEXCOORD1FPROC)load("glMultiTexCoord1f"); 1358 | glad_glMultiTexCoord1fv = (PFNGLMULTITEXCOORD1FVPROC)load("glMultiTexCoord1fv"); 1359 | glad_glMultiTexCoord1i = (PFNGLMULTITEXCOORD1IPROC)load("glMultiTexCoord1i"); 1360 | glad_glMultiTexCoord1iv = (PFNGLMULTITEXCOORD1IVPROC)load("glMultiTexCoord1iv"); 1361 | glad_glMultiTexCoord1s = (PFNGLMULTITEXCOORD1SPROC)load("glMultiTexCoord1s"); 1362 | glad_glMultiTexCoord1sv = (PFNGLMULTITEXCOORD1SVPROC)load("glMultiTexCoord1sv"); 1363 | glad_glMultiTexCoord2d = (PFNGLMULTITEXCOORD2DPROC)load("glMultiTexCoord2d"); 1364 | glad_glMultiTexCoord2dv = (PFNGLMULTITEXCOORD2DVPROC)load("glMultiTexCoord2dv"); 1365 | glad_glMultiTexCoord2f = (PFNGLMULTITEXCOORD2FPROC)load("glMultiTexCoord2f"); 1366 | glad_glMultiTexCoord2fv = (PFNGLMULTITEXCOORD2FVPROC)load("glMultiTexCoord2fv"); 1367 | glad_glMultiTexCoord2i = (PFNGLMULTITEXCOORD2IPROC)load("glMultiTexCoord2i"); 1368 | glad_glMultiTexCoord2iv = (PFNGLMULTITEXCOORD2IVPROC)load("glMultiTexCoord2iv"); 1369 | glad_glMultiTexCoord2s = (PFNGLMULTITEXCOORD2SPROC)load("glMultiTexCoord2s"); 1370 | glad_glMultiTexCoord2sv = (PFNGLMULTITEXCOORD2SVPROC)load("glMultiTexCoord2sv"); 1371 | glad_glMultiTexCoord3d = (PFNGLMULTITEXCOORD3DPROC)load("glMultiTexCoord3d"); 1372 | glad_glMultiTexCoord3dv = (PFNGLMULTITEXCOORD3DVPROC)load("glMultiTexCoord3dv"); 1373 | glad_glMultiTexCoord3f = (PFNGLMULTITEXCOORD3FPROC)load("glMultiTexCoord3f"); 1374 | glad_glMultiTexCoord3fv = (PFNGLMULTITEXCOORD3FVPROC)load("glMultiTexCoord3fv"); 1375 | glad_glMultiTexCoord3i = (PFNGLMULTITEXCOORD3IPROC)load("glMultiTexCoord3i"); 1376 | glad_glMultiTexCoord3iv = (PFNGLMULTITEXCOORD3IVPROC)load("glMultiTexCoord3iv"); 1377 | glad_glMultiTexCoord3s = (PFNGLMULTITEXCOORD3SPROC)load("glMultiTexCoord3s"); 1378 | glad_glMultiTexCoord3sv = (PFNGLMULTITEXCOORD3SVPROC)load("glMultiTexCoord3sv"); 1379 | glad_glMultiTexCoord4d = (PFNGLMULTITEXCOORD4DPROC)load("glMultiTexCoord4d"); 1380 | glad_glMultiTexCoord4dv = (PFNGLMULTITEXCOORD4DVPROC)load("glMultiTexCoord4dv"); 1381 | glad_glMultiTexCoord4f = (PFNGLMULTITEXCOORD4FPROC)load("glMultiTexCoord4f"); 1382 | glad_glMultiTexCoord4fv = (PFNGLMULTITEXCOORD4FVPROC)load("glMultiTexCoord4fv"); 1383 | glad_glMultiTexCoord4i = (PFNGLMULTITEXCOORD4IPROC)load("glMultiTexCoord4i"); 1384 | glad_glMultiTexCoord4iv = (PFNGLMULTITEXCOORD4IVPROC)load("glMultiTexCoord4iv"); 1385 | glad_glMultiTexCoord4s = (PFNGLMULTITEXCOORD4SPROC)load("glMultiTexCoord4s"); 1386 | glad_glMultiTexCoord4sv = (PFNGLMULTITEXCOORD4SVPROC)load("glMultiTexCoord4sv"); 1387 | glad_glLoadTransposeMatrixf = (PFNGLLOADTRANSPOSEMATRIXFPROC)load("glLoadTransposeMatrixf"); 1388 | glad_glLoadTransposeMatrixd = (PFNGLLOADTRANSPOSEMATRIXDPROC)load("glLoadTransposeMatrixd"); 1389 | glad_glMultTransposeMatrixf = (PFNGLMULTTRANSPOSEMATRIXFPROC)load("glMultTransposeMatrixf"); 1390 | glad_glMultTransposeMatrixd = (PFNGLMULTTRANSPOSEMATRIXDPROC)load("glMultTransposeMatrixd"); 1391 | } 1392 | static void load_GL_VERSION_1_4(GLADloadproc load) { 1393 | if(!GLAD_GL_VERSION_1_4) return; 1394 | glad_glBlendFuncSeparate = (PFNGLBLENDFUNCSEPARATEPROC)load("glBlendFuncSeparate"); 1395 | glad_glMultiDrawArrays = (PFNGLMULTIDRAWARRAYSPROC)load("glMultiDrawArrays"); 1396 | glad_glMultiDrawElements = (PFNGLMULTIDRAWELEMENTSPROC)load("glMultiDrawElements"); 1397 | glad_glPointParameterf = (PFNGLPOINTPARAMETERFPROC)load("glPointParameterf"); 1398 | glad_glPointParameterfv = (PFNGLPOINTPARAMETERFVPROC)load("glPointParameterfv"); 1399 | glad_glPointParameteri = (PFNGLPOINTPARAMETERIPROC)load("glPointParameteri"); 1400 | glad_glPointParameteriv = (PFNGLPOINTPARAMETERIVPROC)load("glPointParameteriv"); 1401 | glad_glFogCoordf = (PFNGLFOGCOORDFPROC)load("glFogCoordf"); 1402 | glad_glFogCoordfv = (PFNGLFOGCOORDFVPROC)load("glFogCoordfv"); 1403 | glad_glFogCoordd = (PFNGLFOGCOORDDPROC)load("glFogCoordd"); 1404 | glad_glFogCoorddv = (PFNGLFOGCOORDDVPROC)load("glFogCoorddv"); 1405 | glad_glFogCoordPointer = (PFNGLFOGCOORDPOINTERPROC)load("glFogCoordPointer"); 1406 | glad_glSecondaryColor3b = (PFNGLSECONDARYCOLOR3BPROC)load("glSecondaryColor3b"); 1407 | glad_glSecondaryColor3bv = (PFNGLSECONDARYCOLOR3BVPROC)load("glSecondaryColor3bv"); 1408 | glad_glSecondaryColor3d = (PFNGLSECONDARYCOLOR3DPROC)load("glSecondaryColor3d"); 1409 | glad_glSecondaryColor3dv = (PFNGLSECONDARYCOLOR3DVPROC)load("glSecondaryColor3dv"); 1410 | glad_glSecondaryColor3f = (PFNGLSECONDARYCOLOR3FPROC)load("glSecondaryColor3f"); 1411 | glad_glSecondaryColor3fv = (PFNGLSECONDARYCOLOR3FVPROC)load("glSecondaryColor3fv"); 1412 | glad_glSecondaryColor3i = (PFNGLSECONDARYCOLOR3IPROC)load("glSecondaryColor3i"); 1413 | glad_glSecondaryColor3iv = (PFNGLSECONDARYCOLOR3IVPROC)load("glSecondaryColor3iv"); 1414 | glad_glSecondaryColor3s = (PFNGLSECONDARYCOLOR3SPROC)load("glSecondaryColor3s"); 1415 | glad_glSecondaryColor3sv = (PFNGLSECONDARYCOLOR3SVPROC)load("glSecondaryColor3sv"); 1416 | glad_glSecondaryColor3ub = (PFNGLSECONDARYCOLOR3UBPROC)load("glSecondaryColor3ub"); 1417 | glad_glSecondaryColor3ubv = (PFNGLSECONDARYCOLOR3UBVPROC)load("glSecondaryColor3ubv"); 1418 | glad_glSecondaryColor3ui = (PFNGLSECONDARYCOLOR3UIPROC)load("glSecondaryColor3ui"); 1419 | glad_glSecondaryColor3uiv = (PFNGLSECONDARYCOLOR3UIVPROC)load("glSecondaryColor3uiv"); 1420 | glad_glSecondaryColor3us = (PFNGLSECONDARYCOLOR3USPROC)load("glSecondaryColor3us"); 1421 | glad_glSecondaryColor3usv = (PFNGLSECONDARYCOLOR3USVPROC)load("glSecondaryColor3usv"); 1422 | glad_glSecondaryColorPointer = (PFNGLSECONDARYCOLORPOINTERPROC)load("glSecondaryColorPointer"); 1423 | glad_glWindowPos2d = (PFNGLWINDOWPOS2DPROC)load("glWindowPos2d"); 1424 | glad_glWindowPos2dv = (PFNGLWINDOWPOS2DVPROC)load("glWindowPos2dv"); 1425 | glad_glWindowPos2f = (PFNGLWINDOWPOS2FPROC)load("glWindowPos2f"); 1426 | glad_glWindowPos2fv = (PFNGLWINDOWPOS2FVPROC)load("glWindowPos2fv"); 1427 | glad_glWindowPos2i = (PFNGLWINDOWPOS2IPROC)load("glWindowPos2i"); 1428 | glad_glWindowPos2iv = (PFNGLWINDOWPOS2IVPROC)load("glWindowPos2iv"); 1429 | glad_glWindowPos2s = (PFNGLWINDOWPOS2SPROC)load("glWindowPos2s"); 1430 | glad_glWindowPos2sv = (PFNGLWINDOWPOS2SVPROC)load("glWindowPos2sv"); 1431 | glad_glWindowPos3d = (PFNGLWINDOWPOS3DPROC)load("glWindowPos3d"); 1432 | glad_glWindowPos3dv = (PFNGLWINDOWPOS3DVPROC)load("glWindowPos3dv"); 1433 | glad_glWindowPos3f = (PFNGLWINDOWPOS3FPROC)load("glWindowPos3f"); 1434 | glad_glWindowPos3fv = (PFNGLWINDOWPOS3FVPROC)load("glWindowPos3fv"); 1435 | glad_glWindowPos3i = (PFNGLWINDOWPOS3IPROC)load("glWindowPos3i"); 1436 | glad_glWindowPos3iv = (PFNGLWINDOWPOS3IVPROC)load("glWindowPos3iv"); 1437 | glad_glWindowPos3s = (PFNGLWINDOWPOS3SPROC)load("glWindowPos3s"); 1438 | glad_glWindowPos3sv = (PFNGLWINDOWPOS3SVPROC)load("glWindowPos3sv"); 1439 | glad_glBlendColor = (PFNGLBLENDCOLORPROC)load("glBlendColor"); 1440 | glad_glBlendEquation = (PFNGLBLENDEQUATIONPROC)load("glBlendEquation"); 1441 | } 1442 | static void load_GL_VERSION_1_5(GLADloadproc load) { 1443 | if(!GLAD_GL_VERSION_1_5) return; 1444 | glad_glGenQueries = (PFNGLGENQUERIESPROC)load("glGenQueries"); 1445 | glad_glDeleteQueries = (PFNGLDELETEQUERIESPROC)load("glDeleteQueries"); 1446 | glad_glIsQuery = (PFNGLISQUERYPROC)load("glIsQuery"); 1447 | glad_glBeginQuery = (PFNGLBEGINQUERYPROC)load("glBeginQuery"); 1448 | glad_glEndQuery = (PFNGLENDQUERYPROC)load("glEndQuery"); 1449 | glad_glGetQueryiv = (PFNGLGETQUERYIVPROC)load("glGetQueryiv"); 1450 | glad_glGetQueryObjectiv = (PFNGLGETQUERYOBJECTIVPROC)load("glGetQueryObjectiv"); 1451 | glad_glGetQueryObjectuiv = (PFNGLGETQUERYOBJECTUIVPROC)load("glGetQueryObjectuiv"); 1452 | glad_glBindBuffer = (PFNGLBINDBUFFERPROC)load("glBindBuffer"); 1453 | glad_glDeleteBuffers = (PFNGLDELETEBUFFERSPROC)load("glDeleteBuffers"); 1454 | glad_glGenBuffers = (PFNGLGENBUFFERSPROC)load("glGenBuffers"); 1455 | glad_glIsBuffer = (PFNGLISBUFFERPROC)load("glIsBuffer"); 1456 | glad_glBufferData = (PFNGLBUFFERDATAPROC)load("glBufferData"); 1457 | glad_glBufferSubData = (PFNGLBUFFERSUBDATAPROC)load("glBufferSubData"); 1458 | glad_glGetBufferSubData = (PFNGLGETBUFFERSUBDATAPROC)load("glGetBufferSubData"); 1459 | glad_glMapBuffer = (PFNGLMAPBUFFERPROC)load("glMapBuffer"); 1460 | glad_glUnmapBuffer = (PFNGLUNMAPBUFFERPROC)load("glUnmapBuffer"); 1461 | glad_glGetBufferParameteriv = (PFNGLGETBUFFERPARAMETERIVPROC)load("glGetBufferParameteriv"); 1462 | glad_glGetBufferPointerv = (PFNGLGETBUFFERPOINTERVPROC)load("glGetBufferPointerv"); 1463 | } 1464 | static void load_GL_VERSION_2_0(GLADloadproc load) { 1465 | if(!GLAD_GL_VERSION_2_0) return; 1466 | glad_glBlendEquationSeparate = (PFNGLBLENDEQUATIONSEPARATEPROC)load("glBlendEquationSeparate"); 1467 | glad_glDrawBuffers = (PFNGLDRAWBUFFERSPROC)load("glDrawBuffers"); 1468 | glad_glStencilOpSeparate = (PFNGLSTENCILOPSEPARATEPROC)load("glStencilOpSeparate"); 1469 | glad_glStencilFuncSeparate = (PFNGLSTENCILFUNCSEPARATEPROC)load("glStencilFuncSeparate"); 1470 | glad_glStencilMaskSeparate = (PFNGLSTENCILMASKSEPARATEPROC)load("glStencilMaskSeparate"); 1471 | glad_glAttachShader = (PFNGLATTACHSHADERPROC)load("glAttachShader"); 1472 | glad_glBindAttribLocation = (PFNGLBINDATTRIBLOCATIONPROC)load("glBindAttribLocation"); 1473 | glad_glCompileShader = (PFNGLCOMPILESHADERPROC)load("glCompileShader"); 1474 | glad_glCreateProgram = (PFNGLCREATEPROGRAMPROC)load("glCreateProgram"); 1475 | glad_glCreateShader = (PFNGLCREATESHADERPROC)load("glCreateShader"); 1476 | glad_glDeleteProgram = (PFNGLDELETEPROGRAMPROC)load("glDeleteProgram"); 1477 | glad_glDeleteShader = (PFNGLDELETESHADERPROC)load("glDeleteShader"); 1478 | glad_glDetachShader = (PFNGLDETACHSHADERPROC)load("glDetachShader"); 1479 | glad_glDisableVertexAttribArray = (PFNGLDISABLEVERTEXATTRIBARRAYPROC)load("glDisableVertexAttribArray"); 1480 | glad_glEnableVertexAttribArray = (PFNGLENABLEVERTEXATTRIBARRAYPROC)load("glEnableVertexAttribArray"); 1481 | glad_glGetActiveAttrib = (PFNGLGETACTIVEATTRIBPROC)load("glGetActiveAttrib"); 1482 | glad_glGetActiveUniform = (PFNGLGETACTIVEUNIFORMPROC)load("glGetActiveUniform"); 1483 | glad_glGetAttachedShaders = (PFNGLGETATTACHEDSHADERSPROC)load("glGetAttachedShaders"); 1484 | glad_glGetAttribLocation = (PFNGLGETATTRIBLOCATIONPROC)load("glGetAttribLocation"); 1485 | glad_glGetProgramiv = (PFNGLGETPROGRAMIVPROC)load("glGetProgramiv"); 1486 | glad_glGetProgramInfoLog = (PFNGLGETPROGRAMINFOLOGPROC)load("glGetProgramInfoLog"); 1487 | glad_glGetShaderiv = (PFNGLGETSHADERIVPROC)load("glGetShaderiv"); 1488 | glad_glGetShaderInfoLog = (PFNGLGETSHADERINFOLOGPROC)load("glGetShaderInfoLog"); 1489 | glad_glGetShaderSource = (PFNGLGETSHADERSOURCEPROC)load("glGetShaderSource"); 1490 | glad_glGetUniformLocation = (PFNGLGETUNIFORMLOCATIONPROC)load("glGetUniformLocation"); 1491 | glad_glGetUniformfv = (PFNGLGETUNIFORMFVPROC)load("glGetUniformfv"); 1492 | glad_glGetUniformiv = (PFNGLGETUNIFORMIVPROC)load("glGetUniformiv"); 1493 | glad_glGetVertexAttribdv = (PFNGLGETVERTEXATTRIBDVPROC)load("glGetVertexAttribdv"); 1494 | glad_glGetVertexAttribfv = (PFNGLGETVERTEXATTRIBFVPROC)load("glGetVertexAttribfv"); 1495 | glad_glGetVertexAttribiv = (PFNGLGETVERTEXATTRIBIVPROC)load("glGetVertexAttribiv"); 1496 | glad_glGetVertexAttribPointerv = (PFNGLGETVERTEXATTRIBPOINTERVPROC)load("glGetVertexAttribPointerv"); 1497 | glad_glIsProgram = (PFNGLISPROGRAMPROC)load("glIsProgram"); 1498 | glad_glIsShader = (PFNGLISSHADERPROC)load("glIsShader"); 1499 | glad_glLinkProgram = (PFNGLLINKPROGRAMPROC)load("glLinkProgram"); 1500 | glad_glShaderSource = (PFNGLSHADERSOURCEPROC)load("glShaderSource"); 1501 | glad_glUseProgram = (PFNGLUSEPROGRAMPROC)load("glUseProgram"); 1502 | glad_glUniform1f = (PFNGLUNIFORM1FPROC)load("glUniform1f"); 1503 | glad_glUniform2f = (PFNGLUNIFORM2FPROC)load("glUniform2f"); 1504 | glad_glUniform3f = (PFNGLUNIFORM3FPROC)load("glUniform3f"); 1505 | glad_glUniform4f = (PFNGLUNIFORM4FPROC)load("glUniform4f"); 1506 | glad_glUniform1i = (PFNGLUNIFORM1IPROC)load("glUniform1i"); 1507 | glad_glUniform2i = (PFNGLUNIFORM2IPROC)load("glUniform2i"); 1508 | glad_glUniform3i = (PFNGLUNIFORM3IPROC)load("glUniform3i"); 1509 | glad_glUniform4i = (PFNGLUNIFORM4IPROC)load("glUniform4i"); 1510 | glad_glUniform1fv = (PFNGLUNIFORM1FVPROC)load("glUniform1fv"); 1511 | glad_glUniform2fv = (PFNGLUNIFORM2FVPROC)load("glUniform2fv"); 1512 | glad_glUniform3fv = (PFNGLUNIFORM3FVPROC)load("glUniform3fv"); 1513 | glad_glUniform4fv = (PFNGLUNIFORM4FVPROC)load("glUniform4fv"); 1514 | glad_glUniform1iv = (PFNGLUNIFORM1IVPROC)load("glUniform1iv"); 1515 | glad_glUniform2iv = (PFNGLUNIFORM2IVPROC)load("glUniform2iv"); 1516 | glad_glUniform3iv = (PFNGLUNIFORM3IVPROC)load("glUniform3iv"); 1517 | glad_glUniform4iv = (PFNGLUNIFORM4IVPROC)load("glUniform4iv"); 1518 | glad_glUniformMatrix2fv = (PFNGLUNIFORMMATRIX2FVPROC)load("glUniformMatrix2fv"); 1519 | glad_glUniformMatrix3fv = (PFNGLUNIFORMMATRIX3FVPROC)load("glUniformMatrix3fv"); 1520 | glad_glUniformMatrix4fv = (PFNGLUNIFORMMATRIX4FVPROC)load("glUniformMatrix4fv"); 1521 | glad_glValidateProgram = (PFNGLVALIDATEPROGRAMPROC)load("glValidateProgram"); 1522 | glad_glVertexAttrib1d = (PFNGLVERTEXATTRIB1DPROC)load("glVertexAttrib1d"); 1523 | glad_glVertexAttrib1dv = (PFNGLVERTEXATTRIB1DVPROC)load("glVertexAttrib1dv"); 1524 | glad_glVertexAttrib1f = (PFNGLVERTEXATTRIB1FPROC)load("glVertexAttrib1f"); 1525 | glad_glVertexAttrib1fv = (PFNGLVERTEXATTRIB1FVPROC)load("glVertexAttrib1fv"); 1526 | glad_glVertexAttrib1s = (PFNGLVERTEXATTRIB1SPROC)load("glVertexAttrib1s"); 1527 | glad_glVertexAttrib1sv = (PFNGLVERTEXATTRIB1SVPROC)load("glVertexAttrib1sv"); 1528 | glad_glVertexAttrib2d = (PFNGLVERTEXATTRIB2DPROC)load("glVertexAttrib2d"); 1529 | glad_glVertexAttrib2dv = (PFNGLVERTEXATTRIB2DVPROC)load("glVertexAttrib2dv"); 1530 | glad_glVertexAttrib2f = (PFNGLVERTEXATTRIB2FPROC)load("glVertexAttrib2f"); 1531 | glad_glVertexAttrib2fv = (PFNGLVERTEXATTRIB2FVPROC)load("glVertexAttrib2fv"); 1532 | glad_glVertexAttrib2s = (PFNGLVERTEXATTRIB2SPROC)load("glVertexAttrib2s"); 1533 | glad_glVertexAttrib2sv = (PFNGLVERTEXATTRIB2SVPROC)load("glVertexAttrib2sv"); 1534 | glad_glVertexAttrib3d = (PFNGLVERTEXATTRIB3DPROC)load("glVertexAttrib3d"); 1535 | glad_glVertexAttrib3dv = (PFNGLVERTEXATTRIB3DVPROC)load("glVertexAttrib3dv"); 1536 | glad_glVertexAttrib3f = (PFNGLVERTEXATTRIB3FPROC)load("glVertexAttrib3f"); 1537 | glad_glVertexAttrib3fv = (PFNGLVERTEXATTRIB3FVPROC)load("glVertexAttrib3fv"); 1538 | glad_glVertexAttrib3s = (PFNGLVERTEXATTRIB3SPROC)load("glVertexAttrib3s"); 1539 | glad_glVertexAttrib3sv = (PFNGLVERTEXATTRIB3SVPROC)load("glVertexAttrib3sv"); 1540 | glad_glVertexAttrib4Nbv = (PFNGLVERTEXATTRIB4NBVPROC)load("glVertexAttrib4Nbv"); 1541 | glad_glVertexAttrib4Niv = (PFNGLVERTEXATTRIB4NIVPROC)load("glVertexAttrib4Niv"); 1542 | glad_glVertexAttrib4Nsv = (PFNGLVERTEXATTRIB4NSVPROC)load("glVertexAttrib4Nsv"); 1543 | glad_glVertexAttrib4Nub = (PFNGLVERTEXATTRIB4NUBPROC)load("glVertexAttrib4Nub"); 1544 | glad_glVertexAttrib4Nubv = (PFNGLVERTEXATTRIB4NUBVPROC)load("glVertexAttrib4Nubv"); 1545 | glad_glVertexAttrib4Nuiv = (PFNGLVERTEXATTRIB4NUIVPROC)load("glVertexAttrib4Nuiv"); 1546 | glad_glVertexAttrib4Nusv = (PFNGLVERTEXATTRIB4NUSVPROC)load("glVertexAttrib4Nusv"); 1547 | glad_glVertexAttrib4bv = (PFNGLVERTEXATTRIB4BVPROC)load("glVertexAttrib4bv"); 1548 | glad_glVertexAttrib4d = (PFNGLVERTEXATTRIB4DPROC)load("glVertexAttrib4d"); 1549 | glad_glVertexAttrib4dv = (PFNGLVERTEXATTRIB4DVPROC)load("glVertexAttrib4dv"); 1550 | glad_glVertexAttrib4f = (PFNGLVERTEXATTRIB4FPROC)load("glVertexAttrib4f"); 1551 | glad_glVertexAttrib4fv = (PFNGLVERTEXATTRIB4FVPROC)load("glVertexAttrib4fv"); 1552 | glad_glVertexAttrib4iv = (PFNGLVERTEXATTRIB4IVPROC)load("glVertexAttrib4iv"); 1553 | glad_glVertexAttrib4s = (PFNGLVERTEXATTRIB4SPROC)load("glVertexAttrib4s"); 1554 | glad_glVertexAttrib4sv = (PFNGLVERTEXATTRIB4SVPROC)load("glVertexAttrib4sv"); 1555 | glad_glVertexAttrib4ubv = (PFNGLVERTEXATTRIB4UBVPROC)load("glVertexAttrib4ubv"); 1556 | glad_glVertexAttrib4uiv = (PFNGLVERTEXATTRIB4UIVPROC)load("glVertexAttrib4uiv"); 1557 | glad_glVertexAttrib4usv = (PFNGLVERTEXATTRIB4USVPROC)load("glVertexAttrib4usv"); 1558 | glad_glVertexAttribPointer = (PFNGLVERTEXATTRIBPOINTERPROC)load("glVertexAttribPointer"); 1559 | } 1560 | static void load_GL_VERSION_2_1(GLADloadproc load) { 1561 | if(!GLAD_GL_VERSION_2_1) return; 1562 | glad_glUniformMatrix2x3fv = (PFNGLUNIFORMMATRIX2X3FVPROC)load("glUniformMatrix2x3fv"); 1563 | glad_glUniformMatrix3x2fv = (PFNGLUNIFORMMATRIX3X2FVPROC)load("glUniformMatrix3x2fv"); 1564 | glad_glUniformMatrix2x4fv = (PFNGLUNIFORMMATRIX2X4FVPROC)load("glUniformMatrix2x4fv"); 1565 | glad_glUniformMatrix4x2fv = (PFNGLUNIFORMMATRIX4X2FVPROC)load("glUniformMatrix4x2fv"); 1566 | glad_glUniformMatrix3x4fv = (PFNGLUNIFORMMATRIX3X4FVPROC)load("glUniformMatrix3x4fv"); 1567 | glad_glUniformMatrix4x3fv = (PFNGLUNIFORMMATRIX4X3FVPROC)load("glUniformMatrix4x3fv"); 1568 | } 1569 | static void load_GL_VERSION_3_0(GLADloadproc load) { 1570 | if(!GLAD_GL_VERSION_3_0) return; 1571 | glad_glColorMaski = (PFNGLCOLORMASKIPROC)load("glColorMaski"); 1572 | glad_glGetBooleani_v = (PFNGLGETBOOLEANI_VPROC)load("glGetBooleani_v"); 1573 | glad_glGetIntegeri_v = (PFNGLGETINTEGERI_VPROC)load("glGetIntegeri_v"); 1574 | glad_glEnablei = (PFNGLENABLEIPROC)load("glEnablei"); 1575 | glad_glDisablei = (PFNGLDISABLEIPROC)load("glDisablei"); 1576 | glad_glIsEnabledi = (PFNGLISENABLEDIPROC)load("glIsEnabledi"); 1577 | glad_glBeginTransformFeedback = (PFNGLBEGINTRANSFORMFEEDBACKPROC)load("glBeginTransformFeedback"); 1578 | glad_glEndTransformFeedback = (PFNGLENDTRANSFORMFEEDBACKPROC)load("glEndTransformFeedback"); 1579 | glad_glBindBufferRange = (PFNGLBINDBUFFERRANGEPROC)load("glBindBufferRange"); 1580 | glad_glBindBufferBase = (PFNGLBINDBUFFERBASEPROC)load("glBindBufferBase"); 1581 | glad_glTransformFeedbackVaryings = (PFNGLTRANSFORMFEEDBACKVARYINGSPROC)load("glTransformFeedbackVaryings"); 1582 | glad_glGetTransformFeedbackVarying = (PFNGLGETTRANSFORMFEEDBACKVARYINGPROC)load("glGetTransformFeedbackVarying"); 1583 | glad_glClampColor = (PFNGLCLAMPCOLORPROC)load("glClampColor"); 1584 | glad_glBeginConditionalRender = (PFNGLBEGINCONDITIONALRENDERPROC)load("glBeginConditionalRender"); 1585 | glad_glEndConditionalRender = (PFNGLENDCONDITIONALRENDERPROC)load("glEndConditionalRender"); 1586 | glad_glVertexAttribIPointer = (PFNGLVERTEXATTRIBIPOINTERPROC)load("glVertexAttribIPointer"); 1587 | glad_glGetVertexAttribIiv = (PFNGLGETVERTEXATTRIBIIVPROC)load("glGetVertexAttribIiv"); 1588 | glad_glGetVertexAttribIuiv = (PFNGLGETVERTEXATTRIBIUIVPROC)load("glGetVertexAttribIuiv"); 1589 | glad_glVertexAttribI1i = (PFNGLVERTEXATTRIBI1IPROC)load("glVertexAttribI1i"); 1590 | glad_glVertexAttribI2i = (PFNGLVERTEXATTRIBI2IPROC)load("glVertexAttribI2i"); 1591 | glad_glVertexAttribI3i = (PFNGLVERTEXATTRIBI3IPROC)load("glVertexAttribI3i"); 1592 | glad_glVertexAttribI4i = (PFNGLVERTEXATTRIBI4IPROC)load("glVertexAttribI4i"); 1593 | glad_glVertexAttribI1ui = (PFNGLVERTEXATTRIBI1UIPROC)load("glVertexAttribI1ui"); 1594 | glad_glVertexAttribI2ui = (PFNGLVERTEXATTRIBI2UIPROC)load("glVertexAttribI2ui"); 1595 | glad_glVertexAttribI3ui = (PFNGLVERTEXATTRIBI3UIPROC)load("glVertexAttribI3ui"); 1596 | glad_glVertexAttribI4ui = (PFNGLVERTEXATTRIBI4UIPROC)load("glVertexAttribI4ui"); 1597 | glad_glVertexAttribI1iv = (PFNGLVERTEXATTRIBI1IVPROC)load("glVertexAttribI1iv"); 1598 | glad_glVertexAttribI2iv = (PFNGLVERTEXATTRIBI2IVPROC)load("glVertexAttribI2iv"); 1599 | glad_glVertexAttribI3iv = (PFNGLVERTEXATTRIBI3IVPROC)load("glVertexAttribI3iv"); 1600 | glad_glVertexAttribI4iv = (PFNGLVERTEXATTRIBI4IVPROC)load("glVertexAttribI4iv"); 1601 | glad_glVertexAttribI1uiv = (PFNGLVERTEXATTRIBI1UIVPROC)load("glVertexAttribI1uiv"); 1602 | glad_glVertexAttribI2uiv = (PFNGLVERTEXATTRIBI2UIVPROC)load("glVertexAttribI2uiv"); 1603 | glad_glVertexAttribI3uiv = (PFNGLVERTEXATTRIBI3UIVPROC)load("glVertexAttribI3uiv"); 1604 | glad_glVertexAttribI4uiv = (PFNGLVERTEXATTRIBI4UIVPROC)load("glVertexAttribI4uiv"); 1605 | glad_glVertexAttribI4bv = (PFNGLVERTEXATTRIBI4BVPROC)load("glVertexAttribI4bv"); 1606 | glad_glVertexAttribI4sv = (PFNGLVERTEXATTRIBI4SVPROC)load("glVertexAttribI4sv"); 1607 | glad_glVertexAttribI4ubv = (PFNGLVERTEXATTRIBI4UBVPROC)load("glVertexAttribI4ubv"); 1608 | glad_glVertexAttribI4usv = (PFNGLVERTEXATTRIBI4USVPROC)load("glVertexAttribI4usv"); 1609 | glad_glGetUniformuiv = (PFNGLGETUNIFORMUIVPROC)load("glGetUniformuiv"); 1610 | glad_glBindFragDataLocation = (PFNGLBINDFRAGDATALOCATIONPROC)load("glBindFragDataLocation"); 1611 | glad_glGetFragDataLocation = (PFNGLGETFRAGDATALOCATIONPROC)load("glGetFragDataLocation"); 1612 | glad_glUniform1ui = (PFNGLUNIFORM1UIPROC)load("glUniform1ui"); 1613 | glad_glUniform2ui = (PFNGLUNIFORM2UIPROC)load("glUniform2ui"); 1614 | glad_glUniform3ui = (PFNGLUNIFORM3UIPROC)load("glUniform3ui"); 1615 | glad_glUniform4ui = (PFNGLUNIFORM4UIPROC)load("glUniform4ui"); 1616 | glad_glUniform1uiv = (PFNGLUNIFORM1UIVPROC)load("glUniform1uiv"); 1617 | glad_glUniform2uiv = (PFNGLUNIFORM2UIVPROC)load("glUniform2uiv"); 1618 | glad_glUniform3uiv = (PFNGLUNIFORM3UIVPROC)load("glUniform3uiv"); 1619 | glad_glUniform4uiv = (PFNGLUNIFORM4UIVPROC)load("glUniform4uiv"); 1620 | glad_glTexParameterIiv = (PFNGLTEXPARAMETERIIVPROC)load("glTexParameterIiv"); 1621 | glad_glTexParameterIuiv = (PFNGLTEXPARAMETERIUIVPROC)load("glTexParameterIuiv"); 1622 | glad_glGetTexParameterIiv = (PFNGLGETTEXPARAMETERIIVPROC)load("glGetTexParameterIiv"); 1623 | glad_glGetTexParameterIuiv = (PFNGLGETTEXPARAMETERIUIVPROC)load("glGetTexParameterIuiv"); 1624 | glad_glClearBufferiv = (PFNGLCLEARBUFFERIVPROC)load("glClearBufferiv"); 1625 | glad_glClearBufferuiv = (PFNGLCLEARBUFFERUIVPROC)load("glClearBufferuiv"); 1626 | glad_glClearBufferfv = (PFNGLCLEARBUFFERFVPROC)load("glClearBufferfv"); 1627 | glad_glClearBufferfi = (PFNGLCLEARBUFFERFIPROC)load("glClearBufferfi"); 1628 | glad_glGetStringi = (PFNGLGETSTRINGIPROC)load("glGetStringi"); 1629 | glad_glIsRenderbuffer = (PFNGLISRENDERBUFFERPROC)load("glIsRenderbuffer"); 1630 | glad_glBindRenderbuffer = (PFNGLBINDRENDERBUFFERPROC)load("glBindRenderbuffer"); 1631 | glad_glDeleteRenderbuffers = (PFNGLDELETERENDERBUFFERSPROC)load("glDeleteRenderbuffers"); 1632 | glad_glGenRenderbuffers = (PFNGLGENRENDERBUFFERSPROC)load("glGenRenderbuffers"); 1633 | glad_glRenderbufferStorage = (PFNGLRENDERBUFFERSTORAGEPROC)load("glRenderbufferStorage"); 1634 | glad_glGetRenderbufferParameteriv = (PFNGLGETRENDERBUFFERPARAMETERIVPROC)load("glGetRenderbufferParameteriv"); 1635 | glad_glIsFramebuffer = (PFNGLISFRAMEBUFFERPROC)load("glIsFramebuffer"); 1636 | glad_glBindFramebuffer = (PFNGLBINDFRAMEBUFFERPROC)load("glBindFramebuffer"); 1637 | glad_glDeleteFramebuffers = (PFNGLDELETEFRAMEBUFFERSPROC)load("glDeleteFramebuffers"); 1638 | glad_glGenFramebuffers = (PFNGLGENFRAMEBUFFERSPROC)load("glGenFramebuffers"); 1639 | glad_glCheckFramebufferStatus = (PFNGLCHECKFRAMEBUFFERSTATUSPROC)load("glCheckFramebufferStatus"); 1640 | glad_glFramebufferTexture1D = (PFNGLFRAMEBUFFERTEXTURE1DPROC)load("glFramebufferTexture1D"); 1641 | glad_glFramebufferTexture2D = (PFNGLFRAMEBUFFERTEXTURE2DPROC)load("glFramebufferTexture2D"); 1642 | glad_glFramebufferTexture3D = (PFNGLFRAMEBUFFERTEXTURE3DPROC)load("glFramebufferTexture3D"); 1643 | glad_glFramebufferRenderbuffer = (PFNGLFRAMEBUFFERRENDERBUFFERPROC)load("glFramebufferRenderbuffer"); 1644 | glad_glGetFramebufferAttachmentParameteriv = (PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC)load("glGetFramebufferAttachmentParameteriv"); 1645 | glad_glGenerateMipmap = (PFNGLGENERATEMIPMAPPROC)load("glGenerateMipmap"); 1646 | glad_glBlitFramebuffer = (PFNGLBLITFRAMEBUFFERPROC)load("glBlitFramebuffer"); 1647 | glad_glRenderbufferStorageMultisample = (PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC)load("glRenderbufferStorageMultisample"); 1648 | glad_glFramebufferTextureLayer = (PFNGLFRAMEBUFFERTEXTURELAYERPROC)load("glFramebufferTextureLayer"); 1649 | glad_glMapBufferRange = (PFNGLMAPBUFFERRANGEPROC)load("glMapBufferRange"); 1650 | glad_glFlushMappedBufferRange = (PFNGLFLUSHMAPPEDBUFFERRANGEPROC)load("glFlushMappedBufferRange"); 1651 | glad_glBindVertexArray = (PFNGLBINDVERTEXARRAYPROC)load("glBindVertexArray"); 1652 | glad_glDeleteVertexArrays = (PFNGLDELETEVERTEXARRAYSPROC)load("glDeleteVertexArrays"); 1653 | glad_glGenVertexArrays = (PFNGLGENVERTEXARRAYSPROC)load("glGenVertexArrays"); 1654 | glad_glIsVertexArray = (PFNGLISVERTEXARRAYPROC)load("glIsVertexArray"); 1655 | } 1656 | static void load_GL_VERSION_3_1(GLADloadproc load) { 1657 | if(!GLAD_GL_VERSION_3_1) return; 1658 | glad_glDrawArraysInstanced = (PFNGLDRAWARRAYSINSTANCEDPROC)load("glDrawArraysInstanced"); 1659 | glad_glDrawElementsInstanced = (PFNGLDRAWELEMENTSINSTANCEDPROC)load("glDrawElementsInstanced"); 1660 | glad_glTexBuffer = (PFNGLTEXBUFFERPROC)load("glTexBuffer"); 1661 | glad_glPrimitiveRestartIndex = (PFNGLPRIMITIVERESTARTINDEXPROC)load("glPrimitiveRestartIndex"); 1662 | glad_glCopyBufferSubData = (PFNGLCOPYBUFFERSUBDATAPROC)load("glCopyBufferSubData"); 1663 | glad_glGetUniformIndices = (PFNGLGETUNIFORMINDICESPROC)load("glGetUniformIndices"); 1664 | glad_glGetActiveUniformsiv = (PFNGLGETACTIVEUNIFORMSIVPROC)load("glGetActiveUniformsiv"); 1665 | glad_glGetActiveUniformName = (PFNGLGETACTIVEUNIFORMNAMEPROC)load("glGetActiveUniformName"); 1666 | glad_glGetUniformBlockIndex = (PFNGLGETUNIFORMBLOCKINDEXPROC)load("glGetUniformBlockIndex"); 1667 | glad_glGetActiveUniformBlockiv = (PFNGLGETACTIVEUNIFORMBLOCKIVPROC)load("glGetActiveUniformBlockiv"); 1668 | glad_glGetActiveUniformBlockName = (PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC)load("glGetActiveUniformBlockName"); 1669 | glad_glUniformBlockBinding = (PFNGLUNIFORMBLOCKBINDINGPROC)load("glUniformBlockBinding"); 1670 | glad_glBindBufferRange = (PFNGLBINDBUFFERRANGEPROC)load("glBindBufferRange"); 1671 | glad_glBindBufferBase = (PFNGLBINDBUFFERBASEPROC)load("glBindBufferBase"); 1672 | glad_glGetIntegeri_v = (PFNGLGETINTEGERI_VPROC)load("glGetIntegeri_v"); 1673 | } 1674 | static void load_GL_VERSION_3_2(GLADloadproc load) { 1675 | if(!GLAD_GL_VERSION_3_2) return; 1676 | glad_glDrawElementsBaseVertex = (PFNGLDRAWELEMENTSBASEVERTEXPROC)load("glDrawElementsBaseVertex"); 1677 | glad_glDrawRangeElementsBaseVertex = (PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC)load("glDrawRangeElementsBaseVertex"); 1678 | glad_glDrawElementsInstancedBaseVertex = (PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC)load("glDrawElementsInstancedBaseVertex"); 1679 | glad_glMultiDrawElementsBaseVertex = (PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC)load("glMultiDrawElementsBaseVertex"); 1680 | glad_glProvokingVertex = (PFNGLPROVOKINGVERTEXPROC)load("glProvokingVertex"); 1681 | glad_glFenceSync = (PFNGLFENCESYNCPROC)load("glFenceSync"); 1682 | glad_glIsSync = (PFNGLISSYNCPROC)load("glIsSync"); 1683 | glad_glDeleteSync = (PFNGLDELETESYNCPROC)load("glDeleteSync"); 1684 | glad_glClientWaitSync = (PFNGLCLIENTWAITSYNCPROC)load("glClientWaitSync"); 1685 | glad_glWaitSync = (PFNGLWAITSYNCPROC)load("glWaitSync"); 1686 | glad_glGetInteger64v = (PFNGLGETINTEGER64VPROC)load("glGetInteger64v"); 1687 | glad_glGetSynciv = (PFNGLGETSYNCIVPROC)load("glGetSynciv"); 1688 | glad_glGetInteger64i_v = (PFNGLGETINTEGER64I_VPROC)load("glGetInteger64i_v"); 1689 | glad_glGetBufferParameteri64v = (PFNGLGETBUFFERPARAMETERI64VPROC)load("glGetBufferParameteri64v"); 1690 | glad_glFramebufferTexture = (PFNGLFRAMEBUFFERTEXTUREPROC)load("glFramebufferTexture"); 1691 | glad_glTexImage2DMultisample = (PFNGLTEXIMAGE2DMULTISAMPLEPROC)load("glTexImage2DMultisample"); 1692 | glad_glTexImage3DMultisample = (PFNGLTEXIMAGE3DMULTISAMPLEPROC)load("glTexImage3DMultisample"); 1693 | glad_glGetMultisamplefv = (PFNGLGETMULTISAMPLEFVPROC)load("glGetMultisamplefv"); 1694 | glad_glSampleMaski = (PFNGLSAMPLEMASKIPROC)load("glSampleMaski"); 1695 | } 1696 | static void load_GL_VERSION_3_3(GLADloadproc load) { 1697 | if(!GLAD_GL_VERSION_3_3) return; 1698 | glad_glBindFragDataLocationIndexed = (PFNGLBINDFRAGDATALOCATIONINDEXEDPROC)load("glBindFragDataLocationIndexed"); 1699 | glad_glGetFragDataIndex = (PFNGLGETFRAGDATAINDEXPROC)load("glGetFragDataIndex"); 1700 | glad_glGenSamplers = (PFNGLGENSAMPLERSPROC)load("glGenSamplers"); 1701 | glad_glDeleteSamplers = (PFNGLDELETESAMPLERSPROC)load("glDeleteSamplers"); 1702 | glad_glIsSampler = (PFNGLISSAMPLERPROC)load("glIsSampler"); 1703 | glad_glBindSampler = (PFNGLBINDSAMPLERPROC)load("glBindSampler"); 1704 | glad_glSamplerParameteri = (PFNGLSAMPLERPARAMETERIPROC)load("glSamplerParameteri"); 1705 | glad_glSamplerParameteriv = (PFNGLSAMPLERPARAMETERIVPROC)load("glSamplerParameteriv"); 1706 | glad_glSamplerParameterf = (PFNGLSAMPLERPARAMETERFPROC)load("glSamplerParameterf"); 1707 | glad_glSamplerParameterfv = (PFNGLSAMPLERPARAMETERFVPROC)load("glSamplerParameterfv"); 1708 | glad_glSamplerParameterIiv = (PFNGLSAMPLERPARAMETERIIVPROC)load("glSamplerParameterIiv"); 1709 | glad_glSamplerParameterIuiv = (PFNGLSAMPLERPARAMETERIUIVPROC)load("glSamplerParameterIuiv"); 1710 | glad_glGetSamplerParameteriv = (PFNGLGETSAMPLERPARAMETERIVPROC)load("glGetSamplerParameteriv"); 1711 | glad_glGetSamplerParameterIiv = (PFNGLGETSAMPLERPARAMETERIIVPROC)load("glGetSamplerParameterIiv"); 1712 | glad_glGetSamplerParameterfv = (PFNGLGETSAMPLERPARAMETERFVPROC)load("glGetSamplerParameterfv"); 1713 | glad_glGetSamplerParameterIuiv = (PFNGLGETSAMPLERPARAMETERIUIVPROC)load("glGetSamplerParameterIuiv"); 1714 | glad_glQueryCounter = (PFNGLQUERYCOUNTERPROC)load("glQueryCounter"); 1715 | glad_glGetQueryObjecti64v = (PFNGLGETQUERYOBJECTI64VPROC)load("glGetQueryObjecti64v"); 1716 | glad_glGetQueryObjectui64v = (PFNGLGETQUERYOBJECTUI64VPROC)load("glGetQueryObjectui64v"); 1717 | glad_glVertexAttribDivisor = (PFNGLVERTEXATTRIBDIVISORPROC)load("glVertexAttribDivisor"); 1718 | glad_glVertexAttribP1ui = (PFNGLVERTEXATTRIBP1UIPROC)load("glVertexAttribP1ui"); 1719 | glad_glVertexAttribP1uiv = (PFNGLVERTEXATTRIBP1UIVPROC)load("glVertexAttribP1uiv"); 1720 | glad_glVertexAttribP2ui = (PFNGLVERTEXATTRIBP2UIPROC)load("glVertexAttribP2ui"); 1721 | glad_glVertexAttribP2uiv = (PFNGLVERTEXATTRIBP2UIVPROC)load("glVertexAttribP2uiv"); 1722 | glad_glVertexAttribP3ui = (PFNGLVERTEXATTRIBP3UIPROC)load("glVertexAttribP3ui"); 1723 | glad_glVertexAttribP3uiv = (PFNGLVERTEXATTRIBP3UIVPROC)load("glVertexAttribP3uiv"); 1724 | glad_glVertexAttribP4ui = (PFNGLVERTEXATTRIBP4UIPROC)load("glVertexAttribP4ui"); 1725 | glad_glVertexAttribP4uiv = (PFNGLVERTEXATTRIBP4UIVPROC)load("glVertexAttribP4uiv"); 1726 | glad_glVertexP2ui = (PFNGLVERTEXP2UIPROC)load("glVertexP2ui"); 1727 | glad_glVertexP2uiv = (PFNGLVERTEXP2UIVPROC)load("glVertexP2uiv"); 1728 | glad_glVertexP3ui = (PFNGLVERTEXP3UIPROC)load("glVertexP3ui"); 1729 | glad_glVertexP3uiv = (PFNGLVERTEXP3UIVPROC)load("glVertexP3uiv"); 1730 | glad_glVertexP4ui = (PFNGLVERTEXP4UIPROC)load("glVertexP4ui"); 1731 | glad_glVertexP4uiv = (PFNGLVERTEXP4UIVPROC)load("glVertexP4uiv"); 1732 | glad_glTexCoordP1ui = (PFNGLTEXCOORDP1UIPROC)load("glTexCoordP1ui"); 1733 | glad_glTexCoordP1uiv = (PFNGLTEXCOORDP1UIVPROC)load("glTexCoordP1uiv"); 1734 | glad_glTexCoordP2ui = (PFNGLTEXCOORDP2UIPROC)load("glTexCoordP2ui"); 1735 | glad_glTexCoordP2uiv = (PFNGLTEXCOORDP2UIVPROC)load("glTexCoordP2uiv"); 1736 | glad_glTexCoordP3ui = (PFNGLTEXCOORDP3UIPROC)load("glTexCoordP3ui"); 1737 | glad_glTexCoordP3uiv = (PFNGLTEXCOORDP3UIVPROC)load("glTexCoordP3uiv"); 1738 | glad_glTexCoordP4ui = (PFNGLTEXCOORDP4UIPROC)load("glTexCoordP4ui"); 1739 | glad_glTexCoordP4uiv = (PFNGLTEXCOORDP4UIVPROC)load("glTexCoordP4uiv"); 1740 | glad_glMultiTexCoordP1ui = (PFNGLMULTITEXCOORDP1UIPROC)load("glMultiTexCoordP1ui"); 1741 | glad_glMultiTexCoordP1uiv = (PFNGLMULTITEXCOORDP1UIVPROC)load("glMultiTexCoordP1uiv"); 1742 | glad_glMultiTexCoordP2ui = (PFNGLMULTITEXCOORDP2UIPROC)load("glMultiTexCoordP2ui"); 1743 | glad_glMultiTexCoordP2uiv = (PFNGLMULTITEXCOORDP2UIVPROC)load("glMultiTexCoordP2uiv"); 1744 | glad_glMultiTexCoordP3ui = (PFNGLMULTITEXCOORDP3UIPROC)load("glMultiTexCoordP3ui"); 1745 | glad_glMultiTexCoordP3uiv = (PFNGLMULTITEXCOORDP3UIVPROC)load("glMultiTexCoordP3uiv"); 1746 | glad_glMultiTexCoordP4ui = (PFNGLMULTITEXCOORDP4UIPROC)load("glMultiTexCoordP4ui"); 1747 | glad_glMultiTexCoordP4uiv = (PFNGLMULTITEXCOORDP4UIVPROC)load("glMultiTexCoordP4uiv"); 1748 | glad_glNormalP3ui = (PFNGLNORMALP3UIPROC)load("glNormalP3ui"); 1749 | glad_glNormalP3uiv = (PFNGLNORMALP3UIVPROC)load("glNormalP3uiv"); 1750 | glad_glColorP3ui = (PFNGLCOLORP3UIPROC)load("glColorP3ui"); 1751 | glad_glColorP3uiv = (PFNGLCOLORP3UIVPROC)load("glColorP3uiv"); 1752 | glad_glColorP4ui = (PFNGLCOLORP4UIPROC)load("glColorP4ui"); 1753 | glad_glColorP4uiv = (PFNGLCOLORP4UIVPROC)load("glColorP4uiv"); 1754 | glad_glSecondaryColorP3ui = (PFNGLSECONDARYCOLORP3UIPROC)load("glSecondaryColorP3ui"); 1755 | glad_glSecondaryColorP3uiv = (PFNGLSECONDARYCOLORP3UIVPROC)load("glSecondaryColorP3uiv"); 1756 | } 1757 | static int find_extensionsGL(void) { 1758 | if (!get_exts()) return 0; 1759 | (void)&has_ext; 1760 | free_exts(); 1761 | return 1; 1762 | } 1763 | 1764 | static void find_coreGL(void) { 1765 | 1766 | /* Thank you @elmindreda 1767 | * https://github.com/elmindreda/greg/blob/master/templates/greg.c.in#L176 1768 | * https://github.com/glfw/glfw/blob/master/src/context.c#L36 1769 | */ 1770 | int i, major, minor; 1771 | 1772 | const char* version; 1773 | const char* prefixes[] = { 1774 | "OpenGL ES-CM ", 1775 | "OpenGL ES-CL ", 1776 | "OpenGL ES ", 1777 | NULL 1778 | }; 1779 | 1780 | version = (const char*) glGetString(GL_VERSION); 1781 | if (!version) return; 1782 | 1783 | for (i = 0; prefixes[i]; i++) { 1784 | const size_t length = strlen(prefixes[i]); 1785 | if (strncmp(version, prefixes[i], length) == 0) { 1786 | version += length; 1787 | break; 1788 | } 1789 | } 1790 | 1791 | /* PR #18 */ 1792 | #ifdef _MSC_VER 1793 | sscanf_s(version, "%d.%d", &major, &minor); 1794 | #else 1795 | sscanf(version, "%d.%d", &major, &minor); 1796 | #endif 1797 | 1798 | GLVersion.major = major; GLVersion.minor = minor; 1799 | max_loaded_major = major; max_loaded_minor = minor; 1800 | GLAD_GL_VERSION_1_0 = (major == 1 && minor >= 0) || major > 1; 1801 | GLAD_GL_VERSION_1_1 = (major == 1 && minor >= 1) || major > 1; 1802 | GLAD_GL_VERSION_1_2 = (major == 1 && minor >= 2) || major > 1; 1803 | GLAD_GL_VERSION_1_3 = (major == 1 && minor >= 3) || major > 1; 1804 | GLAD_GL_VERSION_1_4 = (major == 1 && minor >= 4) || major > 1; 1805 | GLAD_GL_VERSION_1_5 = (major == 1 && minor >= 5) || major > 1; 1806 | GLAD_GL_VERSION_2_0 = (major == 2 && minor >= 0) || major > 2; 1807 | GLAD_GL_VERSION_2_1 = (major == 2 && minor >= 1) || major > 2; 1808 | GLAD_GL_VERSION_3_0 = (major == 3 && minor >= 0) || major > 3; 1809 | GLAD_GL_VERSION_3_1 = (major == 3 && minor >= 1) || major > 3; 1810 | GLAD_GL_VERSION_3_2 = (major == 3 && minor >= 2) || major > 3; 1811 | GLAD_GL_VERSION_3_3 = (major == 3 && minor >= 3) || major > 3; 1812 | if (GLVersion.major > 3 || (GLVersion.major >= 3 && GLVersion.minor >= 3)) { 1813 | max_loaded_major = 3; 1814 | max_loaded_minor = 3; 1815 | } 1816 | } 1817 | 1818 | int gladLoadGLLoader(GLADloadproc load) { 1819 | GLVersion.major = 0; GLVersion.minor = 0; 1820 | glGetString = (PFNGLGETSTRINGPROC)load("glGetString"); 1821 | if(glGetString == NULL) return 0; 1822 | if(glGetString(GL_VERSION) == NULL) return 0; 1823 | find_coreGL(); 1824 | load_GL_VERSION_1_0(load); 1825 | load_GL_VERSION_1_1(load); 1826 | load_GL_VERSION_1_2(load); 1827 | load_GL_VERSION_1_3(load); 1828 | load_GL_VERSION_1_4(load); 1829 | load_GL_VERSION_1_5(load); 1830 | load_GL_VERSION_2_0(load); 1831 | load_GL_VERSION_2_1(load); 1832 | load_GL_VERSION_3_0(load); 1833 | load_GL_VERSION_3_1(load); 1834 | load_GL_VERSION_3_2(load); 1835 | load_GL_VERSION_3_3(load); 1836 | 1837 | if (!find_extensionsGL()) return 0; 1838 | return GLVersion.major != 0 || GLVersion.minor != 0; 1839 | } 1840 | 1841 | -------------------------------------------------------------------------------- /src/main.c: -------------------------------------------------------------------------------- 1 | #include "program/program.h" 2 | int main(void) 3 | { 4 | 5 | Program this = programCreate(); 6 | programMainLoop(this); 7 | programDestroy(this); 8 | 9 | return 0; 10 | } -------------------------------------------------------------------------------- /src/program/camera/camera.c: -------------------------------------------------------------------------------- 1 | #include "camera.h" 2 | 3 | Camera cameraCreate(double aspectRatio, Point3 origin) 4 | { 5 | Camera this = {0}; 6 | this.origin = origin; 7 | this.aspectRatio = aspectRatio; 8 | this.viewPortHeight = -2.0; 9 | this.viewPortWidth = aspectRatio * this.viewPortHeight; 10 | this.focalLength = 1.0; 11 | this.horizontal = vec3Create(this.viewPortWidth, 0, 0); 12 | this.vertical = vec3Create(0, this.viewPortHeight, 0); 13 | { 14 | Vec3 temp = vec3Mult(this.horizontal, .5); 15 | Vec3 point1 = vec3Substract(this.origin, temp); 16 | temp = vec3Mult(this.vertical, .5); 17 | Vec3 point2 = vec3Substract(point1, temp); 18 | temp = vec3Create(0, 0, this.focalLength); 19 | this.lowerLeft = vec3Substract(point2, temp); 20 | } 21 | return this; 22 | } -------------------------------------------------------------------------------- /src/program/camera/camera.h: -------------------------------------------------------------------------------- 1 | #ifndef __CAMERA_H__ 2 | #define __CAMERA_H__ 3 | #include "../vec3/vec3.h" 4 | 5 | typedef struct 6 | { 7 | float viewPortHeight; 8 | float viewPortWidth; 9 | float focalLength; 10 | double aspectRatio; 11 | Point3 origin, horizontal, vertical, lowerLeft; 12 | } Camera; 13 | 14 | Camera cameraCreate(double aspectRatio, Point3 origin); 15 | 16 | #endif -------------------------------------------------------------------------------- /src/program/core/array/array.h: -------------------------------------------------------------------------------- 1 | #ifndef __UNIVERSAL_ARRAY_H__ 2 | #define __UNIVERSAL_ARRAY_H__ 3 | 4 | #include "array_header.h" 5 | #include 6 | #include 7 | #include 8 | 9 | typedef struct Array 10 | { 11 | ArrayHeader header; 12 | char data[1]; 13 | } Array; 14 | 15 | Array *arrayCreate(int initialCapacity, size_t elementSize); 16 | Array *arrayCreateFromCArray(void *c_array, size_t elementSize, int length); 17 | void arrayInsertElement(Array **this, void *element); 18 | void arrayConcatenate(Array **this, Array *source); 19 | void *arrayGetElementAt(Array *this, int index); 20 | #endif 21 | 22 | #ifndef ARRAY_MALLOC 23 | #define ARRAY_MALLOC malloc 24 | #endif 25 | 26 | #ifndef ARRAY_REALLOC 27 | #define ARRAY_REALLOC realloc 28 | #endif 29 | 30 | #ifdef __UNIVERSAL_ARRAY_IMPLEMENTATION__ 31 | #undef __UNIVERSAL_ARRAY_IMPLEMENTATION__ 32 | // recomended initial capacity 10 33 | Array *arrayCreate(int initialCapacity, size_t elementSize) 34 | { 35 | size_t size = elementSize * initialCapacity + sizeof(ArrayHeader); 36 | Array *array = (Array *)ARRAY_MALLOC(size); 37 | 38 | if (!array) 39 | { 40 | printf("Error allocation memory for UniversalArray %s::%d\n", __FILE__, __LINE__); 41 | exit(-1); 42 | } 43 | 44 | memset(array, 0, size); 45 | 46 | array->header.capacity = initialCapacity; 47 | array->header.elementSize = elementSize; 48 | array->header.length = 0; 49 | return array; 50 | } 51 | 52 | Array *arrayCreateFromCArray(void *c_array, size_t elementSize, int length) 53 | { 54 | Array *array = arrayCreate(length, elementSize); 55 | array->header.length = length; 56 | memcpy(array->data, c_array, length * elementSize); 57 | return array; 58 | } 59 | 60 | void arrayInsertElement(Array **this, void *element) 61 | { 62 | if ((*this)->header.length + 1 == (*this)->header.capacity) 63 | { 64 | int size = (*this)->header.capacity * (*this)->header.elementSize * 2 + sizeof(ArrayHeader); 65 | Array *newPointer = ARRAY_REALLOC(*this, size); 66 | if (*this == NULL) 67 | { 68 | printf("Error reallocating array\n"); 69 | exit(-1); 70 | } 71 | else 72 | { 73 | *this = newPointer; 74 | (*this)->header.capacity *= 2; 75 | } 76 | } 77 | 78 | memcpy(&(**this).data[(*this)->header.elementSize * (*this)->header.length], element, (**this).header.elementSize); 79 | (*this)->header.length++; 80 | } 81 | 82 | void arrayConcatenate(Array **this, Array *source) 83 | { 84 | if ((*this)->header.elementSize != source->header.elementSize) 85 | { 86 | printf("Error: Arrays holds elements of different dizes. %s::%d\n", __FILE__, __LINE__); 87 | exit(-1); 88 | } 89 | for (int i = 0; i < source->header.length; i++) 90 | { 91 | arrayInsertElement(this, &source->data[i]); 92 | } 93 | } 94 | 95 | void *arrayGetElementAt(Array *this, int index) 96 | { 97 | if (index < this->header.length) 98 | { 99 | return &this->data[index * this->header.elementSize]; 100 | } 101 | return NULL; 102 | } 103 | #endif 104 | -------------------------------------------------------------------------------- /src/program/core/array/array_header.h: -------------------------------------------------------------------------------- 1 | #ifndef __ARRAY_HEADER_H__ 2 | #define __ARRAY_HEADER_H__ 3 | 4 | #include 5 | 6 | typedef struct ArrayHeader 7 | { 8 | int capacity; 9 | int length; 10 | int elementSize; 11 | } ArrayHeader; 12 | 13 | #endif -------------------------------------------------------------------------------- /src/program/core/fonts/fonts.c: -------------------------------------------------------------------------------- 1 | #define FONT_WIDTH 5 2 | unsigned char fonts[255][5] = 3 | { 4 | [33] = 5 | {0b100000, 6 | 0b100000, 7 | 0b100000, 8 | 0b000000, 9 | 0b100000}, 10 | // " 11 | {0b010100, 12 | 0b010100, 13 | 0b000000, 14 | 0b000000, 15 | 0b000000}, 16 | // # 17 | {0b010100, 18 | 0b111110, 19 | 0b010100, 20 | 0b111110, 21 | 0b010100}, 22 | // $ 23 | {0b011110, 24 | 0b101000, 25 | 0b011100, 26 | 0b001010, 27 | 0b111100}, 28 | // % 29 | {0b000010, 30 | 0b100100, 31 | 0b001000, 32 | 0b010010, 33 | 0b100000}, 34 | // & 35 | {0b001100, 36 | 0b010010, 37 | 0b011000, 38 | 0b100100, 39 | 0b011010}, 40 | // ' 41 | {0b001000, 42 | 0b001000, 43 | 0b000000, 44 | 0b000000, 45 | 0b000000}, 46 | // ( 47 | {0b010000, 48 | 0b100000, 49 | 0b100000, 50 | 0b100000, 51 | 0b010000}, 52 | // ) 53 | {0b100000, 54 | 0b010000, 55 | 0b010000, 56 | 0b010000, 57 | 0b100000}, 58 | // . 59 | [46] = 60 | {0b000000, 61 | 0b000000, 62 | 0b000000, 63 | 0b000000, 64 | 0b001000}, 65 | // 0 66 | [48] = 67 | {0b011100, 68 | 0b110010, 69 | 0b101010, 70 | 0b100110, 71 | 0b011100}, 72 | // 1 73 | {0b01000, 74 | 0b11000, 75 | 0b01000, 76 | 0b01000, 77 | 0b11100}, 78 | // 2 79 | {0b011100, 80 | 0b100010, 81 | 0b001100, 82 | 0b010000, 83 | 0b111110}, 84 | // 3 85 | {0b011100, 86 | 0b100010, 87 | 0b001100, 88 | 0b100010, 89 | 0b011100}, 90 | // 4 91 | {0b001010, 92 | 0b010010, 93 | 0b100010, 94 | 0b111110, 95 | 0b000010}, 96 | // 5 97 | {0b111110, 98 | 0b100000, 99 | 0b111100, 100 | 0b000010, 101 | 0b111100}, 102 | // 6 103 | {0b011110, 104 | 0b100000, 105 | 0b111100, 106 | 0b100010, 107 | 0b011100}, 108 | // 7 109 | {0b111110, 110 | 0b000010, 111 | 0b000100, 112 | 0b001000, 113 | 0b010000}, 114 | // 8 115 | {0b011100, 116 | 0b100010, 117 | 0b011100, 118 | 0b100010, 119 | 0b011100}, 120 | // 9 121 | {0b011100, 122 | 0b100010, 123 | 0b011110, 124 | 0b000010, 125 | 0b011100}, 126 | // A 127 | [65] = 128 | {0b111100, 129 | 0b100100, 130 | 0b100100, 131 | 0b111100, 132 | 0b100100}, 133 | // B 134 | {0b111000, 135 | 0b100100, 136 | 0b111000, 137 | 0b100100, 138 | 0b111000}, 139 | // C 140 | {0b111100, 141 | 0b100100, 142 | 0b100000, 143 | 0b100100, 144 | 0b111100}, 145 | // D 146 | {0b111000, 147 | 0b100100, 148 | 0b100100, 149 | 0b100100, 150 | 0b111000}, 151 | // E 152 | {0b111100, 153 | 0b100000, 154 | 0b111100, 155 | 0b100000, 156 | 0b111100}, 157 | // F 158 | {0b111100, 159 | 0b100000, 160 | 0b111000, 161 | 0b100000, 162 | 0b100000}, 163 | // G 164 | {0b011000, 165 | 0b100000, 166 | 0b101100, 167 | 0b100100, 168 | 0b011000}, 169 | // H 170 | {0b100100, 171 | 0b100100, 172 | 0b111100, 173 | 0b100100, 174 | 0b100100}, 175 | // I 176 | {0b11100, 177 | 0b01000, 178 | 0b01000, 179 | 0b01000, 180 | 0b11100}, 181 | // J 182 | {0b111100, 183 | 0b000100, 184 | 0b000100, 185 | 0b100100, 186 | 0b011000}, 187 | // K 188 | {0b100100, 189 | 0b101000, 190 | 0b110000, 191 | 0b101000, 192 | 0b100100}, 193 | // L 194 | {0b100000, 195 | 0b100000, 196 | 0b100000, 197 | 0b100000, 198 | 0b111000}, 199 | // M 200 | {0b100010, 201 | 0b110110, 202 | 0b101010, 203 | 0b100010, 204 | 0b100010}, 205 | // N 206 | {0b10010, 207 | 0b11010, 208 | 0b10110, 209 | 0b10010, 210 | 0b10010}, 211 | // O 212 | {0b111100, 213 | 0b100100, 214 | 0b100100, 215 | 0b100100, 216 | 0b111100}, 217 | // P 218 | {0b111000, 219 | 0b100100, 220 | 0b111000, 221 | 0b100000, 222 | 0b100000}, 223 | // Q 224 | {0b111100, 225 | 0b100100, 226 | 0b100100, 227 | 0b101100, 228 | 0b111100}, 229 | // R 230 | {0b111000, 231 | 0b100100, 232 | 0b111000, 233 | 0b100100, 234 | 0b100100}, 235 | // S 236 | {0b011100, 237 | 0b100000, 238 | 0b011000, 239 | 0b000100, 240 | 0b111000}, 241 | // T 242 | {0b111000, 243 | 0b010000, 244 | 0b010000, 245 | 0b010000, 246 | 0b010000}, 247 | // U 248 | {0b100100, 249 | 0b100100, 250 | 0b100100, 251 | 0b100100, 252 | 0b011000}, 253 | // V 254 | {0b100100, 255 | 0b100100, 256 | 0b100100, 257 | 0b011000, 258 | 0b010000}, 259 | // W 260 | {0b100010, 261 | 0b100010, 262 | 0b101010, 263 | 0b110110, 264 | 0b100010}, 265 | // X 266 | {0b100100, 267 | 0b100100, 268 | 0b011000, 269 | 0b100100, 270 | 0b100100}, 271 | // Y 272 | {0b100010, 273 | 0b100010, 274 | 0b010100, 275 | 0b001000, 276 | 0b001000}, 277 | // Z 278 | {0b111110, 279 | 0b000100, 280 | 0b001000, 281 | 0b010000, 282 | 0b111110}, 283 | // A 284 | [97] = 285 | {0b111100, 286 | 0b100100, 287 | 0b100100, 288 | 0b111100, 289 | 0b100100}, 290 | // B 291 | {0b111000, 292 | 0b100100, 293 | 0b111000, 294 | 0b100100, 295 | 0b111000}, 296 | // C 297 | {0b111100, 298 | 0b100100, 299 | 0b100000, 300 | 0b100100, 301 | 0b111100}, 302 | // D 303 | {0b111000, 304 | 0b100100, 305 | 0b100100, 306 | 0b100100, 307 | 0b111000}, 308 | // E 309 | {0b111100, 310 | 0b100000, 311 | 0b111100, 312 | 0b100000, 313 | 0b111100}, 314 | // F 315 | {0b111100, 316 | 0b100000, 317 | 0b111000, 318 | 0b100000, 319 | 0b100000}, 320 | // G 321 | {0b011000, 322 | 0b100000, 323 | 0b101100, 324 | 0b100100, 325 | 0b011000}, 326 | // H 327 | {0b100100, 328 | 0b100100, 329 | 0b111100, 330 | 0b100100, 331 | 0b100100}, 332 | // I 333 | {0b11100, 334 | 0b01000, 335 | 0b01000, 336 | 0b01000, 337 | 0b11100}, 338 | // J 339 | {0b111100, 340 | 0b000100, 341 | 0b000100, 342 | 0b100100, 343 | 0b011000}, 344 | // K 345 | {0b100100, 346 | 0b101000, 347 | 0b110000, 348 | 0b101000, 349 | 0b100100}, 350 | // L 351 | {0b100000, 352 | 0b100000, 353 | 0b100000, 354 | 0b100000, 355 | 0b111000}, 356 | // M 357 | {0b100010, 358 | 0b110110, 359 | 0b101010, 360 | 0b100010, 361 | 0b100010}, 362 | // N 363 | {0b10010, 364 | 0b11010, 365 | 0b10110, 366 | 0b10010, 367 | 0b10010}, 368 | // O 369 | {0b111100, 370 | 0b100100, 371 | 0b100100, 372 | 0b100100, 373 | 0b111100}, 374 | // P 375 | {0b111000, 376 | 0b100100, 377 | 0b111000, 378 | 0b100000, 379 | 0b100000}, 380 | // Q 381 | {0b111100, 382 | 0b100100, 383 | 0b100100, 384 | 0b101100, 385 | 0b111100}, 386 | // R 387 | {0b111000, 388 | 0b100100, 389 | 0b111000, 390 | 0b100100, 391 | 0b100100}, 392 | // S 393 | {0b011100, 394 | 0b100000, 395 | 0b011000, 396 | 0b000100, 397 | 0b111000}, 398 | // T 399 | {0b111000, 400 | 0b010000, 401 | 0b010000, 402 | 0b010000, 403 | 0b010000}, 404 | // U 405 | {0b100100, 406 | 0b100100, 407 | 0b100100, 408 | 0b100100, 409 | 0b011000}, 410 | // V 411 | {0b100100, 412 | 0b100100, 413 | 0b100100, 414 | 0b011000, 415 | 0b010000}, 416 | // W 417 | {0b100010, 418 | 0b100010, 419 | 0b101010, 420 | 0b110110, 421 | 0b100010}, 422 | // X 423 | {0b100100, 424 | 0b100100, 425 | 0b011000, 426 | 0b100100, 427 | 0b100100}, 428 | // Y 429 | {0b100010, 430 | 0b100010, 431 | 0b010100, 432 | 0b001000, 433 | 0b001000}, 434 | // Z 435 | {0b111110, 436 | 0b000100, 437 | 0b001000, 438 | 0b010000, 439 | 0b111110}, 440 | // , 441 | {0b00000, 442 | 0b00000, 443 | 0b00000, 444 | 0b01000, 445 | 0b10000}, 446 | // . 447 | {0b0000, 448 | 0b0000, 449 | 0b0000, 450 | 0b0000, 451 | 0b1000}, 452 | // ; 453 | {0b000000, 454 | 0b001000, 455 | 0b000000, 456 | 0b001000, 457 | 0b010000} 458 | // // { 459 | // [123] = 460 | // {0b001100, 461 | // 0b001000, 462 | // 0b010000, 463 | // 0b001000, 464 | // 0b001100}, 465 | // // } 466 | // [125] = 467 | // {0b011000, 468 | // 0b001000, 469 | // 0b000100, 470 | // 0b001000, 471 | // 0b011000} 472 | }; 473 | -------------------------------------------------------------------------------- /src/program/core/graphics/graphics.c: -------------------------------------------------------------------------------- 1 | #include "graphics.h" 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include "../shader/shader.h" 8 | #include 9 | #include 10 | #include 11 | 12 | static void textureCreate(Graphics *this) 13 | { 14 | 15 | glGenTextures(1, &this->textureId); 16 | glBindTexture(GL_TEXTURE_2D, this->textureId); 17 | glPixelStorei(GL_UNPACK_ALIGNMENT, 3); 18 | glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); 19 | glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); 20 | 21 | this->imageData.bufferSize = this->imageData.size.x * this->imageData.size.y * sizeof(Color); 22 | this->imageData.data = malloc(this->imageData.bufferSize); 23 | if (this->imageData.data == NULL) 24 | { 25 | fprintf(stderr, "Error allocating memory\n"); 26 | exit(-1); 27 | } 28 | 29 | glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, this->imageData.size.x, this->imageData.size.y, 0, GL_RGB, GL_UNSIGNED_BYTE, this->imageData.data); 30 | } 31 | 32 | void textureCreateFromImage(Graphics *this, char *fileName) 33 | { 34 | int width, height, nrChannels; 35 | 36 | glGenTextures(1, &this->textureId); 37 | glBindTexture(GL_TEXTURE_2D, this->textureId); 38 | // Set texture wrapping filtering options. 39 | glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); 40 | glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); 41 | 42 | stbi_set_flip_vertically_on_load(false); 43 | this->imageData.data = (Color *)stbi_load(fileName, &width, &height, &nrChannels, 0); 44 | 45 | if (this->imageData.data) 46 | { 47 | 48 | GLenum format = 0; 49 | if (nrChannels == 1) 50 | format = GL_RED; 51 | else if (nrChannels == 3) 52 | format = GL_RGB; 53 | else if (nrChannels == 4) 54 | format = GL_RGBA; 55 | 56 | glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, format, GL_UNSIGNED_BYTE, this->imageData.data); 57 | glGenerateMipmap(GL_TEXTURE_2D); 58 | } 59 | else 60 | { 61 | printf("%s::%s - Error loading texture \n", __FILE__, __FUNCTION__); 62 | printf("Error: %s\n", stbi_failure_reason()); 63 | exit(1); 64 | } 65 | } 66 | 67 | Graphics graphicsCreate(int width, int height) 68 | { 69 | Graphics this = {0}; 70 | this.imageData.size.x = width; 71 | this.imageData.size.y = height; 72 | 73 | glfwInit(); 74 | GLFWmonitor *monitor = glfwGetPrimaryMonitor(); 75 | 76 | const GLFWvidmode *mode = glfwGetVideoMode(monitor); 77 | 78 | glfwWindowHint(GLFW_RED_BITS, mode->redBits); 79 | glfwWindowHint(GLFW_GREEN_BITS, mode->greenBits); 80 | glfwWindowHint(GLFW_BLUE_BITS, mode->blueBits); 81 | glfwWindowHint(GLFW_REFRESH_RATE, mode->refreshRate); 82 | glfwWindowHint(GLFW_DOUBLEBUFFER, GL_FALSE); 83 | 84 | glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); 85 | glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3); 86 | glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); 87 | 88 | this.window = glfwCreateWindow(mode->width, mode->height, "Frame Buffer", monitor, NULL); 89 | glfwMakeContextCurrent(this.window); 90 | 91 | if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) 92 | { 93 | printf("Failed to initialize GLAD\n"); 94 | exit(-1); 95 | } 96 | 97 | double ratioX = ((float)this.imageData.size.x / (float)this.imageData.size.y) / ((float)mode->width / (float)mode->height); 98 | double ratioY = 1.0; 99 | 100 | // set up vertex data (and buffer(s)) and configure vertex attributes 101 | // ------------------------------------------------------------------ 102 | float vertices[] = { 103 | // positions // texture coords 104 | ratioX * 1.0f, ratioY * 1.0f, 0.0f, 1.0f, 0.0f, // top right 105 | ratioX * 1.0f, ratioY * -1.0f, 0.0f, 1.0f, 1.0f, // bottom right 106 | ratioX * -1.0f, ratioY * -1.0f, 0.0f, 0.0f, 1.0f, // bottom left 107 | ratioX * -1.0f, ratioY * 1.0f, 0.0f, 0.0f, 0.0f // top left 108 | }; 109 | 110 | unsigned int indices[] = { 111 | 0, 1, 3, // first triangle 112 | 1, 2, 3 // second triangle 113 | }; 114 | 115 | textureCreate(&this); 116 | 117 | this.shaderProgram = shaderProgramCreateFromFiles("assets/shaders/default.vs", "assets/shaders/default.fs"); 118 | glUseProgram(this.shaderProgram); 119 | 120 | unsigned int VBO, EBO; 121 | glGenVertexArrays(1, &this.VAO); 122 | glGenBuffers(1, &VBO); 123 | glGenBuffers(1, &EBO); 124 | 125 | glBindVertexArray(this.VAO); 126 | 127 | glBindBuffer(GL_ARRAY_BUFFER, VBO); 128 | glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW); 129 | 130 | glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO); 131 | glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW); 132 | 133 | // position attribute 134 | glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void *)0); 135 | glEnableVertexAttribArray(0); 136 | // texture coord attribute 137 | glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void *)(3 * sizeof(float))); 138 | glEnableVertexAttribArray(1); 139 | 140 | glfwSetInputMode(this.window, GLFW_CURSOR, GLFW_CURSOR_HIDDEN); 141 | 142 | glfwSetCursorPos(this.window, 0, 0); 143 | 144 | return this; 145 | } 146 | 147 | void graphicsRender(Graphics this) 148 | { 149 | // Update texture 150 | glBindTexture(GL_TEXTURE_2D, this.textureId); 151 | glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, this.imageData.size.x, this.imageData.size.y, GL_RGB, GL_UNSIGNED_BYTE, this.imageData.data); 152 | 153 | // render container 154 | glBindVertexArray(this.VAO); 155 | glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0); 156 | 157 | glFlush(); 158 | } 159 | 160 | void graphicsDestroy(Graphics this) 161 | { 162 | glfwSetWindowShouldClose(this.window, true); 163 | free(this.imageData.data); 164 | glfwDestroyWindow(this.window); 165 | glfwTerminate(); 166 | } 167 | 168 | void graphicsUpdateMouseCoordinates(Graphics *this) 169 | { 170 | int w, h; 171 | double mouseX, mouseY; 172 | glfwGetWindowSize(this->window, &w, &h); 173 | glfwGetCursorPos(this->window, &mouseX, &mouseY); 174 | this->mousePosition.x = mouseX + this->imageData.size.x / (float)w; 175 | this->mousePosition.y = mouseY + this->imageData.size.y / (float)h; 176 | this->mouseRightDown = glfwGetMouseButton(this->window, GLFW_MOUSE_BUTTON_1); 177 | } 178 | -------------------------------------------------------------------------------- /src/program/core/graphics/graphics.h: -------------------------------------------------------------------------------- 1 | #ifndef __GRAPHICS_H__ 2 | #define __GRAPHICS_H__ 3 | #include 4 | #include 5 | #include 6 | #include "imageData/imageData.h" 7 | 8 | typedef struct 9 | { 10 | unsigned int textureId; 11 | unsigned int VAO; 12 | unsigned int shaderProgram; 13 | PointI mousePosition; 14 | bool mouseRightDown; 15 | GLFWwindow *window; 16 | ImageData imageData; 17 | } Graphics; 18 | 19 | Graphics graphicsCreate(int width, int height); 20 | void graphicsRender(Graphics this); 21 | void graphicsDestroy(Graphics this); 22 | void graphicsUpdateMouseCoordinates(Graphics *this); 23 | #endif -------------------------------------------------------------------------------- /src/program/core/graphics/imageData/imageData.c: -------------------------------------------------------------------------------- 1 | #include "imageData.h" 2 | #include 3 | #include 4 | #include 5 | 6 | extern char fonts[][5]; 7 | 8 | void imPutPixel(ImageData this, PointI point, Color color) 9 | { 10 | int position = (point.x + point.y * this.size.x); 11 | this.data[position] = color; 12 | } 13 | 14 | inline Color imGetPixel(ImageData this, PointU point) 15 | { 16 | int position = point.x + point.y * this.size.x; 17 | return this.data[position]; 18 | } 19 | 20 | void imDrawCircle(ImageData this, PointI center, double radious, Color color) 21 | { 22 | for (int i = center.x - radious; i <= center.x + radious; i++) 23 | { 24 | for (int j = center.y - radious; j <= center.y + radious; j++) 25 | { 26 | if (floor(sqrt(pow(center.x - i, 2) + pow(center.y - j, 2))) == radious) 27 | imPutPixel(this, (PointI){i, j}, color); 28 | } 29 | } 30 | } 31 | 32 | void imDrawSquare(ImageData this, PointI topLeftCorner, PointI size, Color color) 33 | { 34 | for (int i = topLeftCorner.x; i <= topLeftCorner.x + size.x; i++) 35 | { 36 | for (int j = topLeftCorner.y; j <= topLeftCorner.y + size.y; j++) 37 | { 38 | if (j == topLeftCorner.y || j == topLeftCorner.y + size.y || i == topLeftCorner.x || i == topLeftCorner.x + size.x) 39 | imPutPixel(this, (PointI){i, j}, color); 40 | } 41 | } 42 | } 43 | 44 | void imDrawCircleFill(ImageData this, PointI center, double radious, Color color) 45 | { 46 | for (int i = center.x - radious; i <= center.x + radious; i++) 47 | { 48 | for (int j = center.y - radious; j <= center.y + radious; j++) 49 | { 50 | if (floor(sqrt(pow(center.x - i, 2) + pow(center.y - j, 2))) == radious) 51 | imPutPixel(this, (PointI){i, j}, color); 52 | } 53 | } 54 | } 55 | 56 | void imClear(ImageData this) 57 | { 58 | memset(this.data, 0, this.bufferSize); 59 | } 60 | 61 | void imClearTransparent(ImageData this) 62 | { 63 | const int limit = this.size.x * this.size.y; 64 | for (int i = 0; i < limit; i++) 65 | { 66 | this.data[i] = (Color){0xFF, 0, 0xFF}; 67 | } 68 | } 69 | 70 | void imClearColor(ImageData this, Color color) 71 | { 72 | const int limit = this.size.x * this.size.y; 73 | for (int i = 0; i < limit; i++) 74 | { 75 | this.data[i] = color; 76 | } 77 | } 78 | 79 | void imDrawCharacter(ImageData this, PointI topLeftCorner, unsigned int letter, Color color) 80 | { 81 | for (int i = 0; i < 5; i++) 82 | { 83 | for (int j = 0; j <= 8; j++) 84 | { 85 | if (fonts[letter][i] & (0b1000000 >> j)) 86 | imPutPixel(this, (PointI){topLeftCorner.x + j, topLeftCorner.y + i}, color); 87 | } 88 | } 89 | } 90 | 91 | void imPrintFontTest(ImageData this) 92 | { 93 | for (int i = 0; i < 255; i++) 94 | { 95 | imDrawCharacter(this, (PointI){i * 6, 100}, i, (Color){0xff, 0xff, 0xff}); 96 | } 97 | } 98 | 99 | void imPrintString(ImageData this, PointI topLeftCorner, char *string, Color color) 100 | { 101 | size_t stringLen = strlen(string); 102 | for (size_t i = 0; i < stringLen; i++) 103 | { 104 | int charOffset = string[i]; 105 | imDrawCharacter(this, (PointI){topLeftCorner.x + i * 6, topLeftCorner.y}, charOffset, color); 106 | } 107 | } 108 | 109 | void imDrawLine(ImageData this, PointI pointA, PointI pointB, Color color) 110 | { 111 | 112 | int dx = abs(pointB.x - pointA.x), sx = pointA.x < pointB.x ? 1 : -1; 113 | int dy = abs(pointB.y - pointA.y), sy = pointA.y < pointB.y ? 1 : -1; 114 | int err = (dx > dy ? dx : -dy) / 2, e2; 115 | 116 | for (;;) 117 | { 118 | imPutPixel(this, pointA, color); 119 | if (pointA.x == pointB.x && pointA.y == pointB.y) 120 | break; 121 | e2 = err; 122 | if (e2 > -dx) 123 | { 124 | err -= dy; 125 | pointA.x += sx; 126 | } 127 | if (e2 < dy) 128 | { 129 | err += dx; 130 | pointA.y += sy; 131 | } 132 | } 133 | } 134 | 135 | void imDrawSquareFill(ImageData this, PointI topLeftCorner, PointI size, Color color) 136 | { 137 | for (int i = topLeftCorner.x; i <= topLeftCorner.x + size.x; i++) 138 | { 139 | for (int j = topLeftCorner.y; j <= topLeftCorner.y + size.y; j++) 140 | { 141 | imPutPixel(this, (PointI){i, j}, color); 142 | } 143 | } 144 | } 145 | 146 | inline PointI pointFToPointI(PointF source) 147 | { 148 | return (PointI){(int)source.x, (int)source.y}; 149 | } 150 | 151 | inline PointU pointIToPointU(PointI source) 152 | { 153 | return (PointU){(unsigned int)abs(source.x), (unsigned int)abs(source.y)}; 154 | } 155 | 156 | inline PointU pointFToPointU(PointF source) 157 | { 158 | return (PointU){(unsigned int)abs((int)round(source.x)), (unsigned int)abs((int)round(source.y))}; 159 | } -------------------------------------------------------------------------------- /src/program/core/graphics/imageData/imageData.h: -------------------------------------------------------------------------------- 1 | #ifndef __IMAGE_DATA_H__ 2 | #define __IMAGE_DATA_H__ 3 | 4 | typedef struct 5 | { 6 | unsigned char r, g, b; 7 | } Color; 8 | 9 | typedef struct 10 | { 11 | int x; 12 | int y; 13 | } PointI; 14 | 15 | typedef struct 16 | { 17 | unsigned int x; 18 | unsigned int y; 19 | } PointU; 20 | 21 | typedef struct 22 | { 23 | double x; 24 | double y; 25 | } PointF; 26 | 27 | typedef struct 28 | { 29 | PointI size; 30 | int bufferSize; 31 | int elementCount; 32 | Color *data; 33 | } ImageData; 34 | 35 | void imPutPixel(ImageData this, PointI point, Color color); 36 | void imDrawCircle(ImageData this, PointI center, double radious, Color color); 37 | void imDrawCircleFill(ImageData this, PointI center, double radious, Color color); 38 | void imDrawSquare(ImageData this, PointI topLeftCorner, PointI size, Color color); 39 | void imClear(ImageData this); 40 | void imClearColor(ImageData this, Color color); 41 | void imClearTransparent(ImageData this); 42 | void imDrawCharacter(ImageData this, PointI topLeftCorner, unsigned int letter, Color color); 43 | void imPrintFontTest(ImageData this); 44 | void imPrintString(ImageData this, PointI topLeftCorner, char *string, Color color); 45 | void imDrawLine(ImageData this, PointI pointA, PointI pointB, Color color); 46 | Color imGetPixel(ImageData this, PointU point); 47 | PointI pointFToPointI(PointF); 48 | PointU pointIToPointU(PointI); 49 | PointU pointFToPointU(PointF source); 50 | 51 | #endif -------------------------------------------------------------------------------- /src/program/core/input/input.h: -------------------------------------------------------------------------------- 1 | #ifndef __INPUT_H__ 2 | #define __INPUT_H__ 3 | 4 | #include "keyboard.h" 5 | #include "mouse.h" 6 | 7 | #endif -------------------------------------------------------------------------------- /src/program/core/input/keyboard.c: -------------------------------------------------------------------------------- 1 | #include "keyboard.h" 2 | #include 3 | 4 | static int keys[255] = {0}; 5 | 6 | bool isKeyJustPressed(GLFWwindow *window, int key) 7 | { 8 | int actualKeyState = glfwGetKey(window, key); 9 | 10 | if (keys[key] == GLFW_PRESS && actualKeyState == GLFW_PRESS) 11 | return false; 12 | 13 | keys[key] = actualKeyState; 14 | 15 | return actualKeyState == GLFW_PRESS; 16 | } -------------------------------------------------------------------------------- /src/program/core/input/keyboard.h: -------------------------------------------------------------------------------- 1 | #ifndef __KEYBOARD_H__ 2 | #define __KEYBOARD_H__ 3 | 4 | #include 5 | #include 6 | 7 | bool isKeyJustPressed(GLFWwindow *window, int key); 8 | 9 | #endif -------------------------------------------------------------------------------- /src/program/core/input/mouse.c: -------------------------------------------------------------------------------- 1 | #include "mouse.h" 2 | 3 | static int mouseButtons[3] = {0}; 4 | 5 | bool isMouseButtonJustPressed(GLFWwindow *window, int mouseButton) 6 | { 7 | int currentMouseState = glfwGetMouseButton(window, GLFW_MOUSE_BUTTON_1); 8 | 9 | if (mouseButtons[mouseButton] && currentMouseState) 10 | return false; 11 | 12 | mouseButtons[mouseButton] = currentMouseState; 13 | 14 | return currentMouseState; 15 | } -------------------------------------------------------------------------------- /src/program/core/input/mouse.h: -------------------------------------------------------------------------------- 1 | #ifndef __MOUSE_H__ 2 | #define __MOUSE_H__ 3 | #include 4 | #include 5 | 6 | bool isMouseButtonJustPressed(GLFWwindow *window, int mouseButton); 7 | 8 | #endif -------------------------------------------------------------------------------- /src/program/core/queue/queue.c: -------------------------------------------------------------------------------- 1 | #include "queue.h" 2 | #include 3 | 4 | bool queueIsEmpty(Queue this) 5 | { 6 | return this.head->next == NULL; 7 | } 8 | 9 | Node *nodeCreate(void *data) 10 | { 11 | Node *this = malloc(sizeof(Node)); 12 | this->data = data; 13 | this->next = this; 14 | return this; 15 | } 16 | 17 | void queueEnqueue(Queue *this, void *data) 18 | { 19 | 20 | Node *node = nodeCreate(data); 21 | if (this->head == NULL) 22 | { 23 | this->head = node; 24 | this->tail = this->head; 25 | this->head->next = this->tail; 26 | } 27 | else 28 | { 29 | this->tail->next = node; 30 | this->tail = node; 31 | } 32 | } 33 | 34 | void *queueDequeue(Queue *this) 35 | { 36 | if (this->head == NULL) 37 | return NULL; 38 | 39 | void *data; 40 | 41 | Node *headNode = this->head; 42 | data = headNode->data; 43 | 44 | if (this->head == this->head->next) 45 | { 46 | this->head = NULL; 47 | this->tail = NULL; 48 | } 49 | else 50 | { 51 | this->head = this->head->next; 52 | } 53 | 54 | if (headNode) 55 | { 56 | free(headNode); 57 | } 58 | 59 | return data; 60 | } 61 | 62 | void queueDestroy(Queue *this) 63 | { 64 | while (this->head) 65 | { 66 | Node *oldHead = this->head; 67 | if (this->head->next == this->head) 68 | { 69 | this->head->next = NULL; 70 | } 71 | this->head = this->head->next; 72 | free(oldHead); 73 | } 74 | 75 | this->tail = NULL; 76 | } 77 | -------------------------------------------------------------------------------- /src/program/core/queue/queue.h: -------------------------------------------------------------------------------- 1 | #ifndef __QUEUE_H__ 2 | #define __QUEUE_H__ 3 | 4 | #include 5 | #include 6 | 7 | struct Node; 8 | 9 | typedef struct Node 10 | { 11 | void *data; 12 | struct Node *next; 13 | } Node; 14 | 15 | typedef struct 16 | { 17 | Node *head; 18 | Node *tail; 19 | } Queue; 20 | 21 | bool queueIsEmpty(Queue this); 22 | Node *nodeCreate(void *data); 23 | void queueEnqueue(Queue *this, void *data); 24 | void *queueDequeue(Queue *this); 25 | void queueDestroy(Queue *this); 26 | 27 | #endif -------------------------------------------------------------------------------- /src/program/core/shader/shader.c: -------------------------------------------------------------------------------- 1 | #include "shader.h" 2 | #include 3 | 4 | static int shaderCreateFromFile(const char *fileName, unsigned int *vertexShader, int shaderType) 5 | { 6 | int returnValue = 0; 7 | size_t fileSize = 0; 8 | char *shaderCode = NULL; 9 | *vertexShader = glCreateShader(shaderType); 10 | 11 | FILE *fp = fopen(fileName, "r"); 12 | 13 | if (fp == NULL) 14 | { 15 | fprintf(stderr, "Error opening file\n"); 16 | returnValue = -1; 17 | goto error_handler; 18 | } 19 | 20 | if (fseek(fp, 0, SEEK_END) != 0) 21 | { 22 | perror("Error obtaining the file size "); 23 | returnValue = -1; 24 | goto error_handler; 25 | } 26 | 27 | fileSize = ftell(fp); 28 | fseek(fp, 0, SEEK_SET); 29 | 30 | shaderCode = malloc(fileSize + 1 * sizeof(char)); 31 | 32 | if (shaderCode == NULL) 33 | { 34 | returnValue = -1; 35 | goto error_handler; 36 | } 37 | 38 | if (fread(shaderCode, sizeof(char), fileSize, fp) != fileSize) 39 | { 40 | fprintf(stderr, "Error opening shader %s\n", fileName); 41 | exit(-1); 42 | } 43 | 44 | glShaderSource(*vertexShader, 1, (const char **)&shaderCode, NULL); 45 | 46 | glCompileShader(*vertexShader); 47 | 48 | int shaderCompilationSuccess; 49 | char infoLog[512]; 50 | 51 | glGetShaderiv(*vertexShader, GL_COMPILE_STATUS, &shaderCompilationSuccess); 52 | 53 | if (!shaderCompilationSuccess) 54 | { 55 | glGetShaderInfoLog(*vertexShader, 512, NULL, infoLog); 56 | printf("%s::%s : vertex shader compilation failed. Error %s\n", __FILE__, __func__, infoLog); 57 | returnValue = -1; 58 | goto error_handler; 59 | } 60 | 61 | error_handler: 62 | if (shaderCode != NULL) 63 | free(shaderCode); 64 | if (fp != NULL) 65 | fclose(fp); 66 | 67 | return returnValue; 68 | } 69 | 70 | unsigned int shaderProgramCreateFromFiles(const char *vertexShaderPath, const char *fragmentShaderPath) 71 | { 72 | unsigned int vs, fs; 73 | 74 | shaderCreateFromFile(vertexShaderPath, &vs, GL_VERTEX_SHADER); 75 | shaderCreateFromFile(fragmentShaderPath, &fs, GL_FRAGMENT_SHADER); 76 | 77 | unsigned int shaderProgram = glCreateProgram(); 78 | glAttachShader(shaderProgram, vs); 79 | glAttachShader(shaderProgram, fs); 80 | if (vs == 0 || fs == 0) 81 | { 82 | fprintf(stderr, "error loading shadfer files\n"); 83 | exit(-1); 84 | } 85 | glLinkProgram(shaderProgram); 86 | 87 | int success; 88 | 89 | glGetProgramiv(shaderProgram, GL_LINK_STATUS, &success); 90 | if (!success) 91 | { 92 | char infoLog[512]; 93 | glGetProgramInfoLog(shaderProgram, 512, NULL, infoLog); 94 | printf("%s::%s - Error linking shader program: %s\n", __FILE__, __func__, infoLog); 95 | exit(-1); 96 | } 97 | 98 | glDeleteShader(vs); 99 | glDeleteShader(fs); 100 | return shaderProgram; 101 | } 102 | 103 | void shaderSetUniformValueMatrix4F(unsigned int shaderProgram, char *uniformName, const float *value) 104 | { 105 | glUseProgram(shaderProgram); 106 | int loc = glGetUniformLocation(shaderProgram, uniformName); 107 | glUniformMatrix4fv(loc, 1, GL_FALSE, value); 108 | } 109 | 110 | void shaderSetUniformValueMatrix3F(unsigned int shaderProgram, char *uniformName, const float *value) 111 | { 112 | glUseProgram(shaderProgram); 113 | int loc = glGetUniformLocation(shaderProgram, uniformName); 114 | glUniformMatrix3fv(loc, 1, GL_FALSE, value); 115 | } 116 | 117 | void shaderSetUniformValue3F(unsigned int shaderProgram, char *uniformName, const float *value) 118 | { 119 | glUseProgram(shaderProgram); 120 | int location = glGetUniformLocation(shaderProgram, uniformName); 121 | glUniform3f(location, value[0], value[1], value[2]); 122 | } 123 | 124 | void shaderSetUniformValueF(unsigned int shaderProgram, char *uniformName, const float value) 125 | { 126 | glUseProgram(shaderProgram); 127 | int location = glGetUniformLocation(shaderProgram, uniformName); 128 | glUniform1f(location, value); 129 | } 130 | 131 | void shaderSetUniformValueI(unsigned int shaderProgram, char *uniformName, const int value) 132 | { 133 | glUseProgram(shaderProgram); 134 | int location = glGetUniformLocation(shaderProgram, uniformName); 135 | glUniform1i(location, value); 136 | } -------------------------------------------------------------------------------- /src/program/core/shader/shader.h: -------------------------------------------------------------------------------- 1 | #ifndef __SHADER_H__ 2 | #define __SHADER_H__ 3 | 4 | #include 5 | #include 6 | 7 | unsigned int shaderProgramCreateFromFiles(const char *vertexShaderPath, const char *fragmentShaderPath); 8 | void shaderSetUniformValueMatrix4F(unsigned int shaderProgram, char *uniformName, const float *value); 9 | void shaderSetUniformValueMatrix3F(unsigned int shaderProgram, char *uniformName, const float *value); 10 | void shaderSetUniformValue3F(unsigned int shaderProgram, char *uniformName, const float *value); 11 | void shaderSetUniformValueF(unsigned int shaderProgram, char *uniformName, const float value); 12 | void shaderSetUniformValueI(unsigned int shaderProgram, char *uniformName, const int value); 13 | 14 | #endif -------------------------------------------------------------------------------- /src/program/core/sprite/sprite.c: -------------------------------------------------------------------------------- 1 | #include "sprite.h" 2 | #include 3 | #include 4 | 5 | Sprite spriteCreate(char *file) 6 | { 7 | Sprite this = {0}; 8 | int nrChannels; 9 | this.imageData.data = (Color *)stbi_load(file, &this.imageData.size.x, &this.imageData.size.y, &nrChannels, 0); 10 | this.imageData.elementCount = this.imageData.size.x * this.imageData.size.y; 11 | this.imageData.bufferSize = this.imageData.elementCount * sizeof(char) * nrChannels; 12 | if (this.imageData.data == NULL) 13 | { 14 | fprintf(stderr, "Error loading file %s. Aborting.\n", file); 15 | exit(-1); 16 | } 17 | return this; 18 | } 19 | 20 | void spriteDraw(Sprite this, ImageData imageData) 21 | { 22 | for (int i = 0; i < this.imageData.size.x; i++) 23 | { 24 | for (int j = 0; j < this.imageData.size.y; j++) 25 | { 26 | Color color = this.imageData.data[j * this.imageData.size.x + i]; 27 | imPutPixel(imageData, (PointI){this.position.x + i, this.position.y + j}, color); 28 | } 29 | } 30 | } 31 | 32 | void spriteDrawClipped(Sprite this, ImageData imageData) 33 | { 34 | int clippedWidth = fmin(this.imageData.size.x, fmax(0, this.imageData.size.x - (this.imageData.size.x + this.position.x - imageData.size.x))); 35 | int clippedHeight = fmin(this.imageData.size.y, fmax(0, this.imageData.size.y - (this.imageData.size.y + this.position.y - imageData.size.y))); 36 | int clippedX = this.position.x < 0 ? -this.position.x : 0; 37 | int clippedY = this.position.y < 0 ? -this.position.y : 0; 38 | for (int i = clippedX; i < clippedWidth; i++) 39 | { 40 | for (int j = clippedY; j < clippedHeight; j++) 41 | { 42 | Color color = this.imageData.data[j * this.imageData.size.x + i]; 43 | imPutPixel(imageData, (PointI){this.position.x + i, this.position.y + j}, color); 44 | } 45 | } 46 | } 47 | 48 | void spriteDrawTransparent(Sprite this, ImageData imageData) 49 | { 50 | for (int i = 0; i < this.imageData.size.x; i++) 51 | { 52 | for (int j = 0; j < this.imageData.size.y; j++) 53 | { 54 | Color color = this.imageData.data[j * this.imageData.size.x + i]; 55 | if (!(color.r == 0xFF && color.b == 0xFF && color.g == 0)) 56 | imPutPixel(imageData, (PointI){this.position.x + i, this.position.y + j}, color); 57 | } 58 | } 59 | } 60 | 61 | void spriteDrawTransparentClipped(Sprite this, ImageData imageData) 62 | { 63 | int clippedWidth = fmin(this.imageData.size.x, 64 | fmax(0, this.imageData.size.x - (this.imageData.size.x + this.position.x - imageData.size.x))); 65 | int clippedHeight = fmin(this.imageData.size.y, 66 | fmax(0, this.imageData.size.y - (this.imageData.size.y + this.position.y - imageData.size.y))); 67 | int clippedX = this.position.x < 0 ? -this.position.x : 0; 68 | int clippedY = this.position.y < 0 ? -this.position.y : 0; 69 | for (int i = clippedX; i < clippedWidth; i++) 70 | { 71 | for (int j = clippedY; j < clippedHeight; j++) 72 | { 73 | Color color = this.imageData.data[j * this.imageData.size.x + i]; 74 | if (!(color.r == 0xFF && color.b == 0xFF && color.g == 0)) 75 | imPutPixel(imageData, (PointI){this.position.x + i, this.position.y + j}, color); 76 | } 77 | } 78 | } 79 | 80 | void spriteDestroy(Sprite this) 81 | { 82 | free(this.imageData.data); 83 | } 84 | 85 | Sprite spriteCreateCkeckerBoard(PointI size, int checkerWidth, Color color1, Color color2) 86 | { 87 | Sprite this = {0}; 88 | Color currentColor = color1; 89 | this.imageData.data = malloc(sizeof(Color) * size.x * size.y); 90 | this.imageData.size = size; 91 | for (int y = 0; y < this.imageData.size.y; y++) 92 | { 93 | for (int x = 0; x < this.imageData.size.x; x++) 94 | { 95 | if ((y / checkerWidth + x / checkerWidth) % 2) 96 | { 97 | currentColor = color1; 98 | } 99 | else 100 | { 101 | currentColor = color2; 102 | } 103 | this.imageData.data[x + y * size.x] = currentColor; 104 | } 105 | } 106 | return this; 107 | } 108 | 109 | void spriteDrawTransparentAnimatedClipped(Sprite *thisP, ImageData imageData, double deltaTime) 110 | { 111 | Sprite this = *thisP; 112 | 113 | int clippedWidth = fmin(this.animation.frameWidth, 114 | fmax(0, this.animation.frameWidth - (this.animation.frameWidth + this.position.x - 115 | imageData.size.x))); 116 | int clippedHeight = fmin(this.imageData.size.y, 117 | fmax(0, this.imageData.size.y - (this.imageData.size.y + this.position.y - 118 | imageData.size.y))); 119 | int clippedX = this.position.x < 0 ? -this.position.x : 0; 120 | int clippedY = this.position.y < 0 ? -this.position.y : 0; 121 | 122 | thisP->animation.frameIncrement += deltaTime * 30; 123 | thisP->animation.currentFrame = this.animation.frameIncrement; 124 | thisP->animation.currentFrame %= this.animation.frameCount; 125 | 126 | for (int i = clippedX; i < clippedWidth; i++) 127 | { 128 | for (int j = clippedY; j < clippedHeight; j++) 129 | { 130 | Color color = this.imageData.data[j * this.imageData.size.x + i + 131 | this.animation.currentFrame * this.animation.frameWidth]; 132 | if (!(color.r == 0xFF && color.b == 0xFF && color.g == 0)) 133 | imPutPixel(imageData, 134 | (PointI){this.position.x + i, this.position.y + j}, 135 | color); 136 | } 137 | } 138 | } 139 | -------------------------------------------------------------------------------- /src/program/core/sprite/sprite.h: -------------------------------------------------------------------------------- 1 | #ifndef __SPRITE_H__ 2 | #define __SPRITE_H__ 3 | 4 | #include "../graphics/imageData/imageData.h" 5 | #include 6 | 7 | typedef struct 8 | { 9 | int frameWidth; 10 | int t; 11 | int currentFrame; 12 | int frameCount; 13 | float frameIncrement; 14 | float inverseFramerrate; 15 | } Animation; 16 | 17 | typedef struct 18 | { 19 | bool animated; 20 | Animation animation; 21 | PointF position; 22 | ImageData imageData; 23 | } Sprite; 24 | 25 | Sprite spriteCreate(char *file); 26 | void spriteDraw(Sprite this, ImageData imageData); 27 | void spriteDrawClipped(Sprite this, ImageData imageData); 28 | void spriteDrawTransparent(Sprite this, ImageData ImageData); 29 | void spriteDrawTransparentClipped(Sprite this, ImageData imageData); 30 | void spriteDrawTransparentAnimatedClipped(Sprite *thisP, ImageData imageData, double deltaTime); 31 | void spriteDestroy(Sprite this); 32 | Sprite spriteCreateCkeckerBoard(PointI size, int checkerWidth, Color color1, Color color2); 33 | 34 | #endif 35 | -------------------------------------------------------------------------------- /src/program/program.c: -------------------------------------------------------------------------------- 1 | #include "program.h" 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #define _GNU_SOURCE 8 | #include 9 | #include 10 | #include 11 | #include "core/input/input.h" 12 | #include "utils/utils.h" 13 | #include "vec3/vec3.h" 14 | 15 | #define MODULE 1048576 16 | 17 | #define MIN(X, Y) (((X) < (Y)) ? (X) : (Y)) 18 | #define MAX(X, Y) (((X) > (Y)) ? (X) : (Y)) 19 | 20 | #ifdef ARRAY_MALLOC 21 | #undef ARRAY_MALLOC 22 | #endif 23 | 24 | #ifdef ARRAY_REALLOC 25 | #undef ARRAY_REALLOC 26 | #endif 27 | 28 | #define DEMO_MODE 29 | 30 | #define __UNIVERSAL_ARRAY_IMPLEMENTATION__ 31 | #include "core/array/array.h" 32 | 33 | #define STB_IMAGE_IMPLEMENTATION 34 | #include 35 | 36 | #include "core/queue/queue.h" 37 | 38 | pthread_mutex_t mutexMain = PTHREAD_MUTEX_INITIALIZER; 39 | pthread_mutex_t referenceCounterLock = PTHREAD_MUTEX_INITIALIZER; 40 | pthread_cond_t condVar = PTHREAD_COND_INITIALIZER; 41 | int refCounter = 0; 42 | Queue taskQ = {0}; 43 | 44 | void *imRenderVoxelSpaceSlice(); 45 | static inline void processDemoMode(Program *this); 46 | static inline void processInput(Program *this); 47 | static inline void initThreads(Program *this); 48 | static inline void initThreadInfo(Program *this); 49 | static inline void enqueueTasks(Program *this); 50 | static inline void waitForTasksToFinish(void); 51 | static inline void drawSlicesIntoTexture(Program *this); 52 | 53 | Program programCreate() 54 | { 55 | Program this = {0}; 56 | 57 | float aspectRatio = 4.0 / 3.0; 58 | int wideSize = 800; 59 | this.graphics = graphicsCreate(wideSize, wideSize / aspectRatio); 60 | 61 | glfwSwapInterval(0); 62 | 63 | char *heightMapNames[] = { 64 | "assets/snow-watery-height.png", 65 | "assets/forest-watery-height.png", 66 | "assets/height.png", 67 | "assets/mountains-desert-height.png", 68 | "assets/mountains-height.png", 69 | "assets/desert-height.png"}; 70 | 71 | char *colorMapNames[] = { 72 | "assets/snow-watery-color.png", 73 | "assets/forest-watery-color.png", 74 | "assets/color.png", 75 | "assets/mountains-desert-color.png", 76 | "assets/mountains-color.png", 77 | "assets/desert-color.png"}; 78 | 79 | for (int i = 0; i < MAP_COUNT; i++) 80 | { 81 | this.heightMaps[i] = spriteCreate(heightMapNames[i]); 82 | this.colorMaps[i] = spriteCreate(colorMapNames[i]); 83 | } 84 | 85 | this.stopwatchStart = glfwGetTime(); 86 | 87 | this.height = 200; 88 | this.horizon = 50; 89 | this.scale.y = 400; 90 | this.distance = 4000; 91 | this.cameraSpeed = 250.0; 92 | this.angularSpeed = 0.5; 93 | this.levelOfDetail = 0.01; 94 | return this; 95 | } 96 | 97 | void programMainLoop(Program this) 98 | { 99 | double lastUpdate = 0; 100 | bool demoMode = true; 101 | 102 | initThreads(&this); 103 | initThreadInfo(&this); 104 | 105 | this.lastCameraPosition = this.cameraPosition; 106 | this.lastAngle = this.lookingAngle; 107 | 108 | while (glfwGetKey(this.graphics.window, GLFW_KEY_ESCAPE) != GLFW_PRESS) 109 | { 110 | this.deltaTime = glfwGetTime() - lastUpdate; 111 | lastUpdate = glfwGetTime(); 112 | 113 | #ifdef DEMO_MODE 114 | processDemoMode(&this); 115 | #else 116 | processInput(&this); 117 | #endif 118 | 119 | enqueueTasks(&this); 120 | waitForTasksToFinish(); 121 | drawSlicesIntoTexture(&this); 122 | 123 | printFPS(this.graphics, getDeltaTime()); 124 | graphicsRender(this.graphics); 125 | glfwPollEvents(); 126 | this.lastCameraPosition = this.cameraPosition; 127 | this.lastAngle = this.lookingAngle; 128 | } 129 | } 130 | 131 | void programDestroy(Program this) 132 | { 133 | pthread_mutex_destroy(&mutexMain); 134 | pthread_mutex_destroy(&referenceCounterLock); 135 | for (int i = 0; i < MAP_COUNT; i++) 136 | { 137 | spriteDestroy(this.heightMaps[i]); 138 | spriteDestroy(this.colorMaps[i]); 139 | } 140 | graphicsDestroy(this.graphics); 141 | } 142 | 143 | void drawVerticalLine(ImageData this, PointI start, Color color, int maxHeight) 144 | { 145 | for (int i = start.y; i < maxHeight; i++) 146 | { 147 | start.y = i; 148 | imPutPixel(this, start, color); 149 | } 150 | } 151 | 152 | void *imRenderVoxelSpaceSlice() 153 | { 154 | PthreadInfo *this = NULL; 155 | 156 | while (true) 157 | { 158 | pthread_mutex_lock(&mutexMain); 159 | pthread_cond_wait(&condVar, &mutexMain); 160 | this = (PthreadInfo *)queueDequeue(&taskQ); 161 | pthread_mutex_unlock(&mutexMain); 162 | 163 | if (this != NULL) 164 | { 165 | PthreadInfo that = *this; 166 | double angle = that.program->lookingAngle; 167 | 168 | PointF pLeft = {0}; 169 | PointF pRight = {0}; 170 | 171 | // precalculate viewing angle parameters 172 | double sinphi = sinf(angle); 173 | double cosphi = cosf(angle); 174 | 175 | double dz = 1.0; 176 | 177 | int maxHeight[that.imageData.size.x]; 178 | 179 | for (int i = 0; i < that.imageData.size.x; i++) 180 | { 181 | maxHeight[i] = that.program->graphics.imageData.size.y - 1; 182 | } 183 | 184 | double z = 1.0; 185 | imClear(that.imageData); 186 | while (z < that.program->distance) 187 | { 188 | 189 | pLeft = (PointF){(-cosphi - sinphi) * z + that.program->cameraPosition.x, (sinphi - cosphi) * z + that.program->cameraPosition.y}; 190 | pRight = (PointF){(cosphi - sinphi) * z + that.program->cameraPosition.x, (-sinphi - cosphi) * z + that.program->cameraPosition.y}; 191 | 192 | double dx = (pRight.x - pLeft.x) / that.program->graphics.imageData.size.x + (that.startColumn / that.program->graphics.imageData.size.x); 193 | double dy = (pRight.y - pLeft.y) / that.program->graphics.imageData.size.y; 194 | 195 | pLeft.x += dx * that.startColumn; 196 | pLeft.y += dy * that.startColumn; 197 | 198 | for (int i = 0; i < that.imageData.size.x; i++) 199 | { 200 | PointU mappedPoint = pointFToPointU(pLeft); 201 | 202 | unsigned int position = (mappedPoint.x + mappedPoint.y * that.program->colorMaps[that.program->mapIndex].imageData.size.x); 203 | 204 | position %= MODULE; 205 | Color colorMapColor = that.program->colorMaps[that.program->mapIndex].imageData.data[position]; 206 | 207 | double colorRatio = (that.program->distance - z) / that.program->distance; 208 | 209 | colorMapColor.r *= colorRatio; 210 | colorMapColor.g *= colorRatio; 211 | colorMapColor.b *= colorRatio; 212 | 213 | position = (mappedPoint.x + mappedPoint.y * that.program->heightMaps[that.program->mapIndex].imageData.size.x); 214 | position %= that.program->heightMaps[that.program->mapIndex].imageData.bufferSize; 215 | char heightMapColor = ((char *)that.program->heightMaps[that.program->mapIndex].imageData.data)[position]; 216 | int heightOnScreen = (that.program->height - heightMapColor) / (float)z * that.program->scale.y + that.program->horizon; 217 | 218 | heightOnScreen = MIN(MAX(heightOnScreen, 0), that.imageData.size.y); 219 | drawVerticalLine(that.imageData, (PointI){i, heightOnScreen}, colorMapColor, maxHeight[i]); 220 | pLeft.x += dx; 221 | pLeft.y += dy; 222 | maxHeight[i] = MIN(heightOnScreen, maxHeight[i]); 223 | } 224 | z += dz; 225 | dz += that.program->levelOfDetail; 226 | } 227 | pthread_mutex_lock(&referenceCounterLock); 228 | refCounter--; 229 | pthread_mutex_unlock(&referenceCounterLock); 230 | } 231 | } 232 | return NULL; 233 | } 234 | 235 | static inline void processDemoMode(Program *this) 236 | { 237 | this->cameraPosition.y += this->cameraSpeed * this->deltaTime; 238 | this->cameraPosition.x += this->cameraSpeed * this->deltaTime; 239 | this->lookingAngle -= this->angularSpeed * this->deltaTime; 240 | if (glfwGetTime() - this->stopwatchStart > 3.0) 241 | { 242 | this->mapIndex += 1; 243 | this->mapIndex %= MAP_COUNT; 244 | this->stopwatchStart = glfwGetTime(); 245 | } 246 | } 247 | 248 | static inline void processInput(Program *this) 249 | { 250 | if (glfwGetKey(this->graphics.window, GLFW_KEY_F1) == GLFW_PRESS) 251 | this->scale.x = this->scale.y += 10; 252 | else if (glfwGetKey(this->graphics.window, GLFW_KEY_F2) == GLFW_PRESS) 253 | this->scale.x = this->scale.y -= 10; 254 | 255 | if (glfwGetKey(this->graphics.window, GLFW_KEY_F3) == GLFW_PRESS) 256 | this->distance += 100; 257 | else if (glfwGetKey(this->graphics.window, GLFW_KEY_F4) == GLFW_PRESS) 258 | this->distance -= 100; 259 | 260 | if (glfwGetKey(this->graphics.window, GLFW_KEY_LEFT) == GLFW_PRESS) 261 | this->cameraPosition.x += this->cameraSpeed * this->deltaTime; 262 | else if (glfwGetKey(this->graphics.window, GLFW_KEY_RIGHT) == GLFW_PRESS) 263 | this->cameraPosition.x -= this->cameraSpeed * this->deltaTime; 264 | 265 | if (glfwGetKey(this->graphics.window, GLFW_KEY_UP) == GLFW_PRESS) 266 | this->cameraPosition.y -= this->cameraSpeed * this->deltaTime; 267 | else if (glfwGetKey(this->graphics.window, GLFW_KEY_DOWN) == GLFW_PRESS) 268 | this->cameraPosition.y += this->cameraSpeed * this->deltaTime; 269 | 270 | if (glfwGetKey(this->graphics.window, GLFW_KEY_I) == GLFW_PRESS) 271 | this->height += this->cameraSpeed * this->deltaTime; 272 | else if (glfwGetKey(this->graphics.window, GLFW_KEY_O) == GLFW_PRESS) 273 | this->height -= this->cameraSpeed * this->deltaTime; 274 | 275 | if (glfwGetKey(this->graphics.window, GLFW_KEY_A) == GLFW_PRESS) 276 | this->lookingAngle += this->angularSpeed * this->deltaTime; 277 | else if (glfwGetKey(this->graphics.window, GLFW_KEY_D) == GLFW_PRESS) 278 | this->lookingAngle -= this->angularSpeed * this->deltaTime; 279 | 280 | if (this->cameraPosition.x - this->lastCameraPosition.x + this->cameraPosition.y - this->lastCameraPosition.y + this->lookingAngle - this->lastAngle != 0) 281 | { 282 | this->levelOfDetail = 0.05; 283 | } 284 | else 285 | { 286 | this->levelOfDetail = 0.01; 287 | } 288 | 289 | if (isKeyJustPressed(this->graphics.window, GLFW_KEY_K)) 290 | { 291 | this->mapIndex++; 292 | this->mapIndex %= MAP_COUNT; 293 | } 294 | 295 | if (isKeyJustPressed(this->graphics.window, GLFW_KEY_L)) 296 | { 297 | this->mapIndex--; 298 | this->mapIndex %= MAP_COUNT; 299 | } 300 | } 301 | 302 | static inline void initThreads(Program *this) 303 | { 304 | for (int i = 0; i < PTHREAD_COUNT; i++) 305 | { 306 | this->pthreads[i].program = this; 307 | pthread_create(&this->pthreads[i].handler, NULL, imRenderVoxelSpaceSlice, NULL); 308 | } 309 | } 310 | 311 | static inline void initThreadInfo(Program *this) 312 | { 313 | for (int i = 0; i < PTHREAD_COUNT; i++) 314 | { 315 | this->pthreads[i].program = this; 316 | this->pthreads[i].imageData.bufferSize = this->graphics.imageData.bufferSize / PTHREAD_COUNT; 317 | this->pthreads[i].imageData.data = (Color *)malloc(this->pthreads[i].imageData.bufferSize); 318 | this->pthreads[i].imageData.size.x = this->graphics.imageData.size.x / PTHREAD_COUNT; 319 | this->pthreads[i].imageData.size.y = this->graphics.imageData.size.y; 320 | this->pthreads[i].startColumn = i * this->pthreads[i].imageData.size.x; 321 | this->pthreads[i].endColumn = this->pthreads[i].startColumn + this->pthreads[i].imageData.size.y; 322 | } 323 | } 324 | 325 | static inline void enqueueTasks(Program *this) 326 | { 327 | pthread_mutex_lock(&mutexMain); 328 | { 329 | for (int i = 0; i < PTHREAD_COUNT; i++) 330 | { 331 | queueEnqueue(&taskQ, &this->pthreads[i]); 332 | pthread_cond_signal(&condVar); 333 | } 334 | } 335 | pthread_mutex_unlock(&mutexMain); 336 | } 337 | 338 | inline static void waitForTasksToFinish(void) 339 | { 340 | int tempRefCounter = PTHREAD_COUNT; 341 | while (tempRefCounter > 0) 342 | { 343 | pthread_mutex_lock(&referenceCounterLock); 344 | tempRefCounter = refCounter; 345 | pthread_mutex_unlock(&referenceCounterLock); 346 | }; 347 | refCounter = PTHREAD_COUNT; 348 | } 349 | 350 | inline static void drawSlicesIntoTexture(Program *this) 351 | { 352 | Sprite tempSprite = {0}; 353 | for (int i = 0; i < PTHREAD_COUNT; i++) 354 | { 355 | tempSprite.position.x = this->pthreads[i].startColumn; 356 | tempSprite.imageData = this->pthreads[i].imageData; 357 | spriteDraw(tempSprite, this->graphics.imageData); 358 | } 359 | } -------------------------------------------------------------------------------- /src/program/program.h: -------------------------------------------------------------------------------- 1 | #ifndef __PROGRAM_H__ 2 | #define __PROGRAM_H__ 3 | #include "core/graphics/graphics.h" 4 | #include "core/sprite/sprite.h" 5 | #include "camera/camera.h" 6 | #include "core/array/array.h" 7 | 8 | enum EnumMapTYpe 9 | { 10 | MAP_SNOW_WATERY, 11 | MAP_FOREST_WATERY, 12 | MAP_JUNGLE, 13 | MAP_MOUNTAINS_DESERT, 14 | MAP_MOUNTAINS, 15 | MAP_DESERT, 16 | MAP_COUNT 17 | }; 18 | 19 | struct Program; 20 | 21 | typedef struct 22 | { 23 | pthread_t handler; 24 | int startColumn; 25 | int endColumn; 26 | ImageData imageData; 27 | struct Program *program; 28 | } PthreadInfo; 29 | 30 | #define PTHREAD_COUNT 8 31 | 32 | typedef struct Program 33 | { 34 | Graphics graphics; 35 | Sprite colorMaps[MAP_COUNT]; 36 | Sprite heightMaps[MAP_COUNT]; 37 | 38 | double lookingAngle; 39 | PointI cameraPosition; 40 | float cameraSpeed; 41 | double angularSpeed; 42 | double levelOfDetail; 43 | int distance; 44 | float height; 45 | int horizon; 46 | PointF scale; 47 | unsigned int mapIndex; 48 | double stopwatchStart; 49 | double deltaTime; 50 | PointI lastCameraPosition; 51 | double lastAngle; 52 | PthreadInfo pthreads[PTHREAD_COUNT]; 53 | } Program; 54 | 55 | Program programCreate(); 56 | void programMainLoop(Program this); 57 | void programDestroy(Program this); 58 | 59 | #endif -------------------------------------------------------------------------------- /src/program/utils/utils.c: -------------------------------------------------------------------------------- 1 | #include "utils.h" 2 | 3 | void printFPS(Graphics this, double deltaTime) 4 | { 5 | #define FPS_HISTORY 10 6 | static double fpsHistory[FPS_HISTORY] = {0}; 7 | static int counter = 1; 8 | counter++; 9 | counter %= FPS_HISTORY; 10 | fpsHistory[counter] = (1 / deltaTime); 11 | 12 | int sum = 0; 13 | for (int i = 0; i < FPS_HISTORY; i++) 14 | { 15 | sum += fpsHistory[i]; 16 | } 17 | 18 | float avg = sum / FPS_HISTORY; 19 | 20 | { 21 | char text[1000] = {0}; 22 | snprintf(text, 1000, "fps: %d", (int)floor(avg)); 23 | imPrintString(this.imageData, (PointI){100, 0}, text, (Color){0, 0xff, 0xff}); 24 | } 25 | } 26 | 27 | double getDeltaTime() 28 | { 29 | static double lastUpdate = 0; 30 | 31 | double deltaTime = glfwGetTime() - lastUpdate; 32 | lastUpdate = glfwGetTime(); 33 | 34 | return deltaTime; 35 | } 36 | 37 | #define RANDOM_TABLE_SIZE 1000 38 | 39 | static double randomTable[RANDOM_TABLE_SIZE] = {0}; 40 | 41 | void initRandomTable(void) 42 | { 43 | for (int i = 0; i < RANDOM_TABLE_SIZE; i++) 44 | { 45 | randomTable[i] = random() / (RAND_MAX + 1.0); 46 | } 47 | } 48 | 49 | double randomDouble(unsigned int *seed) 50 | { 51 | return randomTable[rand_r(seed) % RANDOM_TABLE_SIZE]; 52 | } 53 | 54 | double randomDoubleMinMax(double min, double max, unsigned int *seed) 55 | { 56 | return min + (max - min) * randomDouble(seed); 57 | } 58 | 59 | double clamp(double pValue, double pMin, double pMax) 60 | { 61 | return fmaxf(pMin, fminf(pValue, pMax)); 62 | } 63 | 64 | Vec3 randomInUnitSphere(unsigned int *seed) 65 | { 66 | while (1) 67 | { 68 | Vec3 point = vec3RandomMinMax(-1, 1, seed); 69 | if (vec3LengthSqurd(point) <= 1) 70 | { 71 | return point; 72 | } 73 | } 74 | } 75 | 76 | Vec3 randomUnitVector(unsigned int *seed) 77 | { 78 | return vec3Unit(randomInUnitSphere(seed)); 79 | } 80 | 81 | Vec3 randomInHemisphere(Vec3 pNormal, unsigned int *seed) 82 | { 83 | Vec3 inUnitSphere = randomInUnitSphere(seed); 84 | if (vec3Dot(inUnitSphere, pNormal) > 0.0) 85 | return inUnitSphere; 86 | else 87 | return vec3Mult(inUnitSphere, -1.0); 88 | } -------------------------------------------------------------------------------- /src/program/utils/utils.h: -------------------------------------------------------------------------------- 1 | #ifndef __UTILS_H__ 2 | #define __UTILS_H__ 3 | #include 4 | #include 5 | #include 6 | #include "../core/graphics/graphics.h" 7 | #include "../vec3/vec3.h" 8 | 9 | void initRandomTable(void); 10 | double randomDouble(unsigned int *seed); 11 | double randomDoubleMinMax(double min, double max, unsigned int *seed); 12 | double clamp(double pValue, double pMin, double pMax); 13 | Vec3 randomInUnitSphere(unsigned int *seed); 14 | Vec3 randomUnitVector(unsigned int *seed); 15 | Vec3 randomInHemisphere(Vec3 pNormal, unsigned int *seed); 16 | void printFPS(Graphics this, double deltaTime); 17 | double getDeltaTime(); 18 | #endif -------------------------------------------------------------------------------- /src/program/vec3/vec3.c: -------------------------------------------------------------------------------- 1 | #include "vec3.h" 2 | #include "../utils/utils.h" 3 | #include "../core/graphics/imageData/imageData.h" 4 | #include 5 | 6 | Vec3 vec3Create(double x, double y, double z) 7 | { 8 | Vec3 this = {x, y, z}; 9 | return this; 10 | } 11 | 12 | Vec3 vec3Substract(Vec3 this, Vec3 other) 13 | { 14 | return (Vec3){this.x - other.x, this.y - other.y, this.z - other.z}; 15 | } 16 | 17 | Vec3 vec3AddScalarF(Vec3 this, double pScalar) 18 | { 19 | return (Vec3){this.x + pScalar, this.y + pScalar, this.z + pScalar}; 20 | } 21 | 22 | Vec3 vec3Add(Vec3 this, Vec3 other) 23 | { 24 | return (Vec3){this.x + other.x, this.y + other.y, this.z + other.z}; 25 | } 26 | 27 | Vec3 vec3Mult(Vec3 this, double scalar) 28 | { 29 | return (Vec3){this.x * scalar, this.y * scalar, this.z * scalar}; 30 | } 31 | 32 | double vec3Length(Vec3 this) 33 | { 34 | return sqrtf(this.x * this.x + this.y * this.y + this.z * this.z); 35 | } 36 | 37 | double vec3LengthSqurd(Vec3 this) 38 | { 39 | return this.x * this.x + this.y * this.y + this.z * this.z; 40 | } 41 | 42 | double vec3Dot(Vec3 this, Vec3 other) 43 | { 44 | return this.x * other.x + 45 | this.y * other.y + 46 | this.z * other.z; 47 | } 48 | 49 | Vec3 vec3Cross(Vec3 a, Vec3 b) 50 | { 51 | return (Vec3){ 52 | a.y * b.z - a.z * b.y, 53 | a.z * b.x - a.x * b.z, 54 | a.x * b.y - a.y * b.x}; 55 | } 56 | 57 | Vec3 vec3MultElem(Vec3 a, Vec3 b) 58 | { 59 | return (Vec3){ 60 | a.x * b.x, 61 | a.y * b.y, 62 | a.z * b.z}; 63 | } 64 | 65 | Vec3 vec3Unit(Vec3 this) 66 | { 67 | return vec3Mult(this, 1 / vec3Length(this)); 68 | } 69 | 70 | Vec3 v3Random(unsigned int *seed) 71 | { 72 | return (Vec3){randomDouble(seed), randomDouble(seed), randomDouble(seed)}; 73 | } 74 | 75 | Vec3 vec3RandomMinMax(double pMin, double pMax, unsigned int *seed) 76 | { 77 | return (Vec3){randomDoubleMinMax(pMin, pMax, seed), randomDoubleMinMax(pMin, pMax, seed), randomDoubleMinMax(pMin, pMax, seed)}; 78 | } 79 | 80 | bool vec3IsNearZero(Vec3 this) 81 | { 82 | double s = 1e-8; 83 | return (fabs(this.x) < s) && (fabs(this.y) < s) && (fabs(this.z) < s); 84 | } 85 | 86 | Vec3 vec3Reflect(Vec3 this, Vec3 pNormal) 87 | { 88 | return vec3Substract(this, vec3Mult(pNormal, 2 * vec3Dot(this, pNormal))); 89 | } 90 | -------------------------------------------------------------------------------- /src/program/vec3/vec3.h: -------------------------------------------------------------------------------- 1 | #ifndef __VEC3_H__ 2 | #define __VEC3_H__ 3 | 4 | #include 5 | #include 6 | #include "../core/graphics/imageData/imageData.h" 7 | typedef struct 8 | { 9 | double x, y, z; 10 | } Vec3; 11 | 12 | typedef Vec3 Point3; 13 | 14 | Vec3 vec3Create(double, double, double); 15 | Vec3 vec3Substract(Vec3, Vec3); 16 | Vec3 vec3Add(Vec3, Vec3); 17 | Vec3 vec3Mult(Vec3, double); 18 | double vec3Length(Vec3); 19 | double vec3LengthSqurd(Vec3); 20 | double vec3Dot(Vec3, Vec3); 21 | Vec3 vec3Cross(Vec3, Vec3); 22 | Vec3 vec3Unit(Vec3 this); 23 | Vec3 v3Random(unsigned int *seed); 24 | Vec3 vec3RandomMinMax(double pMin, double pMax, unsigned int *seed); 25 | Vec3 vec3AddScalarF(Vec3 this, double pScalar); 26 | bool vec3IsNearZero(Vec3 this); 27 | Vec3 vec3Reflect(Vec3 this, Vec3 pNormal); 28 | Vec3 vec3MultElem(Vec3 a, Vec3 b); 29 | Color vec3ToColor(Vec3 this); 30 | Vec3 colorToVec3(Color this); 31 | #endif --------------------------------------------------------------------------------