├── .gitignore ├── .gitmodules ├── CMakeLists.txt ├── LICENSE ├── README.md ├── levels ├── demo_terrain_64 └── demo_terrain_96 ├── libraries ├── cxxpool │ └── include │ │ └── cxxpool.h └── glad │ ├── include │ ├── KHR │ │ └── khrplatform.h │ └── glad │ │ └── glad.h │ └── src │ └── glad.c ├── screenshots ├── banner.png └── wireframe.png └── src ├── data ├── level_file.h └── rle.h ├── main.cpp ├── mesher.h ├── misc ├── camera.h ├── noise.h ├── shader.h ├── timer.h └── utility.h ├── rendering └── chunk_renderer.h └── shaders ├── main.fs └── main.vs /.gitignore: -------------------------------------------------------------------------------- 1 | /*.vs* 2 | *build* 3 | settings.json 4 | libraries/* 5 | !libraries/include 6 | !libraries/glad 7 | !libraries/cxxpool -------------------------------------------------------------------------------- /.gitmodules: -------------------------------------------------------------------------------- 1 | [submodule "libraries/glfw"] 2 | path = libraries/glfw 3 | url = https://github.com/glfw/glfw.git 4 | [submodule "libraries/glm"] 5 | path = libraries/glm 6 | url = https://github.com/g-truc/glm.git 7 | [submodule "libraries/FastNoise"] 8 | path = libraries/FastNoise 9 | url = https://github.com/Auburns/FastNoise 10 | -------------------------------------------------------------------------------- /CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 3.1) 2 | project(binaryMesher) 3 | 4 | set(SRC_DIR "${CMAKE_CURRENT_SOURCE_DIR}/src") 5 | 6 | set(LIB_DIR "${CMAKE_CURRENT_SOURCE_DIR}/libraries") 7 | set(LIB_INCLUDE_DIR "${LIB_DIR}/include/") 8 | set(GLFW_DIR "${LIB_DIR}/glfw") 9 | set(GLAD_DIR "${LIB_DIR}/glad") 10 | set(GLM_DIR "${LIB_DIR}/glm") 11 | set(FAST_NOISE_DIR "${LIB_DIR}/FastNoise") 12 | set(CXXPOOL_DIR "${LIB_DIR}/cxxpool") 13 | 14 | add_subdirectory(${GLM_DIR} EXCLUDE_FROM_ALL) 15 | add_subdirectory(${GLFW_DIR}) 16 | 17 | set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/cmake") 18 | set(CMAKE_BUILD_TYPE RelWithDebInfo) 19 | 20 | add_executable(client 21 | ${SRC_DIR}/main.cpp 22 | ${FAST_NOISE_DIR}/FastNoise.cpp 23 | ) 24 | 25 | target_link_libraries(client ${CMAKE_DL_LIBS}) 26 | target_link_libraries(client ${GLFW_LIBRARIES}) 27 | target_link_libraries(client "glm") 28 | target_link_libraries(client "glfw" "${GLFW_LIBRARIES}") 29 | target_link_libraries(client "glad" "${CMAKE_DL_LIBS}") 30 | 31 | target_include_directories(client PRIVATE "${LIB_INCLUDE_DIR}") 32 | target_include_directories(client PRIVATE ${SRC_DIR}) 33 | target_include_directories(client PRIVATE ${COMMON_DIR}) 34 | target_include_directories(client PRIVATE "${GLFW_DIR}/include") 35 | target_include_directories(client PRIVATE "${GLAD_DIR}/include") 36 | target_include_directories(client PRIVATE "${CXXPOOL_DIR}/include") 37 | 38 | target_compile_definitions(client PRIVATE "GLFW_INCLUDE_NONE") 39 | 40 | set_property(TARGET client PROPERTY CXX_STANDARD 17) 41 | set_property(GLOBAL PROPERTY USE_FOLDERS ON) 42 | 43 | # GLFW 44 | set(GLFW_BUILD_EXAMPLES OFF CACHE INTERNAL "Build the GLFW example programs" FORCE) 45 | set(GLFW_BUILD_TESTS OFF CACHE INTERNAL "Build the GLFW test programs" FORCE) 46 | set(GLFW_BUILD_DOCS OFF CACHE INTERNAL "Build the GLFW documentation" FORCE) 47 | set(GLFW_INSTALL OFF CACHE INTERNAL "Generate installation target") 48 | 49 | # glad 50 | add_library("glad" "${GLAD_DIR}/src/glad.c") 51 | target_include_directories("glad" PRIVATE "${GLAD_DIR}/include") -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2020 Erik Johansson 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Binary Greedy Meshing v2 2 | 3 |

4 | 5 | 6 |

7 | 8 | **Voxel meshing algorithm that creates large quads using extremely fast bitwise operations.** 9 | 10 | **Version 2 is several times faster compared to version 1 thanks to contributions by:** 11 | 12 | **Ethan Gore** - Core V2 changes & Vertex Pulling rendering ([Youtube Channel](https://www.youtube.com/@ethangore8697), [Github](https://github.com/kryyptor)) 13 | **Finding Fortune** - Optimization and cleanup ([Youtube Channel](https://www.youtube.com/@Finding_Fortune), [Github](https://github.com/Finding-Fortune)) 14 | 15 | Execution time for a single chunk typically ranges from **50us** to **200us**. 16 | The chunks in the screenshot were meshed at an average of **74us** single-threaded and **108us** in a thread pool. (Ryzen 3800x). 17 | 18 | Chunks with a maximum size of 64x64x64 are supported, including neighboring chunk data. 19 | 20 | **Check out the [v1.0.0](https://github.com/cgerikj/binary-greedy-meshing/tree/v1.0.0) branch for version 1 which supports baked AO.** 21 | 22 | ## How does it work? 23 | 24 | ### Step 1 - Generate occupancy mask 25 | The first step, which is performed outside the main meshing function, is to create a binary opaque/occupancy mask of the chunk. A 64x64 array of 64-bit integers is generated where **0** means air and **1** means an opaque voxel. This data can be saved and updated for future re-meshing. It's also useful for physics and raycasting. 26 | 27 | The demo does this in two different ways: 28 | * World generation: **src/misc/noise.h: generateTerrainV1** 29 | * Chunk decompression (RLE): **src/data/rle.h: decompressToVoxelsAndOpaqueMask** 30 | 31 | ### Step 2 - Generate face masks / hidden face culling 32 | Bitwise operations are used to cull 64 faces at a time and create another data structure for visible faces. A 62x62 array of 64-bit masks is generated for each of the 6 faces. Each bit represents whether or not a face of a voxel faces air and should be visible. 33 | 34 | ### Step 3 - Greedy face merging 35 | The masks from step 2 are iterated for each face and merged into larger quads. Bitwise operations are used to merge 64 faces at a time and the original voxel types are looked up to check whether or not two voxel faces can be merged into one. Step 3 is divided into two separate algorithms because it operates on data on two different planes. 36 | 37 | **The vertices that are generated are 8 bytes per quad.** 38 | These are rendered using vertex pulling. The mesher can of course be modified to create 4/6 regular vertices per quad. 39 | 40 | The first 4 bytes are packed like this: 6 bit x, 6 bit y, 6 bit z, 6 bit width, 6 bit height. 41 | The last 4 bytes only utilize 8 bits for voxel type data. 42 | 43 | ## Rendering 44 | The demo project ships with a fast renderer that uses vertex pulling. All chunks are rendered in one draw call using glMultiDrawElementsIndirect. Faces facing away from the camera are not rendered. 45 | 46 | ## T-junctions 47 | To reduce artifacts from T-junctions (when a quad edge meets the middle of another), the renderer does the following: 48 | 49 | 1. Quads are rendered slightly larger (~1px) to hide/cover small gaps. 50 | 2. Vertex positions are calculated in eye-space to improve float accuracy, especially at larger coordinates. 51 | 52 | ## Demo 53 | When the program is started, a 96x96 chunk (5952x5952 voxels) file is loaded from disk and meshed in a few seconds (multi-threaded). 54 | 55 | Use these controls to fly around and swap between a few test/benchmark chunks. Meshing durations are printed to the console. 56 | 57 | - Noclip: WASD 58 | - Toggle wireframe: X 59 | - Regenerate test chunk: Spacebar 60 | - Cycle test mesh type: Tab 61 | 62 | ### Demo setup example (Visual Studio) 63 | ``` 64 | > git clone https://github.com/cgerikj/binary-greedy-meshing --recursive 65 | > cd binary-greedy-meshing 66 | > mkdir build && cd build 67 | > cmake .. -G "Visual Studio 17 2022" 68 | > start binaryMesher.sln 69 | > (Switch to Release Mode / RelWithDebInfo) 70 | ``` 71 | 72 | ## Other resources 73 | #### Meshing in a minecraft game: 74 | https://0fps.net/2012/06/30/meshing-in-a-minecraft-game/ 75 | 76 | #### Vertex pulling 77 | https://voxel.wiki/wiki/vertex-pulling/ 78 | -------------------------------------------------------------------------------- /levels/demo_terrain_64: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cgerikj/binary-greedy-meshing/af8c688ed3af63e98f9631c05774f30e1350a021/levels/demo_terrain_64 -------------------------------------------------------------------------------- /levels/demo_terrain_96: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cgerikj/binary-greedy-meshing/af8c688ed3af63e98f9631c05774f30e1350a021/levels/demo_terrain_96 -------------------------------------------------------------------------------- /libraries/cxxpool/include/cxxpool.h: -------------------------------------------------------------------------------- 1 | // cxxpool is a header-only thread pool for C++ 2 | // Repository: https://github.com/bloomen/cxxpool 3 | // Copyright: 2022 Christian Blume 4 | // License: http://www.opensource.org/licenses/mit-license.php 5 | #pragma once 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | 17 | 18 | namespace cxxpool { 19 | namespace detail { 20 | 21 | 22 | template 23 | struct future_info { 24 | typedef typename std::iterator_traits::value_type future_type; 25 | typedef decltype(std::declval().get()) value_type; 26 | static constexpr bool is_void = std::is_void::value; 27 | }; 28 | 29 | 30 | } // detail 31 | 32 | 33 | // Waits until all futures contain results 34 | template 35 | inline 36 | void wait(Iterator first, Iterator last) { 37 | for (; first != last; ++first) 38 | first->wait(); 39 | } 40 | 41 | 42 | // Waits until all futures contain results with a given timeout duration and 43 | // returns a container of std::future::status 44 | template 45 | inline 46 | Result wait_for(Iterator first, Iterator last, 47 | const std::chrono::duration& timeout_duration, 48 | Result result) { 49 | for (; first != last; ++first) 50 | result.push_back(first->wait_for(timeout_duration)); 51 | return result; 52 | } 53 | 54 | 55 | // Waits until all futures contain results with a given timeout duration and 56 | // returns a vector of std::future::status 57 | template 58 | inline 59 | std::vector wait_for(Iterator first, Iterator last, 60 | const std::chrono::duration& timeout_duration) { 61 | return wait_for(first, last, timeout_duration, std::vector{}); 62 | } 63 | 64 | 65 | // Waits until all futures contain results with a given timeout time and 66 | // returns a container of std::future::status 67 | template 68 | inline 69 | Result wait_until(Iterator first, Iterator last, 70 | const std::chrono::time_point& timeout_time, 71 | Result result) { 72 | for (; first != last; ++first) 73 | result.push_back(first->wait_until(timeout_time)); 74 | return result; 75 | } 76 | 77 | 78 | // Waits until all futures contain results with a given timeout time and 79 | // returns a vector of std::future::status 80 | template 81 | inline 82 | std::vector wait_until(Iterator first, Iterator last, 83 | const std::chrono::time_point& timeout_time) { 84 | return wait_until(first, last, timeout_time, std::vector{}); 85 | } 86 | 87 | 88 | // Calls get() on all futures 89 | template::is_void>::type> 91 | inline 92 | void get(Iterator first, Iterator last) { 93 | for (; first != last; ++first) 94 | first->get(); 95 | } 96 | 97 | 98 | // Calls get() on all futures and stores the results in the returned container 99 | template::is_void>::type> 101 | inline 102 | Result get(Iterator first, Iterator last, Result result) { 103 | for (; first != last; ++first) 104 | result.push_back(first->get()); 105 | return result; 106 | } 107 | 108 | 109 | // Calls get() on all futures and stores the results in the returned vector 110 | template::is_void>::type> 112 | inline 113 | std::vector::value_type> 114 | get(Iterator first, Iterator last) { 115 | return cxxpool::get(first, last, std::vector::value_type>{}); 116 | } 117 | 118 | 119 | namespace detail { 120 | 121 | 122 | template::max()> 123 | class infinite_counter { 124 | public: 125 | 126 | infinite_counter() 127 | : count_{0} 128 | {} 129 | 130 | infinite_counter& operator++() { 131 | if (count_.back() == max) 132 | count_.push_back(0); 133 | else 134 | ++count_.back(); 135 | return *this; 136 | } 137 | 138 | bool operator>(const infinite_counter& other) const { 139 | if (count_.size() == other.count_.size()) { 140 | return count_.back() > other.count_.back(); 141 | } else { 142 | return count_.size() > other.count_.size(); 143 | } 144 | } 145 | 146 | private: 147 | std::vector count_; 148 | }; 149 | 150 | 151 | class priority_task { 152 | public: 153 | typedef std::size_t counter_elem_t; 154 | 155 | priority_task() 156 | : callback_{}, priority_{}, order_{} 157 | {} 158 | 159 | // cppcheck-suppress passedByValue 160 | priority_task(std::function callback, std::size_t priority, cxxpool::detail::infinite_counter order) 161 | : callback_{std::move(callback)}, priority_(priority), order_{std::move(order)} 162 | {} 163 | 164 | bool operator<(const priority_task& other) const { 165 | if (priority_ == other.priority_) { 166 | return order_ > other.order_; 167 | } else { 168 | return priority_ < other.priority_; 169 | } 170 | } 171 | 172 | void operator()() const { 173 | return callback_(); 174 | } 175 | 176 | private: 177 | std::function callback_; 178 | std::size_t priority_; 179 | cxxpool::detail::infinite_counter order_; 180 | }; 181 | 182 | 183 | } // detail 184 | 185 | 186 | // Exception thrown by the thread_pool class 187 | class thread_pool_error : public std::runtime_error { 188 | public: 189 | explicit thread_pool_error(const std::string& message) 190 | : std::runtime_error{message} 191 | {} 192 | }; 193 | 194 | 195 | // A thread pool for C++ 196 | // 197 | // Constructing the thread pool launches the worker threads while 198 | // destructing it joins them. The threads will be alive for as long as the 199 | // thread pool is not destructed. One may call add_threads() to add more 200 | // threads to the thread pool. 201 | // 202 | // Tasks can be pushed into the pool with and w/o providing a priority >= 0. 203 | // Not providing a priority is equivalent to providing a priority of 0. 204 | // Those tasks are processed first that have the highest priority. 205 | // If priorities are equal those tasks are processed first that were pushed 206 | // first into the pool (FIFO). 207 | class thread_pool { 208 | public: 209 | 210 | // Constructor. No threads are launched 211 | thread_pool() 212 | : done_{false}, paused_{false}, threads_{}, tasks_{}, task_counter_{}, 213 | task_cond_var_{}, task_mutex_{}, thread_mutex_{} 214 | {} 215 | 216 | // Constructor. Launches the desired number of threads. Passing 0 is 217 | // equivalent to calling the no-argument constructor 218 | explicit thread_pool(std::size_t n_threads) 219 | : thread_pool{} 220 | { 221 | if (n_threads > 0) { 222 | std::lock_guard thread_lock(thread_mutex_); 223 | const auto n_target = threads_.size() + n_threads; 224 | while (threads_.size() < n_target) { 225 | std::thread thread; 226 | try { 227 | thread = std::thread{&thread_pool::worker, this}; 228 | } catch (...) { 229 | shutdown(); 230 | throw; 231 | } 232 | try { 233 | threads_.push_back(std::move(thread)); 234 | } catch (...) { 235 | shutdown(); 236 | thread.join(); 237 | throw; 238 | } 239 | } 240 | } 241 | } 242 | 243 | // Destructor. Joins all threads launched. Waits for all running tasks 244 | // to complete 245 | ~thread_pool() { 246 | shutdown(); 247 | } 248 | 249 | // deleting copy/move semantics 250 | thread_pool(const thread_pool&) = delete; 251 | thread_pool& operator=(const thread_pool&) = delete; 252 | thread_pool(thread_pool&&) = delete; 253 | thread_pool& operator=(thread_pool&&) = delete; 254 | 255 | // Adds new threads to the pool and launches them 256 | void add_threads(std::size_t n_threads) { 257 | if (n_threads > 0) { 258 | { 259 | std::lock_guard task_lock(task_mutex_); 260 | if (done_) 261 | throw thread_pool_error{"add_threads called while pool is shutting down"}; 262 | } 263 | std::lock_guard thread_lock(thread_mutex_); 264 | const auto n_target = threads_.size() + n_threads; 265 | while (threads_.size() < n_target) { 266 | std::thread thread(&thread_pool::worker, this); 267 | try { 268 | threads_.push_back(std::move(thread)); 269 | } catch (...) { 270 | shutdown(); 271 | thread.join(); 272 | throw; 273 | } 274 | } 275 | } 276 | } 277 | 278 | // Returns the number of threads launched 279 | std::size_t n_threads() const { 280 | { 281 | std::lock_guard task_lock(task_mutex_); 282 | if (done_) 283 | throw thread_pool_error{"n_threads called while pool is shutting down"}; 284 | } 285 | std::lock_guard thread_lock(thread_mutex_); 286 | return threads_.size(); 287 | } 288 | 289 | // Pushes a new task into the thread pool and returns the associated future. 290 | // The task will have a priority of 0 291 | template 292 | auto push(Functor&& functor, Args&&... args) -> std::future { 293 | return push(0, std::forward(functor), std::forward(args)...); 294 | } 295 | 296 | // Pushes a new task into the thread pool while providing a priority and 297 | // returns the associated future. Higher priorities are processed first 298 | template 299 | auto push(std::size_t priority, Functor&& functor, Args&&... args) -> std::future { 300 | typedef decltype(functor(args...)) result_type; 301 | auto pack_task = std::make_shared>( 302 | std::bind(std::forward(functor), std::forward(args)...)); 303 | auto future = pack_task->get_future(); 304 | { 305 | std::lock_guard task_lock(task_mutex_); 306 | if (done_) 307 | throw cxxpool::thread_pool_error{"push called while pool is shutting down"}; 308 | tasks_.emplace([pack_task]{ (*pack_task)(); }, priority, ++task_counter_); 309 | } 310 | task_cond_var_.notify_one(); 311 | return future; 312 | } 313 | 314 | // Returns the current number of queued tasks 315 | std::size_t n_tasks() const { 316 | std::lock_guard task_lock(task_mutex_); 317 | return tasks_.size(); 318 | } 319 | 320 | // Clears all queued tasks, not affecting currently running tasks 321 | void clear() { 322 | std::lock_guard task_lock(task_mutex_); 323 | decltype(tasks_) empty; 324 | tasks_.swap(empty); 325 | } 326 | 327 | // If enabled then pauses the processing of tasks, not affecting currently 328 | // running tasks. Disabling it will resume the processing of tasks 329 | void set_pause(bool enabled) { 330 | { 331 | std::lock_guard task_lock(task_mutex_); 332 | paused_ = enabled; 333 | } 334 | if (!paused_) 335 | task_cond_var_.notify_all(); 336 | } 337 | 338 | private: 339 | 340 | void worker() { 341 | for (;;) { 342 | cxxpool::detail::priority_task task; 343 | { 344 | std::unique_lock task_lock(task_mutex_); 345 | task_cond_var_.wait(task_lock, [this]{ 346 | return !paused_ && (done_ || !tasks_.empty()); 347 | }); 348 | if (done_ && tasks_.empty()) 349 | break; 350 | task = tasks_.top(); 351 | tasks_.pop(); 352 | } 353 | task(); 354 | } 355 | } 356 | 357 | void shutdown() { 358 | { 359 | std::lock_guard task_lock(task_mutex_); 360 | done_ = true; 361 | paused_ = false; 362 | } 363 | task_cond_var_.notify_all(); 364 | std::lock_guard thread_lock(thread_mutex_); 365 | for (auto& thread : threads_) 366 | thread.join(); 367 | } 368 | 369 | bool done_; 370 | bool paused_; 371 | std::vector threads_; 372 | std::priority_queue tasks_; 373 | cxxpool::detail::infinite_counter< 374 | typename detail::priority_task::counter_elem_t> task_counter_; 375 | std::condition_variable task_cond_var_; 376 | mutable std::mutex task_mutex_; 377 | mutable std::mutex thread_mutex_; 378 | }; 379 | 380 | 381 | } // cxxpool -------------------------------------------------------------------------------- /libraries/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 | * To support platform where unsigned long cannot be used interchangeably with 158 | * inptr_t (e.g. CHERI-extended ISAs), we can use the stdint.h intptr_t. 159 | * Ideally, we could just use (u)intptr_t everywhere, but this could result in 160 | * ABI breakage if khronos_uintptr_t is changed from unsigned long to 161 | * unsigned long long or similar (this results in different C++ name mangling). 162 | * To avoid changes for existing platforms, we restrict usage of intptr_t to 163 | * platforms where the size of a pointer is larger than the size of long. 164 | */ 165 | #if defined(__SIZEOF_LONG__) && defined(__SIZEOF_POINTER__) 166 | #if __SIZEOF_POINTER__ > __SIZEOF_LONG__ 167 | #define KHRONOS_USE_INTPTR_T 168 | #endif 169 | #endif 170 | 171 | #elif defined(__VMS ) || defined(__sgi) 172 | 173 | /* 174 | * Using 175 | */ 176 | #include 177 | typedef int32_t khronos_int32_t; 178 | typedef uint32_t khronos_uint32_t; 179 | typedef int64_t khronos_int64_t; 180 | typedef uint64_t khronos_uint64_t; 181 | #define KHRONOS_SUPPORT_INT64 1 182 | #define KHRONOS_SUPPORT_FLOAT 1 183 | 184 | #elif defined(_WIN32) && !defined(__SCITECH_SNAP__) 185 | 186 | /* 187 | * Win32 188 | */ 189 | typedef __int32 khronos_int32_t; 190 | typedef unsigned __int32 khronos_uint32_t; 191 | typedef __int64 khronos_int64_t; 192 | typedef unsigned __int64 khronos_uint64_t; 193 | #define KHRONOS_SUPPORT_INT64 1 194 | #define KHRONOS_SUPPORT_FLOAT 1 195 | 196 | #elif defined(__sun__) || defined(__digital__) 197 | 198 | /* 199 | * Sun or Digital 200 | */ 201 | typedef int khronos_int32_t; 202 | typedef unsigned int khronos_uint32_t; 203 | #if defined(__arch64__) || defined(_LP64) 204 | typedef long int khronos_int64_t; 205 | typedef unsigned long int khronos_uint64_t; 206 | #else 207 | typedef long long int khronos_int64_t; 208 | typedef unsigned long long int khronos_uint64_t; 209 | #endif /* __arch64__ */ 210 | #define KHRONOS_SUPPORT_INT64 1 211 | #define KHRONOS_SUPPORT_FLOAT 1 212 | 213 | #elif 0 214 | 215 | /* 216 | * Hypothetical platform with no float or int64 support 217 | */ 218 | typedef int khronos_int32_t; 219 | typedef unsigned int khronos_uint32_t; 220 | #define KHRONOS_SUPPORT_INT64 0 221 | #define KHRONOS_SUPPORT_FLOAT 0 222 | 223 | #else 224 | 225 | /* 226 | * Generic fallback 227 | */ 228 | #include 229 | typedef int32_t khronos_int32_t; 230 | typedef uint32_t khronos_uint32_t; 231 | typedef int64_t khronos_int64_t; 232 | typedef uint64_t khronos_uint64_t; 233 | #define KHRONOS_SUPPORT_INT64 1 234 | #define KHRONOS_SUPPORT_FLOAT 1 235 | 236 | #endif 237 | 238 | 239 | /* 240 | * Types that are (so far) the same on all platforms 241 | */ 242 | typedef signed char khronos_int8_t; 243 | typedef unsigned char khronos_uint8_t; 244 | typedef signed short int khronos_int16_t; 245 | typedef unsigned short int khronos_uint16_t; 246 | 247 | /* 248 | * Types that differ between LLP64 and LP64 architectures - in LLP64, 249 | * pointers are 64 bits, but 'long' is still 32 bits. Win64 appears 250 | * to be the only LLP64 architecture in current use. 251 | */ 252 | #ifdef KHRONOS_USE_INTPTR_T 253 | typedef intptr_t khronos_intptr_t; 254 | typedef uintptr_t khronos_uintptr_t; 255 | #elif defined(_WIN64) 256 | typedef signed long long int khronos_intptr_t; 257 | typedef unsigned long long int khronos_uintptr_t; 258 | #else 259 | typedef signed long int khronos_intptr_t; 260 | typedef unsigned long int khronos_uintptr_t; 261 | #endif 262 | 263 | #if defined(_WIN64) 264 | typedef signed long long int khronos_ssize_t; 265 | typedef unsigned long long int khronos_usize_t; 266 | #else 267 | typedef signed long int khronos_ssize_t; 268 | typedef unsigned long int khronos_usize_t; 269 | #endif 270 | 271 | #if KHRONOS_SUPPORT_FLOAT 272 | /* 273 | * Float type 274 | */ 275 | typedef float khronos_float_t; 276 | #endif 277 | 278 | #if KHRONOS_SUPPORT_INT64 279 | /* Time types 280 | * 281 | * These types can be used to represent a time interval in nanoseconds or 282 | * an absolute Unadjusted System Time. Unadjusted System Time is the number 283 | * of nanoseconds since some arbitrary system event (e.g. since the last 284 | * time the system booted). The Unadjusted System Time is an unsigned 285 | * 64 bit value that wraps back to 0 every 584 years. Time intervals 286 | * may be either signed or unsigned. 287 | */ 288 | typedef khronos_uint64_t khronos_utime_nanoseconds_t; 289 | typedef khronos_int64_t khronos_stime_nanoseconds_t; 290 | #endif 291 | 292 | /* 293 | * Dummy value used to pad enum types to 32 bits. 294 | */ 295 | #ifndef KHRONOS_MAX_ENUM 296 | #define KHRONOS_MAX_ENUM 0x7FFFFFFF 297 | #endif 298 | 299 | /* 300 | * Enumerated boolean type 301 | * 302 | * Values other than zero should be considered to be true. Therefore 303 | * comparisons should not be made against KHRONOS_TRUE. 304 | */ 305 | typedef enum { 306 | KHRONOS_FALSE = 0, 307 | KHRONOS_TRUE = 1, 308 | KHRONOS_BOOLEAN_ENUM_FORCE_SIZE = KHRONOS_MAX_ENUM 309 | } khronos_boolean_enum_t; 310 | 311 | #endif /* __khrplatform_h_ */ -------------------------------------------------------------------------------- /libraries/glad/src/glad.c: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | OpenGL loader generated by glad 0.1.36 on Thu May 9 10:08:22 2024. 4 | 5 | Language/Generator: C/C++ 6 | Specification: gl 7 | APIs: gl=4.4 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=4.4" --generator="c" --spec="gl" --extensions="" 18 | Online: 19 | https://glad.dav1d.de/#profile=compatibility&language=c&specification=gl&loader=on&api=gl%3D4.4 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 | int GLAD_GL_VERSION_4_0 = 0; 271 | int GLAD_GL_VERSION_4_1 = 0; 272 | int GLAD_GL_VERSION_4_2 = 0; 273 | int GLAD_GL_VERSION_4_3 = 0; 274 | int GLAD_GL_VERSION_4_4 = 0; 275 | PFNGLACCUMPROC glad_glAccum = NULL; 276 | PFNGLACTIVESHADERPROGRAMPROC glad_glActiveShaderProgram = NULL; 277 | PFNGLACTIVETEXTUREPROC glad_glActiveTexture = NULL; 278 | PFNGLALPHAFUNCPROC glad_glAlphaFunc = NULL; 279 | PFNGLARETEXTURESRESIDENTPROC glad_glAreTexturesResident = NULL; 280 | PFNGLARRAYELEMENTPROC glad_glArrayElement = NULL; 281 | PFNGLATTACHSHADERPROC glad_glAttachShader = NULL; 282 | PFNGLBEGINPROC glad_glBegin = NULL; 283 | PFNGLBEGINCONDITIONALRENDERPROC glad_glBeginConditionalRender = NULL; 284 | PFNGLBEGINQUERYPROC glad_glBeginQuery = NULL; 285 | PFNGLBEGINQUERYINDEXEDPROC glad_glBeginQueryIndexed = NULL; 286 | PFNGLBEGINTRANSFORMFEEDBACKPROC glad_glBeginTransformFeedback = NULL; 287 | PFNGLBINDATTRIBLOCATIONPROC glad_glBindAttribLocation = NULL; 288 | PFNGLBINDBUFFERPROC glad_glBindBuffer = NULL; 289 | PFNGLBINDBUFFERBASEPROC glad_glBindBufferBase = NULL; 290 | PFNGLBINDBUFFERRANGEPROC glad_glBindBufferRange = NULL; 291 | PFNGLBINDBUFFERSBASEPROC glad_glBindBuffersBase = NULL; 292 | PFNGLBINDBUFFERSRANGEPROC glad_glBindBuffersRange = NULL; 293 | PFNGLBINDFRAGDATALOCATIONPROC glad_glBindFragDataLocation = NULL; 294 | PFNGLBINDFRAGDATALOCATIONINDEXEDPROC glad_glBindFragDataLocationIndexed = NULL; 295 | PFNGLBINDFRAMEBUFFERPROC glad_glBindFramebuffer = NULL; 296 | PFNGLBINDIMAGETEXTUREPROC glad_glBindImageTexture = NULL; 297 | PFNGLBINDIMAGETEXTURESPROC glad_glBindImageTextures = NULL; 298 | PFNGLBINDPROGRAMPIPELINEPROC glad_glBindProgramPipeline = NULL; 299 | PFNGLBINDRENDERBUFFERPROC glad_glBindRenderbuffer = NULL; 300 | PFNGLBINDSAMPLERPROC glad_glBindSampler = NULL; 301 | PFNGLBINDSAMPLERSPROC glad_glBindSamplers = NULL; 302 | PFNGLBINDTEXTUREPROC glad_glBindTexture = NULL; 303 | PFNGLBINDTEXTURESPROC glad_glBindTextures = NULL; 304 | PFNGLBINDTRANSFORMFEEDBACKPROC glad_glBindTransformFeedback = NULL; 305 | PFNGLBINDVERTEXARRAYPROC glad_glBindVertexArray = NULL; 306 | PFNGLBINDVERTEXBUFFERPROC glad_glBindVertexBuffer = NULL; 307 | PFNGLBINDVERTEXBUFFERSPROC glad_glBindVertexBuffers = NULL; 308 | PFNGLBITMAPPROC glad_glBitmap = NULL; 309 | PFNGLBLENDCOLORPROC glad_glBlendColor = NULL; 310 | PFNGLBLENDEQUATIONPROC glad_glBlendEquation = NULL; 311 | PFNGLBLENDEQUATIONSEPARATEPROC glad_glBlendEquationSeparate = NULL; 312 | PFNGLBLENDEQUATIONSEPARATEIPROC glad_glBlendEquationSeparatei = NULL; 313 | PFNGLBLENDEQUATIONIPROC glad_glBlendEquationi = NULL; 314 | PFNGLBLENDFUNCPROC glad_glBlendFunc = NULL; 315 | PFNGLBLENDFUNCSEPARATEPROC glad_glBlendFuncSeparate = NULL; 316 | PFNGLBLENDFUNCSEPARATEIPROC glad_glBlendFuncSeparatei = NULL; 317 | PFNGLBLENDFUNCIPROC glad_glBlendFunci = NULL; 318 | PFNGLBLITFRAMEBUFFERPROC glad_glBlitFramebuffer = NULL; 319 | PFNGLBUFFERDATAPROC glad_glBufferData = NULL; 320 | PFNGLBUFFERSTORAGEPROC glad_glBufferStorage = NULL; 321 | PFNGLBUFFERSUBDATAPROC glad_glBufferSubData = NULL; 322 | PFNGLCALLLISTPROC glad_glCallList = NULL; 323 | PFNGLCALLLISTSPROC glad_glCallLists = NULL; 324 | PFNGLCHECKFRAMEBUFFERSTATUSPROC glad_glCheckFramebufferStatus = NULL; 325 | PFNGLCLAMPCOLORPROC glad_glClampColor = NULL; 326 | PFNGLCLEARPROC glad_glClear = NULL; 327 | PFNGLCLEARACCUMPROC glad_glClearAccum = NULL; 328 | PFNGLCLEARBUFFERDATAPROC glad_glClearBufferData = NULL; 329 | PFNGLCLEARBUFFERSUBDATAPROC glad_glClearBufferSubData = NULL; 330 | PFNGLCLEARBUFFERFIPROC glad_glClearBufferfi = NULL; 331 | PFNGLCLEARBUFFERFVPROC glad_glClearBufferfv = NULL; 332 | PFNGLCLEARBUFFERIVPROC glad_glClearBufferiv = NULL; 333 | PFNGLCLEARBUFFERUIVPROC glad_glClearBufferuiv = NULL; 334 | PFNGLCLEARCOLORPROC glad_glClearColor = NULL; 335 | PFNGLCLEARDEPTHPROC glad_glClearDepth = NULL; 336 | PFNGLCLEARDEPTHFPROC glad_glClearDepthf = NULL; 337 | PFNGLCLEARINDEXPROC glad_glClearIndex = NULL; 338 | PFNGLCLEARSTENCILPROC glad_glClearStencil = NULL; 339 | PFNGLCLEARTEXIMAGEPROC glad_glClearTexImage = NULL; 340 | PFNGLCLEARTEXSUBIMAGEPROC glad_glClearTexSubImage = NULL; 341 | PFNGLCLIENTACTIVETEXTUREPROC glad_glClientActiveTexture = NULL; 342 | PFNGLCLIENTWAITSYNCPROC glad_glClientWaitSync = NULL; 343 | PFNGLCLIPPLANEPROC glad_glClipPlane = NULL; 344 | PFNGLCOLOR3BPROC glad_glColor3b = NULL; 345 | PFNGLCOLOR3BVPROC glad_glColor3bv = NULL; 346 | PFNGLCOLOR3DPROC glad_glColor3d = NULL; 347 | PFNGLCOLOR3DVPROC glad_glColor3dv = NULL; 348 | PFNGLCOLOR3FPROC glad_glColor3f = NULL; 349 | PFNGLCOLOR3FVPROC glad_glColor3fv = NULL; 350 | PFNGLCOLOR3IPROC glad_glColor3i = NULL; 351 | PFNGLCOLOR3IVPROC glad_glColor3iv = NULL; 352 | PFNGLCOLOR3SPROC glad_glColor3s = NULL; 353 | PFNGLCOLOR3SVPROC glad_glColor3sv = NULL; 354 | PFNGLCOLOR3UBPROC glad_glColor3ub = NULL; 355 | PFNGLCOLOR3UBVPROC glad_glColor3ubv = NULL; 356 | PFNGLCOLOR3UIPROC glad_glColor3ui = NULL; 357 | PFNGLCOLOR3UIVPROC glad_glColor3uiv = NULL; 358 | PFNGLCOLOR3USPROC glad_glColor3us = NULL; 359 | PFNGLCOLOR3USVPROC glad_glColor3usv = NULL; 360 | PFNGLCOLOR4BPROC glad_glColor4b = NULL; 361 | PFNGLCOLOR4BVPROC glad_glColor4bv = NULL; 362 | PFNGLCOLOR4DPROC glad_glColor4d = NULL; 363 | PFNGLCOLOR4DVPROC glad_glColor4dv = NULL; 364 | PFNGLCOLOR4FPROC glad_glColor4f = NULL; 365 | PFNGLCOLOR4FVPROC glad_glColor4fv = NULL; 366 | PFNGLCOLOR4IPROC glad_glColor4i = NULL; 367 | PFNGLCOLOR4IVPROC glad_glColor4iv = NULL; 368 | PFNGLCOLOR4SPROC glad_glColor4s = NULL; 369 | PFNGLCOLOR4SVPROC glad_glColor4sv = NULL; 370 | PFNGLCOLOR4UBPROC glad_glColor4ub = NULL; 371 | PFNGLCOLOR4UBVPROC glad_glColor4ubv = NULL; 372 | PFNGLCOLOR4UIPROC glad_glColor4ui = NULL; 373 | PFNGLCOLOR4UIVPROC glad_glColor4uiv = NULL; 374 | PFNGLCOLOR4USPROC glad_glColor4us = NULL; 375 | PFNGLCOLOR4USVPROC glad_glColor4usv = NULL; 376 | PFNGLCOLORMASKPROC glad_glColorMask = NULL; 377 | PFNGLCOLORMASKIPROC glad_glColorMaski = NULL; 378 | PFNGLCOLORMATERIALPROC glad_glColorMaterial = NULL; 379 | PFNGLCOLORP3UIPROC glad_glColorP3ui = NULL; 380 | PFNGLCOLORP3UIVPROC glad_glColorP3uiv = NULL; 381 | PFNGLCOLORP4UIPROC glad_glColorP4ui = NULL; 382 | PFNGLCOLORP4UIVPROC glad_glColorP4uiv = NULL; 383 | PFNGLCOLORPOINTERPROC glad_glColorPointer = NULL; 384 | PFNGLCOMPILESHADERPROC glad_glCompileShader = NULL; 385 | PFNGLCOMPRESSEDTEXIMAGE1DPROC glad_glCompressedTexImage1D = NULL; 386 | PFNGLCOMPRESSEDTEXIMAGE2DPROC glad_glCompressedTexImage2D = NULL; 387 | PFNGLCOMPRESSEDTEXIMAGE3DPROC glad_glCompressedTexImage3D = NULL; 388 | PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC glad_glCompressedTexSubImage1D = NULL; 389 | PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC glad_glCompressedTexSubImage2D = NULL; 390 | PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC glad_glCompressedTexSubImage3D = NULL; 391 | PFNGLCOPYBUFFERSUBDATAPROC glad_glCopyBufferSubData = NULL; 392 | PFNGLCOPYIMAGESUBDATAPROC glad_glCopyImageSubData = NULL; 393 | PFNGLCOPYPIXELSPROC glad_glCopyPixels = NULL; 394 | PFNGLCOPYTEXIMAGE1DPROC glad_glCopyTexImage1D = NULL; 395 | PFNGLCOPYTEXIMAGE2DPROC glad_glCopyTexImage2D = NULL; 396 | PFNGLCOPYTEXSUBIMAGE1DPROC glad_glCopyTexSubImage1D = NULL; 397 | PFNGLCOPYTEXSUBIMAGE2DPROC glad_glCopyTexSubImage2D = NULL; 398 | PFNGLCOPYTEXSUBIMAGE3DPROC glad_glCopyTexSubImage3D = NULL; 399 | PFNGLCREATEPROGRAMPROC glad_glCreateProgram = NULL; 400 | PFNGLCREATESHADERPROC glad_glCreateShader = NULL; 401 | PFNGLCREATESHADERPROGRAMVPROC glad_glCreateShaderProgramv = NULL; 402 | PFNGLCULLFACEPROC glad_glCullFace = NULL; 403 | PFNGLDEBUGMESSAGECALLBACKPROC glad_glDebugMessageCallback = NULL; 404 | PFNGLDEBUGMESSAGECONTROLPROC glad_glDebugMessageControl = NULL; 405 | PFNGLDEBUGMESSAGEINSERTPROC glad_glDebugMessageInsert = NULL; 406 | PFNGLDELETEBUFFERSPROC glad_glDeleteBuffers = NULL; 407 | PFNGLDELETEFRAMEBUFFERSPROC glad_glDeleteFramebuffers = NULL; 408 | PFNGLDELETELISTSPROC glad_glDeleteLists = NULL; 409 | PFNGLDELETEPROGRAMPROC glad_glDeleteProgram = NULL; 410 | PFNGLDELETEPROGRAMPIPELINESPROC glad_glDeleteProgramPipelines = NULL; 411 | PFNGLDELETEQUERIESPROC glad_glDeleteQueries = NULL; 412 | PFNGLDELETERENDERBUFFERSPROC glad_glDeleteRenderbuffers = NULL; 413 | PFNGLDELETESAMPLERSPROC glad_glDeleteSamplers = NULL; 414 | PFNGLDELETESHADERPROC glad_glDeleteShader = NULL; 415 | PFNGLDELETESYNCPROC glad_glDeleteSync = NULL; 416 | PFNGLDELETETEXTURESPROC glad_glDeleteTextures = NULL; 417 | PFNGLDELETETRANSFORMFEEDBACKSPROC glad_glDeleteTransformFeedbacks = NULL; 418 | PFNGLDELETEVERTEXARRAYSPROC glad_glDeleteVertexArrays = NULL; 419 | PFNGLDEPTHFUNCPROC glad_glDepthFunc = NULL; 420 | PFNGLDEPTHMASKPROC glad_glDepthMask = NULL; 421 | PFNGLDEPTHRANGEPROC glad_glDepthRange = NULL; 422 | PFNGLDEPTHRANGEARRAYVPROC glad_glDepthRangeArrayv = NULL; 423 | PFNGLDEPTHRANGEINDEXEDPROC glad_glDepthRangeIndexed = NULL; 424 | PFNGLDEPTHRANGEFPROC glad_glDepthRangef = NULL; 425 | PFNGLDETACHSHADERPROC glad_glDetachShader = NULL; 426 | PFNGLDISABLEPROC glad_glDisable = NULL; 427 | PFNGLDISABLECLIENTSTATEPROC glad_glDisableClientState = NULL; 428 | PFNGLDISABLEVERTEXATTRIBARRAYPROC glad_glDisableVertexAttribArray = NULL; 429 | PFNGLDISABLEIPROC glad_glDisablei = NULL; 430 | PFNGLDISPATCHCOMPUTEPROC glad_glDispatchCompute = NULL; 431 | PFNGLDISPATCHCOMPUTEINDIRECTPROC glad_glDispatchComputeIndirect = NULL; 432 | PFNGLDRAWARRAYSPROC glad_glDrawArrays = NULL; 433 | PFNGLDRAWARRAYSINDIRECTPROC glad_glDrawArraysIndirect = NULL; 434 | PFNGLDRAWARRAYSINSTANCEDPROC glad_glDrawArraysInstanced = NULL; 435 | PFNGLDRAWARRAYSINSTANCEDBASEINSTANCEPROC glad_glDrawArraysInstancedBaseInstance = NULL; 436 | PFNGLDRAWBUFFERPROC glad_glDrawBuffer = NULL; 437 | PFNGLDRAWBUFFERSPROC glad_glDrawBuffers = NULL; 438 | PFNGLDRAWELEMENTSPROC glad_glDrawElements = NULL; 439 | PFNGLDRAWELEMENTSBASEVERTEXPROC glad_glDrawElementsBaseVertex = NULL; 440 | PFNGLDRAWELEMENTSINDIRECTPROC glad_glDrawElementsIndirect = NULL; 441 | PFNGLDRAWELEMENTSINSTANCEDPROC glad_glDrawElementsInstanced = NULL; 442 | PFNGLDRAWELEMENTSINSTANCEDBASEINSTANCEPROC glad_glDrawElementsInstancedBaseInstance = NULL; 443 | PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC glad_glDrawElementsInstancedBaseVertex = NULL; 444 | PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCEPROC glad_glDrawElementsInstancedBaseVertexBaseInstance = NULL; 445 | PFNGLDRAWPIXELSPROC glad_glDrawPixels = NULL; 446 | PFNGLDRAWRANGEELEMENTSPROC glad_glDrawRangeElements = NULL; 447 | PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC glad_glDrawRangeElementsBaseVertex = NULL; 448 | PFNGLDRAWTRANSFORMFEEDBACKPROC glad_glDrawTransformFeedback = NULL; 449 | PFNGLDRAWTRANSFORMFEEDBACKINSTANCEDPROC glad_glDrawTransformFeedbackInstanced = NULL; 450 | PFNGLDRAWTRANSFORMFEEDBACKSTREAMPROC glad_glDrawTransformFeedbackStream = NULL; 451 | PFNGLDRAWTRANSFORMFEEDBACKSTREAMINSTANCEDPROC glad_glDrawTransformFeedbackStreamInstanced = NULL; 452 | PFNGLEDGEFLAGPROC glad_glEdgeFlag = NULL; 453 | PFNGLEDGEFLAGPOINTERPROC glad_glEdgeFlagPointer = NULL; 454 | PFNGLEDGEFLAGVPROC glad_glEdgeFlagv = NULL; 455 | PFNGLENABLEPROC glad_glEnable = NULL; 456 | PFNGLENABLECLIENTSTATEPROC glad_glEnableClientState = NULL; 457 | PFNGLENABLEVERTEXATTRIBARRAYPROC glad_glEnableVertexAttribArray = NULL; 458 | PFNGLENABLEIPROC glad_glEnablei = NULL; 459 | PFNGLENDPROC glad_glEnd = NULL; 460 | PFNGLENDCONDITIONALRENDERPROC glad_glEndConditionalRender = NULL; 461 | PFNGLENDLISTPROC glad_glEndList = NULL; 462 | PFNGLENDQUERYPROC glad_glEndQuery = NULL; 463 | PFNGLENDQUERYINDEXEDPROC glad_glEndQueryIndexed = NULL; 464 | PFNGLENDTRANSFORMFEEDBACKPROC glad_glEndTransformFeedback = NULL; 465 | PFNGLEVALCOORD1DPROC glad_glEvalCoord1d = NULL; 466 | PFNGLEVALCOORD1DVPROC glad_glEvalCoord1dv = NULL; 467 | PFNGLEVALCOORD1FPROC glad_glEvalCoord1f = NULL; 468 | PFNGLEVALCOORD1FVPROC glad_glEvalCoord1fv = NULL; 469 | PFNGLEVALCOORD2DPROC glad_glEvalCoord2d = NULL; 470 | PFNGLEVALCOORD2DVPROC glad_glEvalCoord2dv = NULL; 471 | PFNGLEVALCOORD2FPROC glad_glEvalCoord2f = NULL; 472 | PFNGLEVALCOORD2FVPROC glad_glEvalCoord2fv = NULL; 473 | PFNGLEVALMESH1PROC glad_glEvalMesh1 = NULL; 474 | PFNGLEVALMESH2PROC glad_glEvalMesh2 = NULL; 475 | PFNGLEVALPOINT1PROC glad_glEvalPoint1 = NULL; 476 | PFNGLEVALPOINT2PROC glad_glEvalPoint2 = NULL; 477 | PFNGLFEEDBACKBUFFERPROC glad_glFeedbackBuffer = NULL; 478 | PFNGLFENCESYNCPROC glad_glFenceSync = NULL; 479 | PFNGLFINISHPROC glad_glFinish = NULL; 480 | PFNGLFLUSHPROC glad_glFlush = NULL; 481 | PFNGLFLUSHMAPPEDBUFFERRANGEPROC glad_glFlushMappedBufferRange = NULL; 482 | PFNGLFOGCOORDPOINTERPROC glad_glFogCoordPointer = NULL; 483 | PFNGLFOGCOORDDPROC glad_glFogCoordd = NULL; 484 | PFNGLFOGCOORDDVPROC glad_glFogCoorddv = NULL; 485 | PFNGLFOGCOORDFPROC glad_glFogCoordf = NULL; 486 | PFNGLFOGCOORDFVPROC glad_glFogCoordfv = NULL; 487 | PFNGLFOGFPROC glad_glFogf = NULL; 488 | PFNGLFOGFVPROC glad_glFogfv = NULL; 489 | PFNGLFOGIPROC glad_glFogi = NULL; 490 | PFNGLFOGIVPROC glad_glFogiv = NULL; 491 | PFNGLFRAMEBUFFERPARAMETERIPROC glad_glFramebufferParameteri = NULL; 492 | PFNGLFRAMEBUFFERRENDERBUFFERPROC glad_glFramebufferRenderbuffer = NULL; 493 | PFNGLFRAMEBUFFERTEXTUREPROC glad_glFramebufferTexture = NULL; 494 | PFNGLFRAMEBUFFERTEXTURE1DPROC glad_glFramebufferTexture1D = NULL; 495 | PFNGLFRAMEBUFFERTEXTURE2DPROC glad_glFramebufferTexture2D = NULL; 496 | PFNGLFRAMEBUFFERTEXTURE3DPROC glad_glFramebufferTexture3D = NULL; 497 | PFNGLFRAMEBUFFERTEXTURELAYERPROC glad_glFramebufferTextureLayer = NULL; 498 | PFNGLFRONTFACEPROC glad_glFrontFace = NULL; 499 | PFNGLFRUSTUMPROC glad_glFrustum = NULL; 500 | PFNGLGENBUFFERSPROC glad_glGenBuffers = NULL; 501 | PFNGLGENFRAMEBUFFERSPROC glad_glGenFramebuffers = NULL; 502 | PFNGLGENLISTSPROC glad_glGenLists = NULL; 503 | PFNGLGENPROGRAMPIPELINESPROC glad_glGenProgramPipelines = NULL; 504 | PFNGLGENQUERIESPROC glad_glGenQueries = NULL; 505 | PFNGLGENRENDERBUFFERSPROC glad_glGenRenderbuffers = NULL; 506 | PFNGLGENSAMPLERSPROC glad_glGenSamplers = NULL; 507 | PFNGLGENTEXTURESPROC glad_glGenTextures = NULL; 508 | PFNGLGENTRANSFORMFEEDBACKSPROC glad_glGenTransformFeedbacks = NULL; 509 | PFNGLGENVERTEXARRAYSPROC glad_glGenVertexArrays = NULL; 510 | PFNGLGENERATEMIPMAPPROC glad_glGenerateMipmap = NULL; 511 | PFNGLGETACTIVEATOMICCOUNTERBUFFERIVPROC glad_glGetActiveAtomicCounterBufferiv = NULL; 512 | PFNGLGETACTIVEATTRIBPROC glad_glGetActiveAttrib = NULL; 513 | PFNGLGETACTIVESUBROUTINENAMEPROC glad_glGetActiveSubroutineName = NULL; 514 | PFNGLGETACTIVESUBROUTINEUNIFORMNAMEPROC glad_glGetActiveSubroutineUniformName = NULL; 515 | PFNGLGETACTIVESUBROUTINEUNIFORMIVPROC glad_glGetActiveSubroutineUniformiv = NULL; 516 | PFNGLGETACTIVEUNIFORMPROC glad_glGetActiveUniform = NULL; 517 | PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC glad_glGetActiveUniformBlockName = NULL; 518 | PFNGLGETACTIVEUNIFORMBLOCKIVPROC glad_glGetActiveUniformBlockiv = NULL; 519 | PFNGLGETACTIVEUNIFORMNAMEPROC glad_glGetActiveUniformName = NULL; 520 | PFNGLGETACTIVEUNIFORMSIVPROC glad_glGetActiveUniformsiv = NULL; 521 | PFNGLGETATTACHEDSHADERSPROC glad_glGetAttachedShaders = NULL; 522 | PFNGLGETATTRIBLOCATIONPROC glad_glGetAttribLocation = NULL; 523 | PFNGLGETBOOLEANI_VPROC glad_glGetBooleani_v = NULL; 524 | PFNGLGETBOOLEANVPROC glad_glGetBooleanv = NULL; 525 | PFNGLGETBUFFERPARAMETERI64VPROC glad_glGetBufferParameteri64v = NULL; 526 | PFNGLGETBUFFERPARAMETERIVPROC glad_glGetBufferParameteriv = NULL; 527 | PFNGLGETBUFFERPOINTERVPROC glad_glGetBufferPointerv = NULL; 528 | PFNGLGETBUFFERSUBDATAPROC glad_glGetBufferSubData = NULL; 529 | PFNGLGETCLIPPLANEPROC glad_glGetClipPlane = NULL; 530 | PFNGLGETCOMPRESSEDTEXIMAGEPROC glad_glGetCompressedTexImage = NULL; 531 | PFNGLGETDEBUGMESSAGELOGPROC glad_glGetDebugMessageLog = NULL; 532 | PFNGLGETDOUBLEI_VPROC glad_glGetDoublei_v = NULL; 533 | PFNGLGETDOUBLEVPROC glad_glGetDoublev = NULL; 534 | PFNGLGETERRORPROC glad_glGetError = NULL; 535 | PFNGLGETFLOATI_VPROC glad_glGetFloati_v = NULL; 536 | PFNGLGETFLOATVPROC glad_glGetFloatv = NULL; 537 | PFNGLGETFRAGDATAINDEXPROC glad_glGetFragDataIndex = NULL; 538 | PFNGLGETFRAGDATALOCATIONPROC glad_glGetFragDataLocation = NULL; 539 | PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC glad_glGetFramebufferAttachmentParameteriv = NULL; 540 | PFNGLGETFRAMEBUFFERPARAMETERIVPROC glad_glGetFramebufferParameteriv = NULL; 541 | PFNGLGETINTEGER64I_VPROC glad_glGetInteger64i_v = NULL; 542 | PFNGLGETINTEGER64VPROC glad_glGetInteger64v = NULL; 543 | PFNGLGETINTEGERI_VPROC glad_glGetIntegeri_v = NULL; 544 | PFNGLGETINTEGERVPROC glad_glGetIntegerv = NULL; 545 | PFNGLGETINTERNALFORMATI64VPROC glad_glGetInternalformati64v = NULL; 546 | PFNGLGETINTERNALFORMATIVPROC glad_glGetInternalformativ = NULL; 547 | PFNGLGETLIGHTFVPROC glad_glGetLightfv = NULL; 548 | PFNGLGETLIGHTIVPROC glad_glGetLightiv = NULL; 549 | PFNGLGETMAPDVPROC glad_glGetMapdv = NULL; 550 | PFNGLGETMAPFVPROC glad_glGetMapfv = NULL; 551 | PFNGLGETMAPIVPROC glad_glGetMapiv = NULL; 552 | PFNGLGETMATERIALFVPROC glad_glGetMaterialfv = NULL; 553 | PFNGLGETMATERIALIVPROC glad_glGetMaterialiv = NULL; 554 | PFNGLGETMULTISAMPLEFVPROC glad_glGetMultisamplefv = NULL; 555 | PFNGLGETOBJECTLABELPROC glad_glGetObjectLabel = NULL; 556 | PFNGLGETOBJECTPTRLABELPROC glad_glGetObjectPtrLabel = NULL; 557 | PFNGLGETPIXELMAPFVPROC glad_glGetPixelMapfv = NULL; 558 | PFNGLGETPIXELMAPUIVPROC glad_glGetPixelMapuiv = NULL; 559 | PFNGLGETPIXELMAPUSVPROC glad_glGetPixelMapusv = NULL; 560 | PFNGLGETPOINTERVPROC glad_glGetPointerv = NULL; 561 | PFNGLGETPOLYGONSTIPPLEPROC glad_glGetPolygonStipple = NULL; 562 | PFNGLGETPROGRAMBINARYPROC glad_glGetProgramBinary = NULL; 563 | PFNGLGETPROGRAMINFOLOGPROC glad_glGetProgramInfoLog = NULL; 564 | PFNGLGETPROGRAMINTERFACEIVPROC glad_glGetProgramInterfaceiv = NULL; 565 | PFNGLGETPROGRAMPIPELINEINFOLOGPROC glad_glGetProgramPipelineInfoLog = NULL; 566 | PFNGLGETPROGRAMPIPELINEIVPROC glad_glGetProgramPipelineiv = NULL; 567 | PFNGLGETPROGRAMRESOURCEINDEXPROC glad_glGetProgramResourceIndex = NULL; 568 | PFNGLGETPROGRAMRESOURCELOCATIONPROC glad_glGetProgramResourceLocation = NULL; 569 | PFNGLGETPROGRAMRESOURCELOCATIONINDEXPROC glad_glGetProgramResourceLocationIndex = NULL; 570 | PFNGLGETPROGRAMRESOURCENAMEPROC glad_glGetProgramResourceName = NULL; 571 | PFNGLGETPROGRAMRESOURCEIVPROC glad_glGetProgramResourceiv = NULL; 572 | PFNGLGETPROGRAMSTAGEIVPROC glad_glGetProgramStageiv = NULL; 573 | PFNGLGETPROGRAMIVPROC glad_glGetProgramiv = NULL; 574 | PFNGLGETQUERYINDEXEDIVPROC glad_glGetQueryIndexediv = NULL; 575 | PFNGLGETQUERYOBJECTI64VPROC glad_glGetQueryObjecti64v = NULL; 576 | PFNGLGETQUERYOBJECTIVPROC glad_glGetQueryObjectiv = NULL; 577 | PFNGLGETQUERYOBJECTUI64VPROC glad_glGetQueryObjectui64v = NULL; 578 | PFNGLGETQUERYOBJECTUIVPROC glad_glGetQueryObjectuiv = NULL; 579 | PFNGLGETQUERYIVPROC glad_glGetQueryiv = NULL; 580 | PFNGLGETRENDERBUFFERPARAMETERIVPROC glad_glGetRenderbufferParameteriv = NULL; 581 | PFNGLGETSAMPLERPARAMETERIIVPROC glad_glGetSamplerParameterIiv = NULL; 582 | PFNGLGETSAMPLERPARAMETERIUIVPROC glad_glGetSamplerParameterIuiv = NULL; 583 | PFNGLGETSAMPLERPARAMETERFVPROC glad_glGetSamplerParameterfv = NULL; 584 | PFNGLGETSAMPLERPARAMETERIVPROC glad_glGetSamplerParameteriv = NULL; 585 | PFNGLGETSHADERINFOLOGPROC glad_glGetShaderInfoLog = NULL; 586 | PFNGLGETSHADERPRECISIONFORMATPROC glad_glGetShaderPrecisionFormat = NULL; 587 | PFNGLGETSHADERSOURCEPROC glad_glGetShaderSource = NULL; 588 | PFNGLGETSHADERIVPROC glad_glGetShaderiv = NULL; 589 | PFNGLGETSTRINGPROC glad_glGetString = NULL; 590 | PFNGLGETSTRINGIPROC glad_glGetStringi = NULL; 591 | PFNGLGETSUBROUTINEINDEXPROC glad_glGetSubroutineIndex = NULL; 592 | PFNGLGETSUBROUTINEUNIFORMLOCATIONPROC glad_glGetSubroutineUniformLocation = NULL; 593 | PFNGLGETSYNCIVPROC glad_glGetSynciv = NULL; 594 | PFNGLGETTEXENVFVPROC glad_glGetTexEnvfv = NULL; 595 | PFNGLGETTEXENVIVPROC glad_glGetTexEnviv = NULL; 596 | PFNGLGETTEXGENDVPROC glad_glGetTexGendv = NULL; 597 | PFNGLGETTEXGENFVPROC glad_glGetTexGenfv = NULL; 598 | PFNGLGETTEXGENIVPROC glad_glGetTexGeniv = NULL; 599 | PFNGLGETTEXIMAGEPROC glad_glGetTexImage = NULL; 600 | PFNGLGETTEXLEVELPARAMETERFVPROC glad_glGetTexLevelParameterfv = NULL; 601 | PFNGLGETTEXLEVELPARAMETERIVPROC glad_glGetTexLevelParameteriv = NULL; 602 | PFNGLGETTEXPARAMETERIIVPROC glad_glGetTexParameterIiv = NULL; 603 | PFNGLGETTEXPARAMETERIUIVPROC glad_glGetTexParameterIuiv = NULL; 604 | PFNGLGETTEXPARAMETERFVPROC glad_glGetTexParameterfv = NULL; 605 | PFNGLGETTEXPARAMETERIVPROC glad_glGetTexParameteriv = NULL; 606 | PFNGLGETTRANSFORMFEEDBACKVARYINGPROC glad_glGetTransformFeedbackVarying = NULL; 607 | PFNGLGETUNIFORMBLOCKINDEXPROC glad_glGetUniformBlockIndex = NULL; 608 | PFNGLGETUNIFORMINDICESPROC glad_glGetUniformIndices = NULL; 609 | PFNGLGETUNIFORMLOCATIONPROC glad_glGetUniformLocation = NULL; 610 | PFNGLGETUNIFORMSUBROUTINEUIVPROC glad_glGetUniformSubroutineuiv = NULL; 611 | PFNGLGETUNIFORMDVPROC glad_glGetUniformdv = NULL; 612 | PFNGLGETUNIFORMFVPROC glad_glGetUniformfv = NULL; 613 | PFNGLGETUNIFORMIVPROC glad_glGetUniformiv = NULL; 614 | PFNGLGETUNIFORMUIVPROC glad_glGetUniformuiv = NULL; 615 | PFNGLGETVERTEXATTRIBIIVPROC glad_glGetVertexAttribIiv = NULL; 616 | PFNGLGETVERTEXATTRIBIUIVPROC glad_glGetVertexAttribIuiv = NULL; 617 | PFNGLGETVERTEXATTRIBLDVPROC glad_glGetVertexAttribLdv = NULL; 618 | PFNGLGETVERTEXATTRIBPOINTERVPROC glad_glGetVertexAttribPointerv = NULL; 619 | PFNGLGETVERTEXATTRIBDVPROC glad_glGetVertexAttribdv = NULL; 620 | PFNGLGETVERTEXATTRIBFVPROC glad_glGetVertexAttribfv = NULL; 621 | PFNGLGETVERTEXATTRIBIVPROC glad_glGetVertexAttribiv = NULL; 622 | PFNGLHINTPROC glad_glHint = NULL; 623 | PFNGLINDEXMASKPROC glad_glIndexMask = NULL; 624 | PFNGLINDEXPOINTERPROC glad_glIndexPointer = NULL; 625 | PFNGLINDEXDPROC glad_glIndexd = NULL; 626 | PFNGLINDEXDVPROC glad_glIndexdv = NULL; 627 | PFNGLINDEXFPROC glad_glIndexf = NULL; 628 | PFNGLINDEXFVPROC glad_glIndexfv = NULL; 629 | PFNGLINDEXIPROC glad_glIndexi = NULL; 630 | PFNGLINDEXIVPROC glad_glIndexiv = NULL; 631 | PFNGLINDEXSPROC glad_glIndexs = NULL; 632 | PFNGLINDEXSVPROC glad_glIndexsv = NULL; 633 | PFNGLINDEXUBPROC glad_glIndexub = NULL; 634 | PFNGLINDEXUBVPROC glad_glIndexubv = NULL; 635 | PFNGLINITNAMESPROC glad_glInitNames = NULL; 636 | PFNGLINTERLEAVEDARRAYSPROC glad_glInterleavedArrays = NULL; 637 | PFNGLINVALIDATEBUFFERDATAPROC glad_glInvalidateBufferData = NULL; 638 | PFNGLINVALIDATEBUFFERSUBDATAPROC glad_glInvalidateBufferSubData = NULL; 639 | PFNGLINVALIDATEFRAMEBUFFERPROC glad_glInvalidateFramebuffer = NULL; 640 | PFNGLINVALIDATESUBFRAMEBUFFERPROC glad_glInvalidateSubFramebuffer = NULL; 641 | PFNGLINVALIDATETEXIMAGEPROC glad_glInvalidateTexImage = NULL; 642 | PFNGLINVALIDATETEXSUBIMAGEPROC glad_glInvalidateTexSubImage = NULL; 643 | PFNGLISBUFFERPROC glad_glIsBuffer = NULL; 644 | PFNGLISENABLEDPROC glad_glIsEnabled = NULL; 645 | PFNGLISENABLEDIPROC glad_glIsEnabledi = NULL; 646 | PFNGLISFRAMEBUFFERPROC glad_glIsFramebuffer = NULL; 647 | PFNGLISLISTPROC glad_glIsList = NULL; 648 | PFNGLISPROGRAMPROC glad_glIsProgram = NULL; 649 | PFNGLISPROGRAMPIPELINEPROC glad_glIsProgramPipeline = NULL; 650 | PFNGLISQUERYPROC glad_glIsQuery = NULL; 651 | PFNGLISRENDERBUFFERPROC glad_glIsRenderbuffer = NULL; 652 | PFNGLISSAMPLERPROC glad_glIsSampler = NULL; 653 | PFNGLISSHADERPROC glad_glIsShader = NULL; 654 | PFNGLISSYNCPROC glad_glIsSync = NULL; 655 | PFNGLISTEXTUREPROC glad_glIsTexture = NULL; 656 | PFNGLISTRANSFORMFEEDBACKPROC glad_glIsTransformFeedback = NULL; 657 | PFNGLISVERTEXARRAYPROC glad_glIsVertexArray = NULL; 658 | PFNGLLIGHTMODELFPROC glad_glLightModelf = NULL; 659 | PFNGLLIGHTMODELFVPROC glad_glLightModelfv = NULL; 660 | PFNGLLIGHTMODELIPROC glad_glLightModeli = NULL; 661 | PFNGLLIGHTMODELIVPROC glad_glLightModeliv = NULL; 662 | PFNGLLIGHTFPROC glad_glLightf = NULL; 663 | PFNGLLIGHTFVPROC glad_glLightfv = NULL; 664 | PFNGLLIGHTIPROC glad_glLighti = NULL; 665 | PFNGLLIGHTIVPROC glad_glLightiv = NULL; 666 | PFNGLLINESTIPPLEPROC glad_glLineStipple = NULL; 667 | PFNGLLINEWIDTHPROC glad_glLineWidth = NULL; 668 | PFNGLLINKPROGRAMPROC glad_glLinkProgram = NULL; 669 | PFNGLLISTBASEPROC glad_glListBase = NULL; 670 | PFNGLLOADIDENTITYPROC glad_glLoadIdentity = NULL; 671 | PFNGLLOADMATRIXDPROC glad_glLoadMatrixd = NULL; 672 | PFNGLLOADMATRIXFPROC glad_glLoadMatrixf = NULL; 673 | PFNGLLOADNAMEPROC glad_glLoadName = NULL; 674 | PFNGLLOADTRANSPOSEMATRIXDPROC glad_glLoadTransposeMatrixd = NULL; 675 | PFNGLLOADTRANSPOSEMATRIXFPROC glad_glLoadTransposeMatrixf = NULL; 676 | PFNGLLOGICOPPROC glad_glLogicOp = NULL; 677 | PFNGLMAP1DPROC glad_glMap1d = NULL; 678 | PFNGLMAP1FPROC glad_glMap1f = NULL; 679 | PFNGLMAP2DPROC glad_glMap2d = NULL; 680 | PFNGLMAP2FPROC glad_glMap2f = NULL; 681 | PFNGLMAPBUFFERPROC glad_glMapBuffer = NULL; 682 | PFNGLMAPBUFFERRANGEPROC glad_glMapBufferRange = NULL; 683 | PFNGLMAPGRID1DPROC glad_glMapGrid1d = NULL; 684 | PFNGLMAPGRID1FPROC glad_glMapGrid1f = NULL; 685 | PFNGLMAPGRID2DPROC glad_glMapGrid2d = NULL; 686 | PFNGLMAPGRID2FPROC glad_glMapGrid2f = NULL; 687 | PFNGLMATERIALFPROC glad_glMaterialf = NULL; 688 | PFNGLMATERIALFVPROC glad_glMaterialfv = NULL; 689 | PFNGLMATERIALIPROC glad_glMateriali = NULL; 690 | PFNGLMATERIALIVPROC glad_glMaterialiv = NULL; 691 | PFNGLMATRIXMODEPROC glad_glMatrixMode = NULL; 692 | PFNGLMEMORYBARRIERPROC glad_glMemoryBarrier = NULL; 693 | PFNGLMINSAMPLESHADINGPROC glad_glMinSampleShading = NULL; 694 | PFNGLMULTMATRIXDPROC glad_glMultMatrixd = NULL; 695 | PFNGLMULTMATRIXFPROC glad_glMultMatrixf = NULL; 696 | PFNGLMULTTRANSPOSEMATRIXDPROC glad_glMultTransposeMatrixd = NULL; 697 | PFNGLMULTTRANSPOSEMATRIXFPROC glad_glMultTransposeMatrixf = NULL; 698 | PFNGLMULTIDRAWARRAYSPROC glad_glMultiDrawArrays = NULL; 699 | PFNGLMULTIDRAWARRAYSINDIRECTPROC glad_glMultiDrawArraysIndirect = NULL; 700 | PFNGLMULTIDRAWELEMENTSPROC glad_glMultiDrawElements = NULL; 701 | PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC glad_glMultiDrawElementsBaseVertex = NULL; 702 | PFNGLMULTIDRAWELEMENTSINDIRECTPROC glad_glMultiDrawElementsIndirect = NULL; 703 | PFNGLMULTITEXCOORD1DPROC glad_glMultiTexCoord1d = NULL; 704 | PFNGLMULTITEXCOORD1DVPROC glad_glMultiTexCoord1dv = NULL; 705 | PFNGLMULTITEXCOORD1FPROC glad_glMultiTexCoord1f = NULL; 706 | PFNGLMULTITEXCOORD1FVPROC glad_glMultiTexCoord1fv = NULL; 707 | PFNGLMULTITEXCOORD1IPROC glad_glMultiTexCoord1i = NULL; 708 | PFNGLMULTITEXCOORD1IVPROC glad_glMultiTexCoord1iv = NULL; 709 | PFNGLMULTITEXCOORD1SPROC glad_glMultiTexCoord1s = NULL; 710 | PFNGLMULTITEXCOORD1SVPROC glad_glMultiTexCoord1sv = NULL; 711 | PFNGLMULTITEXCOORD2DPROC glad_glMultiTexCoord2d = NULL; 712 | PFNGLMULTITEXCOORD2DVPROC glad_glMultiTexCoord2dv = NULL; 713 | PFNGLMULTITEXCOORD2FPROC glad_glMultiTexCoord2f = NULL; 714 | PFNGLMULTITEXCOORD2FVPROC glad_glMultiTexCoord2fv = NULL; 715 | PFNGLMULTITEXCOORD2IPROC glad_glMultiTexCoord2i = NULL; 716 | PFNGLMULTITEXCOORD2IVPROC glad_glMultiTexCoord2iv = NULL; 717 | PFNGLMULTITEXCOORD2SPROC glad_glMultiTexCoord2s = NULL; 718 | PFNGLMULTITEXCOORD2SVPROC glad_glMultiTexCoord2sv = NULL; 719 | PFNGLMULTITEXCOORD3DPROC glad_glMultiTexCoord3d = NULL; 720 | PFNGLMULTITEXCOORD3DVPROC glad_glMultiTexCoord3dv = NULL; 721 | PFNGLMULTITEXCOORD3FPROC glad_glMultiTexCoord3f = NULL; 722 | PFNGLMULTITEXCOORD3FVPROC glad_glMultiTexCoord3fv = NULL; 723 | PFNGLMULTITEXCOORD3IPROC glad_glMultiTexCoord3i = NULL; 724 | PFNGLMULTITEXCOORD3IVPROC glad_glMultiTexCoord3iv = NULL; 725 | PFNGLMULTITEXCOORD3SPROC glad_glMultiTexCoord3s = NULL; 726 | PFNGLMULTITEXCOORD3SVPROC glad_glMultiTexCoord3sv = NULL; 727 | PFNGLMULTITEXCOORD4DPROC glad_glMultiTexCoord4d = NULL; 728 | PFNGLMULTITEXCOORD4DVPROC glad_glMultiTexCoord4dv = NULL; 729 | PFNGLMULTITEXCOORD4FPROC glad_glMultiTexCoord4f = NULL; 730 | PFNGLMULTITEXCOORD4FVPROC glad_glMultiTexCoord4fv = NULL; 731 | PFNGLMULTITEXCOORD4IPROC glad_glMultiTexCoord4i = NULL; 732 | PFNGLMULTITEXCOORD4IVPROC glad_glMultiTexCoord4iv = NULL; 733 | PFNGLMULTITEXCOORD4SPROC glad_glMultiTexCoord4s = NULL; 734 | PFNGLMULTITEXCOORD4SVPROC glad_glMultiTexCoord4sv = NULL; 735 | PFNGLMULTITEXCOORDP1UIPROC glad_glMultiTexCoordP1ui = NULL; 736 | PFNGLMULTITEXCOORDP1UIVPROC glad_glMultiTexCoordP1uiv = NULL; 737 | PFNGLMULTITEXCOORDP2UIPROC glad_glMultiTexCoordP2ui = NULL; 738 | PFNGLMULTITEXCOORDP2UIVPROC glad_glMultiTexCoordP2uiv = NULL; 739 | PFNGLMULTITEXCOORDP3UIPROC glad_glMultiTexCoordP3ui = NULL; 740 | PFNGLMULTITEXCOORDP3UIVPROC glad_glMultiTexCoordP3uiv = NULL; 741 | PFNGLMULTITEXCOORDP4UIPROC glad_glMultiTexCoordP4ui = NULL; 742 | PFNGLMULTITEXCOORDP4UIVPROC glad_glMultiTexCoordP4uiv = NULL; 743 | PFNGLNEWLISTPROC glad_glNewList = NULL; 744 | PFNGLNORMAL3BPROC glad_glNormal3b = NULL; 745 | PFNGLNORMAL3BVPROC glad_glNormal3bv = NULL; 746 | PFNGLNORMAL3DPROC glad_glNormal3d = NULL; 747 | PFNGLNORMAL3DVPROC glad_glNormal3dv = NULL; 748 | PFNGLNORMAL3FPROC glad_glNormal3f = NULL; 749 | PFNGLNORMAL3FVPROC glad_glNormal3fv = NULL; 750 | PFNGLNORMAL3IPROC glad_glNormal3i = NULL; 751 | PFNGLNORMAL3IVPROC glad_glNormal3iv = NULL; 752 | PFNGLNORMAL3SPROC glad_glNormal3s = NULL; 753 | PFNGLNORMAL3SVPROC glad_glNormal3sv = NULL; 754 | PFNGLNORMALP3UIPROC glad_glNormalP3ui = NULL; 755 | PFNGLNORMALP3UIVPROC glad_glNormalP3uiv = NULL; 756 | PFNGLNORMALPOINTERPROC glad_glNormalPointer = NULL; 757 | PFNGLOBJECTLABELPROC glad_glObjectLabel = NULL; 758 | PFNGLOBJECTPTRLABELPROC glad_glObjectPtrLabel = NULL; 759 | PFNGLORTHOPROC glad_glOrtho = NULL; 760 | PFNGLPASSTHROUGHPROC glad_glPassThrough = NULL; 761 | PFNGLPATCHPARAMETERFVPROC glad_glPatchParameterfv = NULL; 762 | PFNGLPATCHPARAMETERIPROC glad_glPatchParameteri = NULL; 763 | PFNGLPAUSETRANSFORMFEEDBACKPROC glad_glPauseTransformFeedback = NULL; 764 | PFNGLPIXELMAPFVPROC glad_glPixelMapfv = NULL; 765 | PFNGLPIXELMAPUIVPROC glad_glPixelMapuiv = NULL; 766 | PFNGLPIXELMAPUSVPROC glad_glPixelMapusv = NULL; 767 | PFNGLPIXELSTOREFPROC glad_glPixelStoref = NULL; 768 | PFNGLPIXELSTOREIPROC glad_glPixelStorei = NULL; 769 | PFNGLPIXELTRANSFERFPROC glad_glPixelTransferf = NULL; 770 | PFNGLPIXELTRANSFERIPROC glad_glPixelTransferi = NULL; 771 | PFNGLPIXELZOOMPROC glad_glPixelZoom = NULL; 772 | PFNGLPOINTPARAMETERFPROC glad_glPointParameterf = NULL; 773 | PFNGLPOINTPARAMETERFVPROC glad_glPointParameterfv = NULL; 774 | PFNGLPOINTPARAMETERIPROC glad_glPointParameteri = NULL; 775 | PFNGLPOINTPARAMETERIVPROC glad_glPointParameteriv = NULL; 776 | PFNGLPOINTSIZEPROC glad_glPointSize = NULL; 777 | PFNGLPOLYGONMODEPROC glad_glPolygonMode = NULL; 778 | PFNGLPOLYGONOFFSETPROC glad_glPolygonOffset = NULL; 779 | PFNGLPOLYGONSTIPPLEPROC glad_glPolygonStipple = NULL; 780 | PFNGLPOPATTRIBPROC glad_glPopAttrib = NULL; 781 | PFNGLPOPCLIENTATTRIBPROC glad_glPopClientAttrib = NULL; 782 | PFNGLPOPDEBUGGROUPPROC glad_glPopDebugGroup = NULL; 783 | PFNGLPOPMATRIXPROC glad_glPopMatrix = NULL; 784 | PFNGLPOPNAMEPROC glad_glPopName = NULL; 785 | PFNGLPRIMITIVERESTARTINDEXPROC glad_glPrimitiveRestartIndex = NULL; 786 | PFNGLPRIORITIZETEXTURESPROC glad_glPrioritizeTextures = NULL; 787 | PFNGLPROGRAMBINARYPROC glad_glProgramBinary = NULL; 788 | PFNGLPROGRAMPARAMETERIPROC glad_glProgramParameteri = NULL; 789 | PFNGLPROGRAMUNIFORM1DPROC glad_glProgramUniform1d = NULL; 790 | PFNGLPROGRAMUNIFORM1DVPROC glad_glProgramUniform1dv = NULL; 791 | PFNGLPROGRAMUNIFORM1FPROC glad_glProgramUniform1f = NULL; 792 | PFNGLPROGRAMUNIFORM1FVPROC glad_glProgramUniform1fv = NULL; 793 | PFNGLPROGRAMUNIFORM1IPROC glad_glProgramUniform1i = NULL; 794 | PFNGLPROGRAMUNIFORM1IVPROC glad_glProgramUniform1iv = NULL; 795 | PFNGLPROGRAMUNIFORM1UIPROC glad_glProgramUniform1ui = NULL; 796 | PFNGLPROGRAMUNIFORM1UIVPROC glad_glProgramUniform1uiv = NULL; 797 | PFNGLPROGRAMUNIFORM2DPROC glad_glProgramUniform2d = NULL; 798 | PFNGLPROGRAMUNIFORM2DVPROC glad_glProgramUniform2dv = NULL; 799 | PFNGLPROGRAMUNIFORM2FPROC glad_glProgramUniform2f = NULL; 800 | PFNGLPROGRAMUNIFORM2FVPROC glad_glProgramUniform2fv = NULL; 801 | PFNGLPROGRAMUNIFORM2IPROC glad_glProgramUniform2i = NULL; 802 | PFNGLPROGRAMUNIFORM2IVPROC glad_glProgramUniform2iv = NULL; 803 | PFNGLPROGRAMUNIFORM2UIPROC glad_glProgramUniform2ui = NULL; 804 | PFNGLPROGRAMUNIFORM2UIVPROC glad_glProgramUniform2uiv = NULL; 805 | PFNGLPROGRAMUNIFORM3DPROC glad_glProgramUniform3d = NULL; 806 | PFNGLPROGRAMUNIFORM3DVPROC glad_glProgramUniform3dv = NULL; 807 | PFNGLPROGRAMUNIFORM3FPROC glad_glProgramUniform3f = NULL; 808 | PFNGLPROGRAMUNIFORM3FVPROC glad_glProgramUniform3fv = NULL; 809 | PFNGLPROGRAMUNIFORM3IPROC glad_glProgramUniform3i = NULL; 810 | PFNGLPROGRAMUNIFORM3IVPROC glad_glProgramUniform3iv = NULL; 811 | PFNGLPROGRAMUNIFORM3UIPROC glad_glProgramUniform3ui = NULL; 812 | PFNGLPROGRAMUNIFORM3UIVPROC glad_glProgramUniform3uiv = NULL; 813 | PFNGLPROGRAMUNIFORM4DPROC glad_glProgramUniform4d = NULL; 814 | PFNGLPROGRAMUNIFORM4DVPROC glad_glProgramUniform4dv = NULL; 815 | PFNGLPROGRAMUNIFORM4FPROC glad_glProgramUniform4f = NULL; 816 | PFNGLPROGRAMUNIFORM4FVPROC glad_glProgramUniform4fv = NULL; 817 | PFNGLPROGRAMUNIFORM4IPROC glad_glProgramUniform4i = NULL; 818 | PFNGLPROGRAMUNIFORM4IVPROC glad_glProgramUniform4iv = NULL; 819 | PFNGLPROGRAMUNIFORM4UIPROC glad_glProgramUniform4ui = NULL; 820 | PFNGLPROGRAMUNIFORM4UIVPROC glad_glProgramUniform4uiv = NULL; 821 | PFNGLPROGRAMUNIFORMMATRIX2DVPROC glad_glProgramUniformMatrix2dv = NULL; 822 | PFNGLPROGRAMUNIFORMMATRIX2FVPROC glad_glProgramUniformMatrix2fv = NULL; 823 | PFNGLPROGRAMUNIFORMMATRIX2X3DVPROC glad_glProgramUniformMatrix2x3dv = NULL; 824 | PFNGLPROGRAMUNIFORMMATRIX2X3FVPROC glad_glProgramUniformMatrix2x3fv = NULL; 825 | PFNGLPROGRAMUNIFORMMATRIX2X4DVPROC glad_glProgramUniformMatrix2x4dv = NULL; 826 | PFNGLPROGRAMUNIFORMMATRIX2X4FVPROC glad_glProgramUniformMatrix2x4fv = NULL; 827 | PFNGLPROGRAMUNIFORMMATRIX3DVPROC glad_glProgramUniformMatrix3dv = NULL; 828 | PFNGLPROGRAMUNIFORMMATRIX3FVPROC glad_glProgramUniformMatrix3fv = NULL; 829 | PFNGLPROGRAMUNIFORMMATRIX3X2DVPROC glad_glProgramUniformMatrix3x2dv = NULL; 830 | PFNGLPROGRAMUNIFORMMATRIX3X2FVPROC glad_glProgramUniformMatrix3x2fv = NULL; 831 | PFNGLPROGRAMUNIFORMMATRIX3X4DVPROC glad_glProgramUniformMatrix3x4dv = NULL; 832 | PFNGLPROGRAMUNIFORMMATRIX3X4FVPROC glad_glProgramUniformMatrix3x4fv = NULL; 833 | PFNGLPROGRAMUNIFORMMATRIX4DVPROC glad_glProgramUniformMatrix4dv = NULL; 834 | PFNGLPROGRAMUNIFORMMATRIX4FVPROC glad_glProgramUniformMatrix4fv = NULL; 835 | PFNGLPROGRAMUNIFORMMATRIX4X2DVPROC glad_glProgramUniformMatrix4x2dv = NULL; 836 | PFNGLPROGRAMUNIFORMMATRIX4X2FVPROC glad_glProgramUniformMatrix4x2fv = NULL; 837 | PFNGLPROGRAMUNIFORMMATRIX4X3DVPROC glad_glProgramUniformMatrix4x3dv = NULL; 838 | PFNGLPROGRAMUNIFORMMATRIX4X3FVPROC glad_glProgramUniformMatrix4x3fv = NULL; 839 | PFNGLPROVOKINGVERTEXPROC glad_glProvokingVertex = NULL; 840 | PFNGLPUSHATTRIBPROC glad_glPushAttrib = NULL; 841 | PFNGLPUSHCLIENTATTRIBPROC glad_glPushClientAttrib = NULL; 842 | PFNGLPUSHDEBUGGROUPPROC glad_glPushDebugGroup = NULL; 843 | PFNGLPUSHMATRIXPROC glad_glPushMatrix = NULL; 844 | PFNGLPUSHNAMEPROC glad_glPushName = NULL; 845 | PFNGLQUERYCOUNTERPROC glad_glQueryCounter = NULL; 846 | PFNGLRASTERPOS2DPROC glad_glRasterPos2d = NULL; 847 | PFNGLRASTERPOS2DVPROC glad_glRasterPos2dv = NULL; 848 | PFNGLRASTERPOS2FPROC glad_glRasterPos2f = NULL; 849 | PFNGLRASTERPOS2FVPROC glad_glRasterPos2fv = NULL; 850 | PFNGLRASTERPOS2IPROC glad_glRasterPos2i = NULL; 851 | PFNGLRASTERPOS2IVPROC glad_glRasterPos2iv = NULL; 852 | PFNGLRASTERPOS2SPROC glad_glRasterPos2s = NULL; 853 | PFNGLRASTERPOS2SVPROC glad_glRasterPos2sv = NULL; 854 | PFNGLRASTERPOS3DPROC glad_glRasterPos3d = NULL; 855 | PFNGLRASTERPOS3DVPROC glad_glRasterPos3dv = NULL; 856 | PFNGLRASTERPOS3FPROC glad_glRasterPos3f = NULL; 857 | PFNGLRASTERPOS3FVPROC glad_glRasterPos3fv = NULL; 858 | PFNGLRASTERPOS3IPROC glad_glRasterPos3i = NULL; 859 | PFNGLRASTERPOS3IVPROC glad_glRasterPos3iv = NULL; 860 | PFNGLRASTERPOS3SPROC glad_glRasterPos3s = NULL; 861 | PFNGLRASTERPOS3SVPROC glad_glRasterPos3sv = NULL; 862 | PFNGLRASTERPOS4DPROC glad_glRasterPos4d = NULL; 863 | PFNGLRASTERPOS4DVPROC glad_glRasterPos4dv = NULL; 864 | PFNGLRASTERPOS4FPROC glad_glRasterPos4f = NULL; 865 | PFNGLRASTERPOS4FVPROC glad_glRasterPos4fv = NULL; 866 | PFNGLRASTERPOS4IPROC glad_glRasterPos4i = NULL; 867 | PFNGLRASTERPOS4IVPROC glad_glRasterPos4iv = NULL; 868 | PFNGLRASTERPOS4SPROC glad_glRasterPos4s = NULL; 869 | PFNGLRASTERPOS4SVPROC glad_glRasterPos4sv = NULL; 870 | PFNGLREADBUFFERPROC glad_glReadBuffer = NULL; 871 | PFNGLREADPIXELSPROC glad_glReadPixels = NULL; 872 | PFNGLRECTDPROC glad_glRectd = NULL; 873 | PFNGLRECTDVPROC glad_glRectdv = NULL; 874 | PFNGLRECTFPROC glad_glRectf = NULL; 875 | PFNGLRECTFVPROC glad_glRectfv = NULL; 876 | PFNGLRECTIPROC glad_glRecti = NULL; 877 | PFNGLRECTIVPROC glad_glRectiv = NULL; 878 | PFNGLRECTSPROC glad_glRects = NULL; 879 | PFNGLRECTSVPROC glad_glRectsv = NULL; 880 | PFNGLRELEASESHADERCOMPILERPROC glad_glReleaseShaderCompiler = NULL; 881 | PFNGLRENDERMODEPROC glad_glRenderMode = NULL; 882 | PFNGLRENDERBUFFERSTORAGEPROC glad_glRenderbufferStorage = NULL; 883 | PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC glad_glRenderbufferStorageMultisample = NULL; 884 | PFNGLRESUMETRANSFORMFEEDBACKPROC glad_glResumeTransformFeedback = NULL; 885 | PFNGLROTATEDPROC glad_glRotated = NULL; 886 | PFNGLROTATEFPROC glad_glRotatef = NULL; 887 | PFNGLSAMPLECOVERAGEPROC glad_glSampleCoverage = NULL; 888 | PFNGLSAMPLEMASKIPROC glad_glSampleMaski = NULL; 889 | PFNGLSAMPLERPARAMETERIIVPROC glad_glSamplerParameterIiv = NULL; 890 | PFNGLSAMPLERPARAMETERIUIVPROC glad_glSamplerParameterIuiv = NULL; 891 | PFNGLSAMPLERPARAMETERFPROC glad_glSamplerParameterf = NULL; 892 | PFNGLSAMPLERPARAMETERFVPROC glad_glSamplerParameterfv = NULL; 893 | PFNGLSAMPLERPARAMETERIPROC glad_glSamplerParameteri = NULL; 894 | PFNGLSAMPLERPARAMETERIVPROC glad_glSamplerParameteriv = NULL; 895 | PFNGLSCALEDPROC glad_glScaled = NULL; 896 | PFNGLSCALEFPROC glad_glScalef = NULL; 897 | PFNGLSCISSORPROC glad_glScissor = NULL; 898 | PFNGLSCISSORARRAYVPROC glad_glScissorArrayv = NULL; 899 | PFNGLSCISSORINDEXEDPROC glad_glScissorIndexed = NULL; 900 | PFNGLSCISSORINDEXEDVPROC glad_glScissorIndexedv = NULL; 901 | PFNGLSECONDARYCOLOR3BPROC glad_glSecondaryColor3b = NULL; 902 | PFNGLSECONDARYCOLOR3BVPROC glad_glSecondaryColor3bv = NULL; 903 | PFNGLSECONDARYCOLOR3DPROC glad_glSecondaryColor3d = NULL; 904 | PFNGLSECONDARYCOLOR3DVPROC glad_glSecondaryColor3dv = NULL; 905 | PFNGLSECONDARYCOLOR3FPROC glad_glSecondaryColor3f = NULL; 906 | PFNGLSECONDARYCOLOR3FVPROC glad_glSecondaryColor3fv = NULL; 907 | PFNGLSECONDARYCOLOR3IPROC glad_glSecondaryColor3i = NULL; 908 | PFNGLSECONDARYCOLOR3IVPROC glad_glSecondaryColor3iv = NULL; 909 | PFNGLSECONDARYCOLOR3SPROC glad_glSecondaryColor3s = NULL; 910 | PFNGLSECONDARYCOLOR3SVPROC glad_glSecondaryColor3sv = NULL; 911 | PFNGLSECONDARYCOLOR3UBPROC glad_glSecondaryColor3ub = NULL; 912 | PFNGLSECONDARYCOLOR3UBVPROC glad_glSecondaryColor3ubv = NULL; 913 | PFNGLSECONDARYCOLOR3UIPROC glad_glSecondaryColor3ui = NULL; 914 | PFNGLSECONDARYCOLOR3UIVPROC glad_glSecondaryColor3uiv = NULL; 915 | PFNGLSECONDARYCOLOR3USPROC glad_glSecondaryColor3us = NULL; 916 | PFNGLSECONDARYCOLOR3USVPROC glad_glSecondaryColor3usv = NULL; 917 | PFNGLSECONDARYCOLORP3UIPROC glad_glSecondaryColorP3ui = NULL; 918 | PFNGLSECONDARYCOLORP3UIVPROC glad_glSecondaryColorP3uiv = NULL; 919 | PFNGLSECONDARYCOLORPOINTERPROC glad_glSecondaryColorPointer = NULL; 920 | PFNGLSELECTBUFFERPROC glad_glSelectBuffer = NULL; 921 | PFNGLSHADEMODELPROC glad_glShadeModel = NULL; 922 | PFNGLSHADERBINARYPROC glad_glShaderBinary = NULL; 923 | PFNGLSHADERSOURCEPROC glad_glShaderSource = NULL; 924 | PFNGLSHADERSTORAGEBLOCKBINDINGPROC glad_glShaderStorageBlockBinding = NULL; 925 | PFNGLSTENCILFUNCPROC glad_glStencilFunc = NULL; 926 | PFNGLSTENCILFUNCSEPARATEPROC glad_glStencilFuncSeparate = NULL; 927 | PFNGLSTENCILMASKPROC glad_glStencilMask = NULL; 928 | PFNGLSTENCILMASKSEPARATEPROC glad_glStencilMaskSeparate = NULL; 929 | PFNGLSTENCILOPPROC glad_glStencilOp = NULL; 930 | PFNGLSTENCILOPSEPARATEPROC glad_glStencilOpSeparate = NULL; 931 | PFNGLTEXBUFFERPROC glad_glTexBuffer = NULL; 932 | PFNGLTEXBUFFERRANGEPROC glad_glTexBufferRange = NULL; 933 | PFNGLTEXCOORD1DPROC glad_glTexCoord1d = NULL; 934 | PFNGLTEXCOORD1DVPROC glad_glTexCoord1dv = NULL; 935 | PFNGLTEXCOORD1FPROC glad_glTexCoord1f = NULL; 936 | PFNGLTEXCOORD1FVPROC glad_glTexCoord1fv = NULL; 937 | PFNGLTEXCOORD1IPROC glad_glTexCoord1i = NULL; 938 | PFNGLTEXCOORD1IVPROC glad_glTexCoord1iv = NULL; 939 | PFNGLTEXCOORD1SPROC glad_glTexCoord1s = NULL; 940 | PFNGLTEXCOORD1SVPROC glad_glTexCoord1sv = NULL; 941 | PFNGLTEXCOORD2DPROC glad_glTexCoord2d = NULL; 942 | PFNGLTEXCOORD2DVPROC glad_glTexCoord2dv = NULL; 943 | PFNGLTEXCOORD2FPROC glad_glTexCoord2f = NULL; 944 | PFNGLTEXCOORD2FVPROC glad_glTexCoord2fv = NULL; 945 | PFNGLTEXCOORD2IPROC glad_glTexCoord2i = NULL; 946 | PFNGLTEXCOORD2IVPROC glad_glTexCoord2iv = NULL; 947 | PFNGLTEXCOORD2SPROC glad_glTexCoord2s = NULL; 948 | PFNGLTEXCOORD2SVPROC glad_glTexCoord2sv = NULL; 949 | PFNGLTEXCOORD3DPROC glad_glTexCoord3d = NULL; 950 | PFNGLTEXCOORD3DVPROC glad_glTexCoord3dv = NULL; 951 | PFNGLTEXCOORD3FPROC glad_glTexCoord3f = NULL; 952 | PFNGLTEXCOORD3FVPROC glad_glTexCoord3fv = NULL; 953 | PFNGLTEXCOORD3IPROC glad_glTexCoord3i = NULL; 954 | PFNGLTEXCOORD3IVPROC glad_glTexCoord3iv = NULL; 955 | PFNGLTEXCOORD3SPROC glad_glTexCoord3s = NULL; 956 | PFNGLTEXCOORD3SVPROC glad_glTexCoord3sv = NULL; 957 | PFNGLTEXCOORD4DPROC glad_glTexCoord4d = NULL; 958 | PFNGLTEXCOORD4DVPROC glad_glTexCoord4dv = NULL; 959 | PFNGLTEXCOORD4FPROC glad_glTexCoord4f = NULL; 960 | PFNGLTEXCOORD4FVPROC glad_glTexCoord4fv = NULL; 961 | PFNGLTEXCOORD4IPROC glad_glTexCoord4i = NULL; 962 | PFNGLTEXCOORD4IVPROC glad_glTexCoord4iv = NULL; 963 | PFNGLTEXCOORD4SPROC glad_glTexCoord4s = NULL; 964 | PFNGLTEXCOORD4SVPROC glad_glTexCoord4sv = NULL; 965 | PFNGLTEXCOORDP1UIPROC glad_glTexCoordP1ui = NULL; 966 | PFNGLTEXCOORDP1UIVPROC glad_glTexCoordP1uiv = NULL; 967 | PFNGLTEXCOORDP2UIPROC glad_glTexCoordP2ui = NULL; 968 | PFNGLTEXCOORDP2UIVPROC glad_glTexCoordP2uiv = NULL; 969 | PFNGLTEXCOORDP3UIPROC glad_glTexCoordP3ui = NULL; 970 | PFNGLTEXCOORDP3UIVPROC glad_glTexCoordP3uiv = NULL; 971 | PFNGLTEXCOORDP4UIPROC glad_glTexCoordP4ui = NULL; 972 | PFNGLTEXCOORDP4UIVPROC glad_glTexCoordP4uiv = NULL; 973 | PFNGLTEXCOORDPOINTERPROC glad_glTexCoordPointer = NULL; 974 | PFNGLTEXENVFPROC glad_glTexEnvf = NULL; 975 | PFNGLTEXENVFVPROC glad_glTexEnvfv = NULL; 976 | PFNGLTEXENVIPROC glad_glTexEnvi = NULL; 977 | PFNGLTEXENVIVPROC glad_glTexEnviv = NULL; 978 | PFNGLTEXGENDPROC glad_glTexGend = NULL; 979 | PFNGLTEXGENDVPROC glad_glTexGendv = NULL; 980 | PFNGLTEXGENFPROC glad_glTexGenf = NULL; 981 | PFNGLTEXGENFVPROC glad_glTexGenfv = NULL; 982 | PFNGLTEXGENIPROC glad_glTexGeni = NULL; 983 | PFNGLTEXGENIVPROC glad_glTexGeniv = NULL; 984 | PFNGLTEXIMAGE1DPROC glad_glTexImage1D = NULL; 985 | PFNGLTEXIMAGE2DPROC glad_glTexImage2D = NULL; 986 | PFNGLTEXIMAGE2DMULTISAMPLEPROC glad_glTexImage2DMultisample = NULL; 987 | PFNGLTEXIMAGE3DPROC glad_glTexImage3D = NULL; 988 | PFNGLTEXIMAGE3DMULTISAMPLEPROC glad_glTexImage3DMultisample = NULL; 989 | PFNGLTEXPARAMETERIIVPROC glad_glTexParameterIiv = NULL; 990 | PFNGLTEXPARAMETERIUIVPROC glad_glTexParameterIuiv = NULL; 991 | PFNGLTEXPARAMETERFPROC glad_glTexParameterf = NULL; 992 | PFNGLTEXPARAMETERFVPROC glad_glTexParameterfv = NULL; 993 | PFNGLTEXPARAMETERIPROC glad_glTexParameteri = NULL; 994 | PFNGLTEXPARAMETERIVPROC glad_glTexParameteriv = NULL; 995 | PFNGLTEXSTORAGE1DPROC glad_glTexStorage1D = NULL; 996 | PFNGLTEXSTORAGE2DPROC glad_glTexStorage2D = NULL; 997 | PFNGLTEXSTORAGE2DMULTISAMPLEPROC glad_glTexStorage2DMultisample = NULL; 998 | PFNGLTEXSTORAGE3DPROC glad_glTexStorage3D = NULL; 999 | PFNGLTEXSTORAGE3DMULTISAMPLEPROC glad_glTexStorage3DMultisample = NULL; 1000 | PFNGLTEXSUBIMAGE1DPROC glad_glTexSubImage1D = NULL; 1001 | PFNGLTEXSUBIMAGE2DPROC glad_glTexSubImage2D = NULL; 1002 | PFNGLTEXSUBIMAGE3DPROC glad_glTexSubImage3D = NULL; 1003 | PFNGLTEXTUREVIEWPROC glad_glTextureView = NULL; 1004 | PFNGLTRANSFORMFEEDBACKVARYINGSPROC glad_glTransformFeedbackVaryings = NULL; 1005 | PFNGLTRANSLATEDPROC glad_glTranslated = NULL; 1006 | PFNGLTRANSLATEFPROC glad_glTranslatef = NULL; 1007 | PFNGLUNIFORM1DPROC glad_glUniform1d = NULL; 1008 | PFNGLUNIFORM1DVPROC glad_glUniform1dv = NULL; 1009 | PFNGLUNIFORM1FPROC glad_glUniform1f = NULL; 1010 | PFNGLUNIFORM1FVPROC glad_glUniform1fv = NULL; 1011 | PFNGLUNIFORM1IPROC glad_glUniform1i = NULL; 1012 | PFNGLUNIFORM1IVPROC glad_glUniform1iv = NULL; 1013 | PFNGLUNIFORM1UIPROC glad_glUniform1ui = NULL; 1014 | PFNGLUNIFORM1UIVPROC glad_glUniform1uiv = NULL; 1015 | PFNGLUNIFORM2DPROC glad_glUniform2d = NULL; 1016 | PFNGLUNIFORM2DVPROC glad_glUniform2dv = NULL; 1017 | PFNGLUNIFORM2FPROC glad_glUniform2f = NULL; 1018 | PFNGLUNIFORM2FVPROC glad_glUniform2fv = NULL; 1019 | PFNGLUNIFORM2IPROC glad_glUniform2i = NULL; 1020 | PFNGLUNIFORM2IVPROC glad_glUniform2iv = NULL; 1021 | PFNGLUNIFORM2UIPROC glad_glUniform2ui = NULL; 1022 | PFNGLUNIFORM2UIVPROC glad_glUniform2uiv = NULL; 1023 | PFNGLUNIFORM3DPROC glad_glUniform3d = NULL; 1024 | PFNGLUNIFORM3DVPROC glad_glUniform3dv = NULL; 1025 | PFNGLUNIFORM3FPROC glad_glUniform3f = NULL; 1026 | PFNGLUNIFORM3FVPROC glad_glUniform3fv = NULL; 1027 | PFNGLUNIFORM3IPROC glad_glUniform3i = NULL; 1028 | PFNGLUNIFORM3IVPROC glad_glUniform3iv = NULL; 1029 | PFNGLUNIFORM3UIPROC glad_glUniform3ui = NULL; 1030 | PFNGLUNIFORM3UIVPROC glad_glUniform3uiv = NULL; 1031 | PFNGLUNIFORM4DPROC glad_glUniform4d = NULL; 1032 | PFNGLUNIFORM4DVPROC glad_glUniform4dv = NULL; 1033 | PFNGLUNIFORM4FPROC glad_glUniform4f = NULL; 1034 | PFNGLUNIFORM4FVPROC glad_glUniform4fv = NULL; 1035 | PFNGLUNIFORM4IPROC glad_glUniform4i = NULL; 1036 | PFNGLUNIFORM4IVPROC glad_glUniform4iv = NULL; 1037 | PFNGLUNIFORM4UIPROC glad_glUniform4ui = NULL; 1038 | PFNGLUNIFORM4UIVPROC glad_glUniform4uiv = NULL; 1039 | PFNGLUNIFORMBLOCKBINDINGPROC glad_glUniformBlockBinding = NULL; 1040 | PFNGLUNIFORMMATRIX2DVPROC glad_glUniformMatrix2dv = NULL; 1041 | PFNGLUNIFORMMATRIX2FVPROC glad_glUniformMatrix2fv = NULL; 1042 | PFNGLUNIFORMMATRIX2X3DVPROC glad_glUniformMatrix2x3dv = NULL; 1043 | PFNGLUNIFORMMATRIX2X3FVPROC glad_glUniformMatrix2x3fv = NULL; 1044 | PFNGLUNIFORMMATRIX2X4DVPROC glad_glUniformMatrix2x4dv = NULL; 1045 | PFNGLUNIFORMMATRIX2X4FVPROC glad_glUniformMatrix2x4fv = NULL; 1046 | PFNGLUNIFORMMATRIX3DVPROC glad_glUniformMatrix3dv = NULL; 1047 | PFNGLUNIFORMMATRIX3FVPROC glad_glUniformMatrix3fv = NULL; 1048 | PFNGLUNIFORMMATRIX3X2DVPROC glad_glUniformMatrix3x2dv = NULL; 1049 | PFNGLUNIFORMMATRIX3X2FVPROC glad_glUniformMatrix3x2fv = NULL; 1050 | PFNGLUNIFORMMATRIX3X4DVPROC glad_glUniformMatrix3x4dv = NULL; 1051 | PFNGLUNIFORMMATRIX3X4FVPROC glad_glUniformMatrix3x4fv = NULL; 1052 | PFNGLUNIFORMMATRIX4DVPROC glad_glUniformMatrix4dv = NULL; 1053 | PFNGLUNIFORMMATRIX4FVPROC glad_glUniformMatrix4fv = NULL; 1054 | PFNGLUNIFORMMATRIX4X2DVPROC glad_glUniformMatrix4x2dv = NULL; 1055 | PFNGLUNIFORMMATRIX4X2FVPROC glad_glUniformMatrix4x2fv = NULL; 1056 | PFNGLUNIFORMMATRIX4X3DVPROC glad_glUniformMatrix4x3dv = NULL; 1057 | PFNGLUNIFORMMATRIX4X3FVPROC glad_glUniformMatrix4x3fv = NULL; 1058 | PFNGLUNIFORMSUBROUTINESUIVPROC glad_glUniformSubroutinesuiv = NULL; 1059 | PFNGLUNMAPBUFFERPROC glad_glUnmapBuffer = NULL; 1060 | PFNGLUSEPROGRAMPROC glad_glUseProgram = NULL; 1061 | PFNGLUSEPROGRAMSTAGESPROC glad_glUseProgramStages = NULL; 1062 | PFNGLVALIDATEPROGRAMPROC glad_glValidateProgram = NULL; 1063 | PFNGLVALIDATEPROGRAMPIPELINEPROC glad_glValidateProgramPipeline = NULL; 1064 | PFNGLVERTEX2DPROC glad_glVertex2d = NULL; 1065 | PFNGLVERTEX2DVPROC glad_glVertex2dv = NULL; 1066 | PFNGLVERTEX2FPROC glad_glVertex2f = NULL; 1067 | PFNGLVERTEX2FVPROC glad_glVertex2fv = NULL; 1068 | PFNGLVERTEX2IPROC glad_glVertex2i = NULL; 1069 | PFNGLVERTEX2IVPROC glad_glVertex2iv = NULL; 1070 | PFNGLVERTEX2SPROC glad_glVertex2s = NULL; 1071 | PFNGLVERTEX2SVPROC glad_glVertex2sv = NULL; 1072 | PFNGLVERTEX3DPROC glad_glVertex3d = NULL; 1073 | PFNGLVERTEX3DVPROC glad_glVertex3dv = NULL; 1074 | PFNGLVERTEX3FPROC glad_glVertex3f = NULL; 1075 | PFNGLVERTEX3FVPROC glad_glVertex3fv = NULL; 1076 | PFNGLVERTEX3IPROC glad_glVertex3i = NULL; 1077 | PFNGLVERTEX3IVPROC glad_glVertex3iv = NULL; 1078 | PFNGLVERTEX3SPROC glad_glVertex3s = NULL; 1079 | PFNGLVERTEX3SVPROC glad_glVertex3sv = NULL; 1080 | PFNGLVERTEX4DPROC glad_glVertex4d = NULL; 1081 | PFNGLVERTEX4DVPROC glad_glVertex4dv = NULL; 1082 | PFNGLVERTEX4FPROC glad_glVertex4f = NULL; 1083 | PFNGLVERTEX4FVPROC glad_glVertex4fv = NULL; 1084 | PFNGLVERTEX4IPROC glad_glVertex4i = NULL; 1085 | PFNGLVERTEX4IVPROC glad_glVertex4iv = NULL; 1086 | PFNGLVERTEX4SPROC glad_glVertex4s = NULL; 1087 | PFNGLVERTEX4SVPROC glad_glVertex4sv = NULL; 1088 | PFNGLVERTEXATTRIB1DPROC glad_glVertexAttrib1d = NULL; 1089 | PFNGLVERTEXATTRIB1DVPROC glad_glVertexAttrib1dv = NULL; 1090 | PFNGLVERTEXATTRIB1FPROC glad_glVertexAttrib1f = NULL; 1091 | PFNGLVERTEXATTRIB1FVPROC glad_glVertexAttrib1fv = NULL; 1092 | PFNGLVERTEXATTRIB1SPROC glad_glVertexAttrib1s = NULL; 1093 | PFNGLVERTEXATTRIB1SVPROC glad_glVertexAttrib1sv = NULL; 1094 | PFNGLVERTEXATTRIB2DPROC glad_glVertexAttrib2d = NULL; 1095 | PFNGLVERTEXATTRIB2DVPROC glad_glVertexAttrib2dv = NULL; 1096 | PFNGLVERTEXATTRIB2FPROC glad_glVertexAttrib2f = NULL; 1097 | PFNGLVERTEXATTRIB2FVPROC glad_glVertexAttrib2fv = NULL; 1098 | PFNGLVERTEXATTRIB2SPROC glad_glVertexAttrib2s = NULL; 1099 | PFNGLVERTEXATTRIB2SVPROC glad_glVertexAttrib2sv = NULL; 1100 | PFNGLVERTEXATTRIB3DPROC glad_glVertexAttrib3d = NULL; 1101 | PFNGLVERTEXATTRIB3DVPROC glad_glVertexAttrib3dv = NULL; 1102 | PFNGLVERTEXATTRIB3FPROC glad_glVertexAttrib3f = NULL; 1103 | PFNGLVERTEXATTRIB3FVPROC glad_glVertexAttrib3fv = NULL; 1104 | PFNGLVERTEXATTRIB3SPROC glad_glVertexAttrib3s = NULL; 1105 | PFNGLVERTEXATTRIB3SVPROC glad_glVertexAttrib3sv = NULL; 1106 | PFNGLVERTEXATTRIB4NBVPROC glad_glVertexAttrib4Nbv = NULL; 1107 | PFNGLVERTEXATTRIB4NIVPROC glad_glVertexAttrib4Niv = NULL; 1108 | PFNGLVERTEXATTRIB4NSVPROC glad_glVertexAttrib4Nsv = NULL; 1109 | PFNGLVERTEXATTRIB4NUBPROC glad_glVertexAttrib4Nub = NULL; 1110 | PFNGLVERTEXATTRIB4NUBVPROC glad_glVertexAttrib4Nubv = NULL; 1111 | PFNGLVERTEXATTRIB4NUIVPROC glad_glVertexAttrib4Nuiv = NULL; 1112 | PFNGLVERTEXATTRIB4NUSVPROC glad_glVertexAttrib4Nusv = NULL; 1113 | PFNGLVERTEXATTRIB4BVPROC glad_glVertexAttrib4bv = NULL; 1114 | PFNGLVERTEXATTRIB4DPROC glad_glVertexAttrib4d = NULL; 1115 | PFNGLVERTEXATTRIB4DVPROC glad_glVertexAttrib4dv = NULL; 1116 | PFNGLVERTEXATTRIB4FPROC glad_glVertexAttrib4f = NULL; 1117 | PFNGLVERTEXATTRIB4FVPROC glad_glVertexAttrib4fv = NULL; 1118 | PFNGLVERTEXATTRIB4IVPROC glad_glVertexAttrib4iv = NULL; 1119 | PFNGLVERTEXATTRIB4SPROC glad_glVertexAttrib4s = NULL; 1120 | PFNGLVERTEXATTRIB4SVPROC glad_glVertexAttrib4sv = NULL; 1121 | PFNGLVERTEXATTRIB4UBVPROC glad_glVertexAttrib4ubv = NULL; 1122 | PFNGLVERTEXATTRIB4UIVPROC glad_glVertexAttrib4uiv = NULL; 1123 | PFNGLVERTEXATTRIB4USVPROC glad_glVertexAttrib4usv = NULL; 1124 | PFNGLVERTEXATTRIBBINDINGPROC glad_glVertexAttribBinding = NULL; 1125 | PFNGLVERTEXATTRIBDIVISORPROC glad_glVertexAttribDivisor = NULL; 1126 | PFNGLVERTEXATTRIBFORMATPROC glad_glVertexAttribFormat = NULL; 1127 | PFNGLVERTEXATTRIBI1IPROC glad_glVertexAttribI1i = NULL; 1128 | PFNGLVERTEXATTRIBI1IVPROC glad_glVertexAttribI1iv = NULL; 1129 | PFNGLVERTEXATTRIBI1UIPROC glad_glVertexAttribI1ui = NULL; 1130 | PFNGLVERTEXATTRIBI1UIVPROC glad_glVertexAttribI1uiv = NULL; 1131 | PFNGLVERTEXATTRIBI2IPROC glad_glVertexAttribI2i = NULL; 1132 | PFNGLVERTEXATTRIBI2IVPROC glad_glVertexAttribI2iv = NULL; 1133 | PFNGLVERTEXATTRIBI2UIPROC glad_glVertexAttribI2ui = NULL; 1134 | PFNGLVERTEXATTRIBI2UIVPROC glad_glVertexAttribI2uiv = NULL; 1135 | PFNGLVERTEXATTRIBI3IPROC glad_glVertexAttribI3i = NULL; 1136 | PFNGLVERTEXATTRIBI3IVPROC glad_glVertexAttribI3iv = NULL; 1137 | PFNGLVERTEXATTRIBI3UIPROC glad_glVertexAttribI3ui = NULL; 1138 | PFNGLVERTEXATTRIBI3UIVPROC glad_glVertexAttribI3uiv = NULL; 1139 | PFNGLVERTEXATTRIBI4BVPROC glad_glVertexAttribI4bv = NULL; 1140 | PFNGLVERTEXATTRIBI4IPROC glad_glVertexAttribI4i = NULL; 1141 | PFNGLVERTEXATTRIBI4IVPROC glad_glVertexAttribI4iv = NULL; 1142 | PFNGLVERTEXATTRIBI4SVPROC glad_glVertexAttribI4sv = NULL; 1143 | PFNGLVERTEXATTRIBI4UBVPROC glad_glVertexAttribI4ubv = NULL; 1144 | PFNGLVERTEXATTRIBI4UIPROC glad_glVertexAttribI4ui = NULL; 1145 | PFNGLVERTEXATTRIBI4UIVPROC glad_glVertexAttribI4uiv = NULL; 1146 | PFNGLVERTEXATTRIBI4USVPROC glad_glVertexAttribI4usv = NULL; 1147 | PFNGLVERTEXATTRIBIFORMATPROC glad_glVertexAttribIFormat = NULL; 1148 | PFNGLVERTEXATTRIBIPOINTERPROC glad_glVertexAttribIPointer = NULL; 1149 | PFNGLVERTEXATTRIBL1DPROC glad_glVertexAttribL1d = NULL; 1150 | PFNGLVERTEXATTRIBL1DVPROC glad_glVertexAttribL1dv = NULL; 1151 | PFNGLVERTEXATTRIBL2DPROC glad_glVertexAttribL2d = NULL; 1152 | PFNGLVERTEXATTRIBL2DVPROC glad_glVertexAttribL2dv = NULL; 1153 | PFNGLVERTEXATTRIBL3DPROC glad_glVertexAttribL3d = NULL; 1154 | PFNGLVERTEXATTRIBL3DVPROC glad_glVertexAttribL3dv = NULL; 1155 | PFNGLVERTEXATTRIBL4DPROC glad_glVertexAttribL4d = NULL; 1156 | PFNGLVERTEXATTRIBL4DVPROC glad_glVertexAttribL4dv = NULL; 1157 | PFNGLVERTEXATTRIBLFORMATPROC glad_glVertexAttribLFormat = NULL; 1158 | PFNGLVERTEXATTRIBLPOINTERPROC glad_glVertexAttribLPointer = NULL; 1159 | PFNGLVERTEXATTRIBP1UIPROC glad_glVertexAttribP1ui = NULL; 1160 | PFNGLVERTEXATTRIBP1UIVPROC glad_glVertexAttribP1uiv = NULL; 1161 | PFNGLVERTEXATTRIBP2UIPROC glad_glVertexAttribP2ui = NULL; 1162 | PFNGLVERTEXATTRIBP2UIVPROC glad_glVertexAttribP2uiv = NULL; 1163 | PFNGLVERTEXATTRIBP3UIPROC glad_glVertexAttribP3ui = NULL; 1164 | PFNGLVERTEXATTRIBP3UIVPROC glad_glVertexAttribP3uiv = NULL; 1165 | PFNGLVERTEXATTRIBP4UIPROC glad_glVertexAttribP4ui = NULL; 1166 | PFNGLVERTEXATTRIBP4UIVPROC glad_glVertexAttribP4uiv = NULL; 1167 | PFNGLVERTEXATTRIBPOINTERPROC glad_glVertexAttribPointer = NULL; 1168 | PFNGLVERTEXBINDINGDIVISORPROC glad_glVertexBindingDivisor = NULL; 1169 | PFNGLVERTEXP2UIPROC glad_glVertexP2ui = NULL; 1170 | PFNGLVERTEXP2UIVPROC glad_glVertexP2uiv = NULL; 1171 | PFNGLVERTEXP3UIPROC glad_glVertexP3ui = NULL; 1172 | PFNGLVERTEXP3UIVPROC glad_glVertexP3uiv = NULL; 1173 | PFNGLVERTEXP4UIPROC glad_glVertexP4ui = NULL; 1174 | PFNGLVERTEXP4UIVPROC glad_glVertexP4uiv = NULL; 1175 | PFNGLVERTEXPOINTERPROC glad_glVertexPointer = NULL; 1176 | PFNGLVIEWPORTPROC glad_glViewport = NULL; 1177 | PFNGLVIEWPORTARRAYVPROC glad_glViewportArrayv = NULL; 1178 | PFNGLVIEWPORTINDEXEDFPROC glad_glViewportIndexedf = NULL; 1179 | PFNGLVIEWPORTINDEXEDFVPROC glad_glViewportIndexedfv = NULL; 1180 | PFNGLWAITSYNCPROC glad_glWaitSync = NULL; 1181 | PFNGLWINDOWPOS2DPROC glad_glWindowPos2d = NULL; 1182 | PFNGLWINDOWPOS2DVPROC glad_glWindowPos2dv = NULL; 1183 | PFNGLWINDOWPOS2FPROC glad_glWindowPos2f = NULL; 1184 | PFNGLWINDOWPOS2FVPROC glad_glWindowPos2fv = NULL; 1185 | PFNGLWINDOWPOS2IPROC glad_glWindowPos2i = NULL; 1186 | PFNGLWINDOWPOS2IVPROC glad_glWindowPos2iv = NULL; 1187 | PFNGLWINDOWPOS2SPROC glad_glWindowPos2s = NULL; 1188 | PFNGLWINDOWPOS2SVPROC glad_glWindowPos2sv = NULL; 1189 | PFNGLWINDOWPOS3DPROC glad_glWindowPos3d = NULL; 1190 | PFNGLWINDOWPOS3DVPROC glad_glWindowPos3dv = NULL; 1191 | PFNGLWINDOWPOS3FPROC glad_glWindowPos3f = NULL; 1192 | PFNGLWINDOWPOS3FVPROC glad_glWindowPos3fv = NULL; 1193 | PFNGLWINDOWPOS3IPROC glad_glWindowPos3i = NULL; 1194 | PFNGLWINDOWPOS3IVPROC glad_glWindowPos3iv = NULL; 1195 | PFNGLWINDOWPOS3SPROC glad_glWindowPos3s = NULL; 1196 | PFNGLWINDOWPOS3SVPROC glad_glWindowPos3sv = NULL; 1197 | static void load_GL_VERSION_1_0(GLADloadproc load) { 1198 | if(!GLAD_GL_VERSION_1_0) return; 1199 | glad_glCullFace = (PFNGLCULLFACEPROC)load("glCullFace"); 1200 | glad_glFrontFace = (PFNGLFRONTFACEPROC)load("glFrontFace"); 1201 | glad_glHint = (PFNGLHINTPROC)load("glHint"); 1202 | glad_glLineWidth = (PFNGLLINEWIDTHPROC)load("glLineWidth"); 1203 | glad_glPointSize = (PFNGLPOINTSIZEPROC)load("glPointSize"); 1204 | glad_glPolygonMode = (PFNGLPOLYGONMODEPROC)load("glPolygonMode"); 1205 | glad_glScissor = (PFNGLSCISSORPROC)load("glScissor"); 1206 | glad_glTexParameterf = (PFNGLTEXPARAMETERFPROC)load("glTexParameterf"); 1207 | glad_glTexParameterfv = (PFNGLTEXPARAMETERFVPROC)load("glTexParameterfv"); 1208 | glad_glTexParameteri = (PFNGLTEXPARAMETERIPROC)load("glTexParameteri"); 1209 | glad_glTexParameteriv = (PFNGLTEXPARAMETERIVPROC)load("glTexParameteriv"); 1210 | glad_glTexImage1D = (PFNGLTEXIMAGE1DPROC)load("glTexImage1D"); 1211 | glad_glTexImage2D = (PFNGLTEXIMAGE2DPROC)load("glTexImage2D"); 1212 | glad_glDrawBuffer = (PFNGLDRAWBUFFERPROC)load("glDrawBuffer"); 1213 | glad_glClear = (PFNGLCLEARPROC)load("glClear"); 1214 | glad_glClearColor = (PFNGLCLEARCOLORPROC)load("glClearColor"); 1215 | glad_glClearStencil = (PFNGLCLEARSTENCILPROC)load("glClearStencil"); 1216 | glad_glClearDepth = (PFNGLCLEARDEPTHPROC)load("glClearDepth"); 1217 | glad_glStencilMask = (PFNGLSTENCILMASKPROC)load("glStencilMask"); 1218 | glad_glColorMask = (PFNGLCOLORMASKPROC)load("glColorMask"); 1219 | glad_glDepthMask = (PFNGLDEPTHMASKPROC)load("glDepthMask"); 1220 | glad_glDisable = (PFNGLDISABLEPROC)load("glDisable"); 1221 | glad_glEnable = (PFNGLENABLEPROC)load("glEnable"); 1222 | glad_glFinish = (PFNGLFINISHPROC)load("glFinish"); 1223 | glad_glFlush = (PFNGLFLUSHPROC)load("glFlush"); 1224 | glad_glBlendFunc = (PFNGLBLENDFUNCPROC)load("glBlendFunc"); 1225 | glad_glLogicOp = (PFNGLLOGICOPPROC)load("glLogicOp"); 1226 | glad_glStencilFunc = (PFNGLSTENCILFUNCPROC)load("glStencilFunc"); 1227 | glad_glStencilOp = (PFNGLSTENCILOPPROC)load("glStencilOp"); 1228 | glad_glDepthFunc = (PFNGLDEPTHFUNCPROC)load("glDepthFunc"); 1229 | glad_glPixelStoref = (PFNGLPIXELSTOREFPROC)load("glPixelStoref"); 1230 | glad_glPixelStorei = (PFNGLPIXELSTOREIPROC)load("glPixelStorei"); 1231 | glad_glReadBuffer = (PFNGLREADBUFFERPROC)load("glReadBuffer"); 1232 | glad_glReadPixels = (PFNGLREADPIXELSPROC)load("glReadPixels"); 1233 | glad_glGetBooleanv = (PFNGLGETBOOLEANVPROC)load("glGetBooleanv"); 1234 | glad_glGetDoublev = (PFNGLGETDOUBLEVPROC)load("glGetDoublev"); 1235 | glad_glGetError = (PFNGLGETERRORPROC)load("glGetError"); 1236 | glad_glGetFloatv = (PFNGLGETFLOATVPROC)load("glGetFloatv"); 1237 | glad_glGetIntegerv = (PFNGLGETINTEGERVPROC)load("glGetIntegerv"); 1238 | glad_glGetString = (PFNGLGETSTRINGPROC)load("glGetString"); 1239 | glad_glGetTexImage = (PFNGLGETTEXIMAGEPROC)load("glGetTexImage"); 1240 | glad_glGetTexParameterfv = (PFNGLGETTEXPARAMETERFVPROC)load("glGetTexParameterfv"); 1241 | glad_glGetTexParameteriv = (PFNGLGETTEXPARAMETERIVPROC)load("glGetTexParameteriv"); 1242 | glad_glGetTexLevelParameterfv = (PFNGLGETTEXLEVELPARAMETERFVPROC)load("glGetTexLevelParameterfv"); 1243 | glad_glGetTexLevelParameteriv = (PFNGLGETTEXLEVELPARAMETERIVPROC)load("glGetTexLevelParameteriv"); 1244 | glad_glIsEnabled = (PFNGLISENABLEDPROC)load("glIsEnabled"); 1245 | glad_glDepthRange = (PFNGLDEPTHRANGEPROC)load("glDepthRange"); 1246 | glad_glViewport = (PFNGLVIEWPORTPROC)load("glViewport"); 1247 | glad_glNewList = (PFNGLNEWLISTPROC)load("glNewList"); 1248 | glad_glEndList = (PFNGLENDLISTPROC)load("glEndList"); 1249 | glad_glCallList = (PFNGLCALLLISTPROC)load("glCallList"); 1250 | glad_glCallLists = (PFNGLCALLLISTSPROC)load("glCallLists"); 1251 | glad_glDeleteLists = (PFNGLDELETELISTSPROC)load("glDeleteLists"); 1252 | glad_glGenLists = (PFNGLGENLISTSPROC)load("glGenLists"); 1253 | glad_glListBase = (PFNGLLISTBASEPROC)load("glListBase"); 1254 | glad_glBegin = (PFNGLBEGINPROC)load("glBegin"); 1255 | glad_glBitmap = (PFNGLBITMAPPROC)load("glBitmap"); 1256 | glad_glColor3b = (PFNGLCOLOR3BPROC)load("glColor3b"); 1257 | glad_glColor3bv = (PFNGLCOLOR3BVPROC)load("glColor3bv"); 1258 | glad_glColor3d = (PFNGLCOLOR3DPROC)load("glColor3d"); 1259 | glad_glColor3dv = (PFNGLCOLOR3DVPROC)load("glColor3dv"); 1260 | glad_glColor3f = (PFNGLCOLOR3FPROC)load("glColor3f"); 1261 | glad_glColor3fv = (PFNGLCOLOR3FVPROC)load("glColor3fv"); 1262 | glad_glColor3i = (PFNGLCOLOR3IPROC)load("glColor3i"); 1263 | glad_glColor3iv = (PFNGLCOLOR3IVPROC)load("glColor3iv"); 1264 | glad_glColor3s = (PFNGLCOLOR3SPROC)load("glColor3s"); 1265 | glad_glColor3sv = (PFNGLCOLOR3SVPROC)load("glColor3sv"); 1266 | glad_glColor3ub = (PFNGLCOLOR3UBPROC)load("glColor3ub"); 1267 | glad_glColor3ubv = (PFNGLCOLOR3UBVPROC)load("glColor3ubv"); 1268 | glad_glColor3ui = (PFNGLCOLOR3UIPROC)load("glColor3ui"); 1269 | glad_glColor3uiv = (PFNGLCOLOR3UIVPROC)load("glColor3uiv"); 1270 | glad_glColor3us = (PFNGLCOLOR3USPROC)load("glColor3us"); 1271 | glad_glColor3usv = (PFNGLCOLOR3USVPROC)load("glColor3usv"); 1272 | glad_glColor4b = (PFNGLCOLOR4BPROC)load("glColor4b"); 1273 | glad_glColor4bv = (PFNGLCOLOR4BVPROC)load("glColor4bv"); 1274 | glad_glColor4d = (PFNGLCOLOR4DPROC)load("glColor4d"); 1275 | glad_glColor4dv = (PFNGLCOLOR4DVPROC)load("glColor4dv"); 1276 | glad_glColor4f = (PFNGLCOLOR4FPROC)load("glColor4f"); 1277 | glad_glColor4fv = (PFNGLCOLOR4FVPROC)load("glColor4fv"); 1278 | glad_glColor4i = (PFNGLCOLOR4IPROC)load("glColor4i"); 1279 | glad_glColor4iv = (PFNGLCOLOR4IVPROC)load("glColor4iv"); 1280 | glad_glColor4s = (PFNGLCOLOR4SPROC)load("glColor4s"); 1281 | glad_glColor4sv = (PFNGLCOLOR4SVPROC)load("glColor4sv"); 1282 | glad_glColor4ub = (PFNGLCOLOR4UBPROC)load("glColor4ub"); 1283 | glad_glColor4ubv = (PFNGLCOLOR4UBVPROC)load("glColor4ubv"); 1284 | glad_glColor4ui = (PFNGLCOLOR4UIPROC)load("glColor4ui"); 1285 | glad_glColor4uiv = (PFNGLCOLOR4UIVPROC)load("glColor4uiv"); 1286 | glad_glColor4us = (PFNGLCOLOR4USPROC)load("glColor4us"); 1287 | glad_glColor4usv = (PFNGLCOLOR4USVPROC)load("glColor4usv"); 1288 | glad_glEdgeFlag = (PFNGLEDGEFLAGPROC)load("glEdgeFlag"); 1289 | glad_glEdgeFlagv = (PFNGLEDGEFLAGVPROC)load("glEdgeFlagv"); 1290 | glad_glEnd = (PFNGLENDPROC)load("glEnd"); 1291 | glad_glIndexd = (PFNGLINDEXDPROC)load("glIndexd"); 1292 | glad_glIndexdv = (PFNGLINDEXDVPROC)load("glIndexdv"); 1293 | glad_glIndexf = (PFNGLINDEXFPROC)load("glIndexf"); 1294 | glad_glIndexfv = (PFNGLINDEXFVPROC)load("glIndexfv"); 1295 | glad_glIndexi = (PFNGLINDEXIPROC)load("glIndexi"); 1296 | glad_glIndexiv = (PFNGLINDEXIVPROC)load("glIndexiv"); 1297 | glad_glIndexs = (PFNGLINDEXSPROC)load("glIndexs"); 1298 | glad_glIndexsv = (PFNGLINDEXSVPROC)load("glIndexsv"); 1299 | glad_glNormal3b = (PFNGLNORMAL3BPROC)load("glNormal3b"); 1300 | glad_glNormal3bv = (PFNGLNORMAL3BVPROC)load("glNormal3bv"); 1301 | glad_glNormal3d = (PFNGLNORMAL3DPROC)load("glNormal3d"); 1302 | glad_glNormal3dv = (PFNGLNORMAL3DVPROC)load("glNormal3dv"); 1303 | glad_glNormal3f = (PFNGLNORMAL3FPROC)load("glNormal3f"); 1304 | glad_glNormal3fv = (PFNGLNORMAL3FVPROC)load("glNormal3fv"); 1305 | glad_glNormal3i = (PFNGLNORMAL3IPROC)load("glNormal3i"); 1306 | glad_glNormal3iv = (PFNGLNORMAL3IVPROC)load("glNormal3iv"); 1307 | glad_glNormal3s = (PFNGLNORMAL3SPROC)load("glNormal3s"); 1308 | glad_glNormal3sv = (PFNGLNORMAL3SVPROC)load("glNormal3sv"); 1309 | glad_glRasterPos2d = (PFNGLRASTERPOS2DPROC)load("glRasterPos2d"); 1310 | glad_glRasterPos2dv = (PFNGLRASTERPOS2DVPROC)load("glRasterPos2dv"); 1311 | glad_glRasterPos2f = (PFNGLRASTERPOS2FPROC)load("glRasterPos2f"); 1312 | glad_glRasterPos2fv = (PFNGLRASTERPOS2FVPROC)load("glRasterPos2fv"); 1313 | glad_glRasterPos2i = (PFNGLRASTERPOS2IPROC)load("glRasterPos2i"); 1314 | glad_glRasterPos2iv = (PFNGLRASTERPOS2IVPROC)load("glRasterPos2iv"); 1315 | glad_glRasterPos2s = (PFNGLRASTERPOS2SPROC)load("glRasterPos2s"); 1316 | glad_glRasterPos2sv = (PFNGLRASTERPOS2SVPROC)load("glRasterPos2sv"); 1317 | glad_glRasterPos3d = (PFNGLRASTERPOS3DPROC)load("glRasterPos3d"); 1318 | glad_glRasterPos3dv = (PFNGLRASTERPOS3DVPROC)load("glRasterPos3dv"); 1319 | glad_glRasterPos3f = (PFNGLRASTERPOS3FPROC)load("glRasterPos3f"); 1320 | glad_glRasterPos3fv = (PFNGLRASTERPOS3FVPROC)load("glRasterPos3fv"); 1321 | glad_glRasterPos3i = (PFNGLRASTERPOS3IPROC)load("glRasterPos3i"); 1322 | glad_glRasterPos3iv = (PFNGLRASTERPOS3IVPROC)load("glRasterPos3iv"); 1323 | glad_glRasterPos3s = (PFNGLRASTERPOS3SPROC)load("glRasterPos3s"); 1324 | glad_glRasterPos3sv = (PFNGLRASTERPOS3SVPROC)load("glRasterPos3sv"); 1325 | glad_glRasterPos4d = (PFNGLRASTERPOS4DPROC)load("glRasterPos4d"); 1326 | glad_glRasterPos4dv = (PFNGLRASTERPOS4DVPROC)load("glRasterPos4dv"); 1327 | glad_glRasterPos4f = (PFNGLRASTERPOS4FPROC)load("glRasterPos4f"); 1328 | glad_glRasterPos4fv = (PFNGLRASTERPOS4FVPROC)load("glRasterPos4fv"); 1329 | glad_glRasterPos4i = (PFNGLRASTERPOS4IPROC)load("glRasterPos4i"); 1330 | glad_glRasterPos4iv = (PFNGLRASTERPOS4IVPROC)load("glRasterPos4iv"); 1331 | glad_glRasterPos4s = (PFNGLRASTERPOS4SPROC)load("glRasterPos4s"); 1332 | glad_glRasterPos4sv = (PFNGLRASTERPOS4SVPROC)load("glRasterPos4sv"); 1333 | glad_glRectd = (PFNGLRECTDPROC)load("glRectd"); 1334 | glad_glRectdv = (PFNGLRECTDVPROC)load("glRectdv"); 1335 | glad_glRectf = (PFNGLRECTFPROC)load("glRectf"); 1336 | glad_glRectfv = (PFNGLRECTFVPROC)load("glRectfv"); 1337 | glad_glRecti = (PFNGLRECTIPROC)load("glRecti"); 1338 | glad_glRectiv = (PFNGLRECTIVPROC)load("glRectiv"); 1339 | glad_glRects = (PFNGLRECTSPROC)load("glRects"); 1340 | glad_glRectsv = (PFNGLRECTSVPROC)load("glRectsv"); 1341 | glad_glTexCoord1d = (PFNGLTEXCOORD1DPROC)load("glTexCoord1d"); 1342 | glad_glTexCoord1dv = (PFNGLTEXCOORD1DVPROC)load("glTexCoord1dv"); 1343 | glad_glTexCoord1f = (PFNGLTEXCOORD1FPROC)load("glTexCoord1f"); 1344 | glad_glTexCoord1fv = (PFNGLTEXCOORD1FVPROC)load("glTexCoord1fv"); 1345 | glad_glTexCoord1i = (PFNGLTEXCOORD1IPROC)load("glTexCoord1i"); 1346 | glad_glTexCoord1iv = (PFNGLTEXCOORD1IVPROC)load("glTexCoord1iv"); 1347 | glad_glTexCoord1s = (PFNGLTEXCOORD1SPROC)load("glTexCoord1s"); 1348 | glad_glTexCoord1sv = (PFNGLTEXCOORD1SVPROC)load("glTexCoord1sv"); 1349 | glad_glTexCoord2d = (PFNGLTEXCOORD2DPROC)load("glTexCoord2d"); 1350 | glad_glTexCoord2dv = (PFNGLTEXCOORD2DVPROC)load("glTexCoord2dv"); 1351 | glad_glTexCoord2f = (PFNGLTEXCOORD2FPROC)load("glTexCoord2f"); 1352 | glad_glTexCoord2fv = (PFNGLTEXCOORD2FVPROC)load("glTexCoord2fv"); 1353 | glad_glTexCoord2i = (PFNGLTEXCOORD2IPROC)load("glTexCoord2i"); 1354 | glad_glTexCoord2iv = (PFNGLTEXCOORD2IVPROC)load("glTexCoord2iv"); 1355 | glad_glTexCoord2s = (PFNGLTEXCOORD2SPROC)load("glTexCoord2s"); 1356 | glad_glTexCoord2sv = (PFNGLTEXCOORD2SVPROC)load("glTexCoord2sv"); 1357 | glad_glTexCoord3d = (PFNGLTEXCOORD3DPROC)load("glTexCoord3d"); 1358 | glad_glTexCoord3dv = (PFNGLTEXCOORD3DVPROC)load("glTexCoord3dv"); 1359 | glad_glTexCoord3f = (PFNGLTEXCOORD3FPROC)load("glTexCoord3f"); 1360 | glad_glTexCoord3fv = (PFNGLTEXCOORD3FVPROC)load("glTexCoord3fv"); 1361 | glad_glTexCoord3i = (PFNGLTEXCOORD3IPROC)load("glTexCoord3i"); 1362 | glad_glTexCoord3iv = (PFNGLTEXCOORD3IVPROC)load("glTexCoord3iv"); 1363 | glad_glTexCoord3s = (PFNGLTEXCOORD3SPROC)load("glTexCoord3s"); 1364 | glad_glTexCoord3sv = (PFNGLTEXCOORD3SVPROC)load("glTexCoord3sv"); 1365 | glad_glTexCoord4d = (PFNGLTEXCOORD4DPROC)load("glTexCoord4d"); 1366 | glad_glTexCoord4dv = (PFNGLTEXCOORD4DVPROC)load("glTexCoord4dv"); 1367 | glad_glTexCoord4f = (PFNGLTEXCOORD4FPROC)load("glTexCoord4f"); 1368 | glad_glTexCoord4fv = (PFNGLTEXCOORD4FVPROC)load("glTexCoord4fv"); 1369 | glad_glTexCoord4i = (PFNGLTEXCOORD4IPROC)load("glTexCoord4i"); 1370 | glad_glTexCoord4iv = (PFNGLTEXCOORD4IVPROC)load("glTexCoord4iv"); 1371 | glad_glTexCoord4s = (PFNGLTEXCOORD4SPROC)load("glTexCoord4s"); 1372 | glad_glTexCoord4sv = (PFNGLTEXCOORD4SVPROC)load("glTexCoord4sv"); 1373 | glad_glVertex2d = (PFNGLVERTEX2DPROC)load("glVertex2d"); 1374 | glad_glVertex2dv = (PFNGLVERTEX2DVPROC)load("glVertex2dv"); 1375 | glad_glVertex2f = (PFNGLVERTEX2FPROC)load("glVertex2f"); 1376 | glad_glVertex2fv = (PFNGLVERTEX2FVPROC)load("glVertex2fv"); 1377 | glad_glVertex2i = (PFNGLVERTEX2IPROC)load("glVertex2i"); 1378 | glad_glVertex2iv = (PFNGLVERTEX2IVPROC)load("glVertex2iv"); 1379 | glad_glVertex2s = (PFNGLVERTEX2SPROC)load("glVertex2s"); 1380 | glad_glVertex2sv = (PFNGLVERTEX2SVPROC)load("glVertex2sv"); 1381 | glad_glVertex3d = (PFNGLVERTEX3DPROC)load("glVertex3d"); 1382 | glad_glVertex3dv = (PFNGLVERTEX3DVPROC)load("glVertex3dv"); 1383 | glad_glVertex3f = (PFNGLVERTEX3FPROC)load("glVertex3f"); 1384 | glad_glVertex3fv = (PFNGLVERTEX3FVPROC)load("glVertex3fv"); 1385 | glad_glVertex3i = (PFNGLVERTEX3IPROC)load("glVertex3i"); 1386 | glad_glVertex3iv = (PFNGLVERTEX3IVPROC)load("glVertex3iv"); 1387 | glad_glVertex3s = (PFNGLVERTEX3SPROC)load("glVertex3s"); 1388 | glad_glVertex3sv = (PFNGLVERTEX3SVPROC)load("glVertex3sv"); 1389 | glad_glVertex4d = (PFNGLVERTEX4DPROC)load("glVertex4d"); 1390 | glad_glVertex4dv = (PFNGLVERTEX4DVPROC)load("glVertex4dv"); 1391 | glad_glVertex4f = (PFNGLVERTEX4FPROC)load("glVertex4f"); 1392 | glad_glVertex4fv = (PFNGLVERTEX4FVPROC)load("glVertex4fv"); 1393 | glad_glVertex4i = (PFNGLVERTEX4IPROC)load("glVertex4i"); 1394 | glad_glVertex4iv = (PFNGLVERTEX4IVPROC)load("glVertex4iv"); 1395 | glad_glVertex4s = (PFNGLVERTEX4SPROC)load("glVertex4s"); 1396 | glad_glVertex4sv = (PFNGLVERTEX4SVPROC)load("glVertex4sv"); 1397 | glad_glClipPlane = (PFNGLCLIPPLANEPROC)load("glClipPlane"); 1398 | glad_glColorMaterial = (PFNGLCOLORMATERIALPROC)load("glColorMaterial"); 1399 | glad_glFogf = (PFNGLFOGFPROC)load("glFogf"); 1400 | glad_glFogfv = (PFNGLFOGFVPROC)load("glFogfv"); 1401 | glad_glFogi = (PFNGLFOGIPROC)load("glFogi"); 1402 | glad_glFogiv = (PFNGLFOGIVPROC)load("glFogiv"); 1403 | glad_glLightf = (PFNGLLIGHTFPROC)load("glLightf"); 1404 | glad_glLightfv = (PFNGLLIGHTFVPROC)load("glLightfv"); 1405 | glad_glLighti = (PFNGLLIGHTIPROC)load("glLighti"); 1406 | glad_glLightiv = (PFNGLLIGHTIVPROC)load("glLightiv"); 1407 | glad_glLightModelf = (PFNGLLIGHTMODELFPROC)load("glLightModelf"); 1408 | glad_glLightModelfv = (PFNGLLIGHTMODELFVPROC)load("glLightModelfv"); 1409 | glad_glLightModeli = (PFNGLLIGHTMODELIPROC)load("glLightModeli"); 1410 | glad_glLightModeliv = (PFNGLLIGHTMODELIVPROC)load("glLightModeliv"); 1411 | glad_glLineStipple = (PFNGLLINESTIPPLEPROC)load("glLineStipple"); 1412 | glad_glMaterialf = (PFNGLMATERIALFPROC)load("glMaterialf"); 1413 | glad_glMaterialfv = (PFNGLMATERIALFVPROC)load("glMaterialfv"); 1414 | glad_glMateriali = (PFNGLMATERIALIPROC)load("glMateriali"); 1415 | glad_glMaterialiv = (PFNGLMATERIALIVPROC)load("glMaterialiv"); 1416 | glad_glPolygonStipple = (PFNGLPOLYGONSTIPPLEPROC)load("glPolygonStipple"); 1417 | glad_glShadeModel = (PFNGLSHADEMODELPROC)load("glShadeModel"); 1418 | glad_glTexEnvf = (PFNGLTEXENVFPROC)load("glTexEnvf"); 1419 | glad_glTexEnvfv = (PFNGLTEXENVFVPROC)load("glTexEnvfv"); 1420 | glad_glTexEnvi = (PFNGLTEXENVIPROC)load("glTexEnvi"); 1421 | glad_glTexEnviv = (PFNGLTEXENVIVPROC)load("glTexEnviv"); 1422 | glad_glTexGend = (PFNGLTEXGENDPROC)load("glTexGend"); 1423 | glad_glTexGendv = (PFNGLTEXGENDVPROC)load("glTexGendv"); 1424 | glad_glTexGenf = (PFNGLTEXGENFPROC)load("glTexGenf"); 1425 | glad_glTexGenfv = (PFNGLTEXGENFVPROC)load("glTexGenfv"); 1426 | glad_glTexGeni = (PFNGLTEXGENIPROC)load("glTexGeni"); 1427 | glad_glTexGeniv = (PFNGLTEXGENIVPROC)load("glTexGeniv"); 1428 | glad_glFeedbackBuffer = (PFNGLFEEDBACKBUFFERPROC)load("glFeedbackBuffer"); 1429 | glad_glSelectBuffer = (PFNGLSELECTBUFFERPROC)load("glSelectBuffer"); 1430 | glad_glRenderMode = (PFNGLRENDERMODEPROC)load("glRenderMode"); 1431 | glad_glInitNames = (PFNGLINITNAMESPROC)load("glInitNames"); 1432 | glad_glLoadName = (PFNGLLOADNAMEPROC)load("glLoadName"); 1433 | glad_glPassThrough = (PFNGLPASSTHROUGHPROC)load("glPassThrough"); 1434 | glad_glPopName = (PFNGLPOPNAMEPROC)load("glPopName"); 1435 | glad_glPushName = (PFNGLPUSHNAMEPROC)load("glPushName"); 1436 | glad_glClearAccum = (PFNGLCLEARACCUMPROC)load("glClearAccum"); 1437 | glad_glClearIndex = (PFNGLCLEARINDEXPROC)load("glClearIndex"); 1438 | glad_glIndexMask = (PFNGLINDEXMASKPROC)load("glIndexMask"); 1439 | glad_glAccum = (PFNGLACCUMPROC)load("glAccum"); 1440 | glad_glPopAttrib = (PFNGLPOPATTRIBPROC)load("glPopAttrib"); 1441 | glad_glPushAttrib = (PFNGLPUSHATTRIBPROC)load("glPushAttrib"); 1442 | glad_glMap1d = (PFNGLMAP1DPROC)load("glMap1d"); 1443 | glad_glMap1f = (PFNGLMAP1FPROC)load("glMap1f"); 1444 | glad_glMap2d = (PFNGLMAP2DPROC)load("glMap2d"); 1445 | glad_glMap2f = (PFNGLMAP2FPROC)load("glMap2f"); 1446 | glad_glMapGrid1d = (PFNGLMAPGRID1DPROC)load("glMapGrid1d"); 1447 | glad_glMapGrid1f = (PFNGLMAPGRID1FPROC)load("glMapGrid1f"); 1448 | glad_glMapGrid2d = (PFNGLMAPGRID2DPROC)load("glMapGrid2d"); 1449 | glad_glMapGrid2f = (PFNGLMAPGRID2FPROC)load("glMapGrid2f"); 1450 | glad_glEvalCoord1d = (PFNGLEVALCOORD1DPROC)load("glEvalCoord1d"); 1451 | glad_glEvalCoord1dv = (PFNGLEVALCOORD1DVPROC)load("glEvalCoord1dv"); 1452 | glad_glEvalCoord1f = (PFNGLEVALCOORD1FPROC)load("glEvalCoord1f"); 1453 | glad_glEvalCoord1fv = (PFNGLEVALCOORD1FVPROC)load("glEvalCoord1fv"); 1454 | glad_glEvalCoord2d = (PFNGLEVALCOORD2DPROC)load("glEvalCoord2d"); 1455 | glad_glEvalCoord2dv = (PFNGLEVALCOORD2DVPROC)load("glEvalCoord2dv"); 1456 | glad_glEvalCoord2f = (PFNGLEVALCOORD2FPROC)load("glEvalCoord2f"); 1457 | glad_glEvalCoord2fv = (PFNGLEVALCOORD2FVPROC)load("glEvalCoord2fv"); 1458 | glad_glEvalMesh1 = (PFNGLEVALMESH1PROC)load("glEvalMesh1"); 1459 | glad_glEvalPoint1 = (PFNGLEVALPOINT1PROC)load("glEvalPoint1"); 1460 | glad_glEvalMesh2 = (PFNGLEVALMESH2PROC)load("glEvalMesh2"); 1461 | glad_glEvalPoint2 = (PFNGLEVALPOINT2PROC)load("glEvalPoint2"); 1462 | glad_glAlphaFunc = (PFNGLALPHAFUNCPROC)load("glAlphaFunc"); 1463 | glad_glPixelZoom = (PFNGLPIXELZOOMPROC)load("glPixelZoom"); 1464 | glad_glPixelTransferf = (PFNGLPIXELTRANSFERFPROC)load("glPixelTransferf"); 1465 | glad_glPixelTransferi = (PFNGLPIXELTRANSFERIPROC)load("glPixelTransferi"); 1466 | glad_glPixelMapfv = (PFNGLPIXELMAPFVPROC)load("glPixelMapfv"); 1467 | glad_glPixelMapuiv = (PFNGLPIXELMAPUIVPROC)load("glPixelMapuiv"); 1468 | glad_glPixelMapusv = (PFNGLPIXELMAPUSVPROC)load("glPixelMapusv"); 1469 | glad_glCopyPixels = (PFNGLCOPYPIXELSPROC)load("glCopyPixels"); 1470 | glad_glDrawPixels = (PFNGLDRAWPIXELSPROC)load("glDrawPixels"); 1471 | glad_glGetClipPlane = (PFNGLGETCLIPPLANEPROC)load("glGetClipPlane"); 1472 | glad_glGetLightfv = (PFNGLGETLIGHTFVPROC)load("glGetLightfv"); 1473 | glad_glGetLightiv = (PFNGLGETLIGHTIVPROC)load("glGetLightiv"); 1474 | glad_glGetMapdv = (PFNGLGETMAPDVPROC)load("glGetMapdv"); 1475 | glad_glGetMapfv = (PFNGLGETMAPFVPROC)load("glGetMapfv"); 1476 | glad_glGetMapiv = (PFNGLGETMAPIVPROC)load("glGetMapiv"); 1477 | glad_glGetMaterialfv = (PFNGLGETMATERIALFVPROC)load("glGetMaterialfv"); 1478 | glad_glGetMaterialiv = (PFNGLGETMATERIALIVPROC)load("glGetMaterialiv"); 1479 | glad_glGetPixelMapfv = (PFNGLGETPIXELMAPFVPROC)load("glGetPixelMapfv"); 1480 | glad_glGetPixelMapuiv = (PFNGLGETPIXELMAPUIVPROC)load("glGetPixelMapuiv"); 1481 | glad_glGetPixelMapusv = (PFNGLGETPIXELMAPUSVPROC)load("glGetPixelMapusv"); 1482 | glad_glGetPolygonStipple = (PFNGLGETPOLYGONSTIPPLEPROC)load("glGetPolygonStipple"); 1483 | glad_glGetTexEnvfv = (PFNGLGETTEXENVFVPROC)load("glGetTexEnvfv"); 1484 | glad_glGetTexEnviv = (PFNGLGETTEXENVIVPROC)load("glGetTexEnviv"); 1485 | glad_glGetTexGendv = (PFNGLGETTEXGENDVPROC)load("glGetTexGendv"); 1486 | glad_glGetTexGenfv = (PFNGLGETTEXGENFVPROC)load("glGetTexGenfv"); 1487 | glad_glGetTexGeniv = (PFNGLGETTEXGENIVPROC)load("glGetTexGeniv"); 1488 | glad_glIsList = (PFNGLISLISTPROC)load("glIsList"); 1489 | glad_glFrustum = (PFNGLFRUSTUMPROC)load("glFrustum"); 1490 | glad_glLoadIdentity = (PFNGLLOADIDENTITYPROC)load("glLoadIdentity"); 1491 | glad_glLoadMatrixf = (PFNGLLOADMATRIXFPROC)load("glLoadMatrixf"); 1492 | glad_glLoadMatrixd = (PFNGLLOADMATRIXDPROC)load("glLoadMatrixd"); 1493 | glad_glMatrixMode = (PFNGLMATRIXMODEPROC)load("glMatrixMode"); 1494 | glad_glMultMatrixf = (PFNGLMULTMATRIXFPROC)load("glMultMatrixf"); 1495 | glad_glMultMatrixd = (PFNGLMULTMATRIXDPROC)load("glMultMatrixd"); 1496 | glad_glOrtho = (PFNGLORTHOPROC)load("glOrtho"); 1497 | glad_glPopMatrix = (PFNGLPOPMATRIXPROC)load("glPopMatrix"); 1498 | glad_glPushMatrix = (PFNGLPUSHMATRIXPROC)load("glPushMatrix"); 1499 | glad_glRotated = (PFNGLROTATEDPROC)load("glRotated"); 1500 | glad_glRotatef = (PFNGLROTATEFPROC)load("glRotatef"); 1501 | glad_glScaled = (PFNGLSCALEDPROC)load("glScaled"); 1502 | glad_glScalef = (PFNGLSCALEFPROC)load("glScalef"); 1503 | glad_glTranslated = (PFNGLTRANSLATEDPROC)load("glTranslated"); 1504 | glad_glTranslatef = (PFNGLTRANSLATEFPROC)load("glTranslatef"); 1505 | } 1506 | static void load_GL_VERSION_1_1(GLADloadproc load) { 1507 | if(!GLAD_GL_VERSION_1_1) return; 1508 | glad_glDrawArrays = (PFNGLDRAWARRAYSPROC)load("glDrawArrays"); 1509 | glad_glDrawElements = (PFNGLDRAWELEMENTSPROC)load("glDrawElements"); 1510 | glad_glGetPointerv = (PFNGLGETPOINTERVPROC)load("glGetPointerv"); 1511 | glad_glPolygonOffset = (PFNGLPOLYGONOFFSETPROC)load("glPolygonOffset"); 1512 | glad_glCopyTexImage1D = (PFNGLCOPYTEXIMAGE1DPROC)load("glCopyTexImage1D"); 1513 | glad_glCopyTexImage2D = (PFNGLCOPYTEXIMAGE2DPROC)load("glCopyTexImage2D"); 1514 | glad_glCopyTexSubImage1D = (PFNGLCOPYTEXSUBIMAGE1DPROC)load("glCopyTexSubImage1D"); 1515 | glad_glCopyTexSubImage2D = (PFNGLCOPYTEXSUBIMAGE2DPROC)load("glCopyTexSubImage2D"); 1516 | glad_glTexSubImage1D = (PFNGLTEXSUBIMAGE1DPROC)load("glTexSubImage1D"); 1517 | glad_glTexSubImage2D = (PFNGLTEXSUBIMAGE2DPROC)load("glTexSubImage2D"); 1518 | glad_glBindTexture = (PFNGLBINDTEXTUREPROC)load("glBindTexture"); 1519 | glad_glDeleteTextures = (PFNGLDELETETEXTURESPROC)load("glDeleteTextures"); 1520 | glad_glGenTextures = (PFNGLGENTEXTURESPROC)load("glGenTextures"); 1521 | glad_glIsTexture = (PFNGLISTEXTUREPROC)load("glIsTexture"); 1522 | glad_glArrayElement = (PFNGLARRAYELEMENTPROC)load("glArrayElement"); 1523 | glad_glColorPointer = (PFNGLCOLORPOINTERPROC)load("glColorPointer"); 1524 | glad_glDisableClientState = (PFNGLDISABLECLIENTSTATEPROC)load("glDisableClientState"); 1525 | glad_glEdgeFlagPointer = (PFNGLEDGEFLAGPOINTERPROC)load("glEdgeFlagPointer"); 1526 | glad_glEnableClientState = (PFNGLENABLECLIENTSTATEPROC)load("glEnableClientState"); 1527 | glad_glIndexPointer = (PFNGLINDEXPOINTERPROC)load("glIndexPointer"); 1528 | glad_glInterleavedArrays = (PFNGLINTERLEAVEDARRAYSPROC)load("glInterleavedArrays"); 1529 | glad_glNormalPointer = (PFNGLNORMALPOINTERPROC)load("glNormalPointer"); 1530 | glad_glTexCoordPointer = (PFNGLTEXCOORDPOINTERPROC)load("glTexCoordPointer"); 1531 | glad_glVertexPointer = (PFNGLVERTEXPOINTERPROC)load("glVertexPointer"); 1532 | glad_glAreTexturesResident = (PFNGLARETEXTURESRESIDENTPROC)load("glAreTexturesResident"); 1533 | glad_glPrioritizeTextures = (PFNGLPRIORITIZETEXTURESPROC)load("glPrioritizeTextures"); 1534 | glad_glIndexub = (PFNGLINDEXUBPROC)load("glIndexub"); 1535 | glad_glIndexubv = (PFNGLINDEXUBVPROC)load("glIndexubv"); 1536 | glad_glPopClientAttrib = (PFNGLPOPCLIENTATTRIBPROC)load("glPopClientAttrib"); 1537 | glad_glPushClientAttrib = (PFNGLPUSHCLIENTATTRIBPROC)load("glPushClientAttrib"); 1538 | } 1539 | static void load_GL_VERSION_1_2(GLADloadproc load) { 1540 | if(!GLAD_GL_VERSION_1_2) return; 1541 | glad_glDrawRangeElements = (PFNGLDRAWRANGEELEMENTSPROC)load("glDrawRangeElements"); 1542 | glad_glTexImage3D = (PFNGLTEXIMAGE3DPROC)load("glTexImage3D"); 1543 | glad_glTexSubImage3D = (PFNGLTEXSUBIMAGE3DPROC)load("glTexSubImage3D"); 1544 | glad_glCopyTexSubImage3D = (PFNGLCOPYTEXSUBIMAGE3DPROC)load("glCopyTexSubImage3D"); 1545 | } 1546 | static void load_GL_VERSION_1_3(GLADloadproc load) { 1547 | if(!GLAD_GL_VERSION_1_3) return; 1548 | glad_glActiveTexture = (PFNGLACTIVETEXTUREPROC)load("glActiveTexture"); 1549 | glad_glSampleCoverage = (PFNGLSAMPLECOVERAGEPROC)load("glSampleCoverage"); 1550 | glad_glCompressedTexImage3D = (PFNGLCOMPRESSEDTEXIMAGE3DPROC)load("glCompressedTexImage3D"); 1551 | glad_glCompressedTexImage2D = (PFNGLCOMPRESSEDTEXIMAGE2DPROC)load("glCompressedTexImage2D"); 1552 | glad_glCompressedTexImage1D = (PFNGLCOMPRESSEDTEXIMAGE1DPROC)load("glCompressedTexImage1D"); 1553 | glad_glCompressedTexSubImage3D = (PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC)load("glCompressedTexSubImage3D"); 1554 | glad_glCompressedTexSubImage2D = (PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC)load("glCompressedTexSubImage2D"); 1555 | glad_glCompressedTexSubImage1D = (PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC)load("glCompressedTexSubImage1D"); 1556 | glad_glGetCompressedTexImage = (PFNGLGETCOMPRESSEDTEXIMAGEPROC)load("glGetCompressedTexImage"); 1557 | glad_glClientActiveTexture = (PFNGLCLIENTACTIVETEXTUREPROC)load("glClientActiveTexture"); 1558 | glad_glMultiTexCoord1d = (PFNGLMULTITEXCOORD1DPROC)load("glMultiTexCoord1d"); 1559 | glad_glMultiTexCoord1dv = (PFNGLMULTITEXCOORD1DVPROC)load("glMultiTexCoord1dv"); 1560 | glad_glMultiTexCoord1f = (PFNGLMULTITEXCOORD1FPROC)load("glMultiTexCoord1f"); 1561 | glad_glMultiTexCoord1fv = (PFNGLMULTITEXCOORD1FVPROC)load("glMultiTexCoord1fv"); 1562 | glad_glMultiTexCoord1i = (PFNGLMULTITEXCOORD1IPROC)load("glMultiTexCoord1i"); 1563 | glad_glMultiTexCoord1iv = (PFNGLMULTITEXCOORD1IVPROC)load("glMultiTexCoord1iv"); 1564 | glad_glMultiTexCoord1s = (PFNGLMULTITEXCOORD1SPROC)load("glMultiTexCoord1s"); 1565 | glad_glMultiTexCoord1sv = (PFNGLMULTITEXCOORD1SVPROC)load("glMultiTexCoord1sv"); 1566 | glad_glMultiTexCoord2d = (PFNGLMULTITEXCOORD2DPROC)load("glMultiTexCoord2d"); 1567 | glad_glMultiTexCoord2dv = (PFNGLMULTITEXCOORD2DVPROC)load("glMultiTexCoord2dv"); 1568 | glad_glMultiTexCoord2f = (PFNGLMULTITEXCOORD2FPROC)load("glMultiTexCoord2f"); 1569 | glad_glMultiTexCoord2fv = (PFNGLMULTITEXCOORD2FVPROC)load("glMultiTexCoord2fv"); 1570 | glad_glMultiTexCoord2i = (PFNGLMULTITEXCOORD2IPROC)load("glMultiTexCoord2i"); 1571 | glad_glMultiTexCoord2iv = (PFNGLMULTITEXCOORD2IVPROC)load("glMultiTexCoord2iv"); 1572 | glad_glMultiTexCoord2s = (PFNGLMULTITEXCOORD2SPROC)load("glMultiTexCoord2s"); 1573 | glad_glMultiTexCoord2sv = (PFNGLMULTITEXCOORD2SVPROC)load("glMultiTexCoord2sv"); 1574 | glad_glMultiTexCoord3d = (PFNGLMULTITEXCOORD3DPROC)load("glMultiTexCoord3d"); 1575 | glad_glMultiTexCoord3dv = (PFNGLMULTITEXCOORD3DVPROC)load("glMultiTexCoord3dv"); 1576 | glad_glMultiTexCoord3f = (PFNGLMULTITEXCOORD3FPROC)load("glMultiTexCoord3f"); 1577 | glad_glMultiTexCoord3fv = (PFNGLMULTITEXCOORD3FVPROC)load("glMultiTexCoord3fv"); 1578 | glad_glMultiTexCoord3i = (PFNGLMULTITEXCOORD3IPROC)load("glMultiTexCoord3i"); 1579 | glad_glMultiTexCoord3iv = (PFNGLMULTITEXCOORD3IVPROC)load("glMultiTexCoord3iv"); 1580 | glad_glMultiTexCoord3s = (PFNGLMULTITEXCOORD3SPROC)load("glMultiTexCoord3s"); 1581 | glad_glMultiTexCoord3sv = (PFNGLMULTITEXCOORD3SVPROC)load("glMultiTexCoord3sv"); 1582 | glad_glMultiTexCoord4d = (PFNGLMULTITEXCOORD4DPROC)load("glMultiTexCoord4d"); 1583 | glad_glMultiTexCoord4dv = (PFNGLMULTITEXCOORD4DVPROC)load("glMultiTexCoord4dv"); 1584 | glad_glMultiTexCoord4f = (PFNGLMULTITEXCOORD4FPROC)load("glMultiTexCoord4f"); 1585 | glad_glMultiTexCoord4fv = (PFNGLMULTITEXCOORD4FVPROC)load("glMultiTexCoord4fv"); 1586 | glad_glMultiTexCoord4i = (PFNGLMULTITEXCOORD4IPROC)load("glMultiTexCoord4i"); 1587 | glad_glMultiTexCoord4iv = (PFNGLMULTITEXCOORD4IVPROC)load("glMultiTexCoord4iv"); 1588 | glad_glMultiTexCoord4s = (PFNGLMULTITEXCOORD4SPROC)load("glMultiTexCoord4s"); 1589 | glad_glMultiTexCoord4sv = (PFNGLMULTITEXCOORD4SVPROC)load("glMultiTexCoord4sv"); 1590 | glad_glLoadTransposeMatrixf = (PFNGLLOADTRANSPOSEMATRIXFPROC)load("glLoadTransposeMatrixf"); 1591 | glad_glLoadTransposeMatrixd = (PFNGLLOADTRANSPOSEMATRIXDPROC)load("glLoadTransposeMatrixd"); 1592 | glad_glMultTransposeMatrixf = (PFNGLMULTTRANSPOSEMATRIXFPROC)load("glMultTransposeMatrixf"); 1593 | glad_glMultTransposeMatrixd = (PFNGLMULTTRANSPOSEMATRIXDPROC)load("glMultTransposeMatrixd"); 1594 | } 1595 | static void load_GL_VERSION_1_4(GLADloadproc load) { 1596 | if(!GLAD_GL_VERSION_1_4) return; 1597 | glad_glBlendFuncSeparate = (PFNGLBLENDFUNCSEPARATEPROC)load("glBlendFuncSeparate"); 1598 | glad_glMultiDrawArrays = (PFNGLMULTIDRAWARRAYSPROC)load("glMultiDrawArrays"); 1599 | glad_glMultiDrawElements = (PFNGLMULTIDRAWELEMENTSPROC)load("glMultiDrawElements"); 1600 | glad_glPointParameterf = (PFNGLPOINTPARAMETERFPROC)load("glPointParameterf"); 1601 | glad_glPointParameterfv = (PFNGLPOINTPARAMETERFVPROC)load("glPointParameterfv"); 1602 | glad_glPointParameteri = (PFNGLPOINTPARAMETERIPROC)load("glPointParameteri"); 1603 | glad_glPointParameteriv = (PFNGLPOINTPARAMETERIVPROC)load("glPointParameteriv"); 1604 | glad_glFogCoordf = (PFNGLFOGCOORDFPROC)load("glFogCoordf"); 1605 | glad_glFogCoordfv = (PFNGLFOGCOORDFVPROC)load("glFogCoordfv"); 1606 | glad_glFogCoordd = (PFNGLFOGCOORDDPROC)load("glFogCoordd"); 1607 | glad_glFogCoorddv = (PFNGLFOGCOORDDVPROC)load("glFogCoorddv"); 1608 | glad_glFogCoordPointer = (PFNGLFOGCOORDPOINTERPROC)load("glFogCoordPointer"); 1609 | glad_glSecondaryColor3b = (PFNGLSECONDARYCOLOR3BPROC)load("glSecondaryColor3b"); 1610 | glad_glSecondaryColor3bv = (PFNGLSECONDARYCOLOR3BVPROC)load("glSecondaryColor3bv"); 1611 | glad_glSecondaryColor3d = (PFNGLSECONDARYCOLOR3DPROC)load("glSecondaryColor3d"); 1612 | glad_glSecondaryColor3dv = (PFNGLSECONDARYCOLOR3DVPROC)load("glSecondaryColor3dv"); 1613 | glad_glSecondaryColor3f = (PFNGLSECONDARYCOLOR3FPROC)load("glSecondaryColor3f"); 1614 | glad_glSecondaryColor3fv = (PFNGLSECONDARYCOLOR3FVPROC)load("glSecondaryColor3fv"); 1615 | glad_glSecondaryColor3i = (PFNGLSECONDARYCOLOR3IPROC)load("glSecondaryColor3i"); 1616 | glad_glSecondaryColor3iv = (PFNGLSECONDARYCOLOR3IVPROC)load("glSecondaryColor3iv"); 1617 | glad_glSecondaryColor3s = (PFNGLSECONDARYCOLOR3SPROC)load("glSecondaryColor3s"); 1618 | glad_glSecondaryColor3sv = (PFNGLSECONDARYCOLOR3SVPROC)load("glSecondaryColor3sv"); 1619 | glad_glSecondaryColor3ub = (PFNGLSECONDARYCOLOR3UBPROC)load("glSecondaryColor3ub"); 1620 | glad_glSecondaryColor3ubv = (PFNGLSECONDARYCOLOR3UBVPROC)load("glSecondaryColor3ubv"); 1621 | glad_glSecondaryColor3ui = (PFNGLSECONDARYCOLOR3UIPROC)load("glSecondaryColor3ui"); 1622 | glad_glSecondaryColor3uiv = (PFNGLSECONDARYCOLOR3UIVPROC)load("glSecondaryColor3uiv"); 1623 | glad_glSecondaryColor3us = (PFNGLSECONDARYCOLOR3USPROC)load("glSecondaryColor3us"); 1624 | glad_glSecondaryColor3usv = (PFNGLSECONDARYCOLOR3USVPROC)load("glSecondaryColor3usv"); 1625 | glad_glSecondaryColorPointer = (PFNGLSECONDARYCOLORPOINTERPROC)load("glSecondaryColorPointer"); 1626 | glad_glWindowPos2d = (PFNGLWINDOWPOS2DPROC)load("glWindowPos2d"); 1627 | glad_glWindowPos2dv = (PFNGLWINDOWPOS2DVPROC)load("glWindowPos2dv"); 1628 | glad_glWindowPos2f = (PFNGLWINDOWPOS2FPROC)load("glWindowPos2f"); 1629 | glad_glWindowPos2fv = (PFNGLWINDOWPOS2FVPROC)load("glWindowPos2fv"); 1630 | glad_glWindowPos2i = (PFNGLWINDOWPOS2IPROC)load("glWindowPos2i"); 1631 | glad_glWindowPos2iv = (PFNGLWINDOWPOS2IVPROC)load("glWindowPos2iv"); 1632 | glad_glWindowPos2s = (PFNGLWINDOWPOS2SPROC)load("glWindowPos2s"); 1633 | glad_glWindowPos2sv = (PFNGLWINDOWPOS2SVPROC)load("glWindowPos2sv"); 1634 | glad_glWindowPos3d = (PFNGLWINDOWPOS3DPROC)load("glWindowPos3d"); 1635 | glad_glWindowPos3dv = (PFNGLWINDOWPOS3DVPROC)load("glWindowPos3dv"); 1636 | glad_glWindowPos3f = (PFNGLWINDOWPOS3FPROC)load("glWindowPos3f"); 1637 | glad_glWindowPos3fv = (PFNGLWINDOWPOS3FVPROC)load("glWindowPos3fv"); 1638 | glad_glWindowPos3i = (PFNGLWINDOWPOS3IPROC)load("glWindowPos3i"); 1639 | glad_glWindowPos3iv = (PFNGLWINDOWPOS3IVPROC)load("glWindowPos3iv"); 1640 | glad_glWindowPos3s = (PFNGLWINDOWPOS3SPROC)load("glWindowPos3s"); 1641 | glad_glWindowPos3sv = (PFNGLWINDOWPOS3SVPROC)load("glWindowPos3sv"); 1642 | glad_glBlendColor = (PFNGLBLENDCOLORPROC)load("glBlendColor"); 1643 | glad_glBlendEquation = (PFNGLBLENDEQUATIONPROC)load("glBlendEquation"); 1644 | } 1645 | static void load_GL_VERSION_1_5(GLADloadproc load) { 1646 | if(!GLAD_GL_VERSION_1_5) return; 1647 | glad_glGenQueries = (PFNGLGENQUERIESPROC)load("glGenQueries"); 1648 | glad_glDeleteQueries = (PFNGLDELETEQUERIESPROC)load("glDeleteQueries"); 1649 | glad_glIsQuery = (PFNGLISQUERYPROC)load("glIsQuery"); 1650 | glad_glBeginQuery = (PFNGLBEGINQUERYPROC)load("glBeginQuery"); 1651 | glad_glEndQuery = (PFNGLENDQUERYPROC)load("glEndQuery"); 1652 | glad_glGetQueryiv = (PFNGLGETQUERYIVPROC)load("glGetQueryiv"); 1653 | glad_glGetQueryObjectiv = (PFNGLGETQUERYOBJECTIVPROC)load("glGetQueryObjectiv"); 1654 | glad_glGetQueryObjectuiv = (PFNGLGETQUERYOBJECTUIVPROC)load("glGetQueryObjectuiv"); 1655 | glad_glBindBuffer = (PFNGLBINDBUFFERPROC)load("glBindBuffer"); 1656 | glad_glDeleteBuffers = (PFNGLDELETEBUFFERSPROC)load("glDeleteBuffers"); 1657 | glad_glGenBuffers = (PFNGLGENBUFFERSPROC)load("glGenBuffers"); 1658 | glad_glIsBuffer = (PFNGLISBUFFERPROC)load("glIsBuffer"); 1659 | glad_glBufferData = (PFNGLBUFFERDATAPROC)load("glBufferData"); 1660 | glad_glBufferSubData = (PFNGLBUFFERSUBDATAPROC)load("glBufferSubData"); 1661 | glad_glGetBufferSubData = (PFNGLGETBUFFERSUBDATAPROC)load("glGetBufferSubData"); 1662 | glad_glMapBuffer = (PFNGLMAPBUFFERPROC)load("glMapBuffer"); 1663 | glad_glUnmapBuffer = (PFNGLUNMAPBUFFERPROC)load("glUnmapBuffer"); 1664 | glad_glGetBufferParameteriv = (PFNGLGETBUFFERPARAMETERIVPROC)load("glGetBufferParameteriv"); 1665 | glad_glGetBufferPointerv = (PFNGLGETBUFFERPOINTERVPROC)load("glGetBufferPointerv"); 1666 | } 1667 | static void load_GL_VERSION_2_0(GLADloadproc load) { 1668 | if(!GLAD_GL_VERSION_2_0) return; 1669 | glad_glBlendEquationSeparate = (PFNGLBLENDEQUATIONSEPARATEPROC)load("glBlendEquationSeparate"); 1670 | glad_glDrawBuffers = (PFNGLDRAWBUFFERSPROC)load("glDrawBuffers"); 1671 | glad_glStencilOpSeparate = (PFNGLSTENCILOPSEPARATEPROC)load("glStencilOpSeparate"); 1672 | glad_glStencilFuncSeparate = (PFNGLSTENCILFUNCSEPARATEPROC)load("glStencilFuncSeparate"); 1673 | glad_glStencilMaskSeparate = (PFNGLSTENCILMASKSEPARATEPROC)load("glStencilMaskSeparate"); 1674 | glad_glAttachShader = (PFNGLATTACHSHADERPROC)load("glAttachShader"); 1675 | glad_glBindAttribLocation = (PFNGLBINDATTRIBLOCATIONPROC)load("glBindAttribLocation"); 1676 | glad_glCompileShader = (PFNGLCOMPILESHADERPROC)load("glCompileShader"); 1677 | glad_glCreateProgram = (PFNGLCREATEPROGRAMPROC)load("glCreateProgram"); 1678 | glad_glCreateShader = (PFNGLCREATESHADERPROC)load("glCreateShader"); 1679 | glad_glDeleteProgram = (PFNGLDELETEPROGRAMPROC)load("glDeleteProgram"); 1680 | glad_glDeleteShader = (PFNGLDELETESHADERPROC)load("glDeleteShader"); 1681 | glad_glDetachShader = (PFNGLDETACHSHADERPROC)load("glDetachShader"); 1682 | glad_glDisableVertexAttribArray = (PFNGLDISABLEVERTEXATTRIBARRAYPROC)load("glDisableVertexAttribArray"); 1683 | glad_glEnableVertexAttribArray = (PFNGLENABLEVERTEXATTRIBARRAYPROC)load("glEnableVertexAttribArray"); 1684 | glad_glGetActiveAttrib = (PFNGLGETACTIVEATTRIBPROC)load("glGetActiveAttrib"); 1685 | glad_glGetActiveUniform = (PFNGLGETACTIVEUNIFORMPROC)load("glGetActiveUniform"); 1686 | glad_glGetAttachedShaders = (PFNGLGETATTACHEDSHADERSPROC)load("glGetAttachedShaders"); 1687 | glad_glGetAttribLocation = (PFNGLGETATTRIBLOCATIONPROC)load("glGetAttribLocation"); 1688 | glad_glGetProgramiv = (PFNGLGETPROGRAMIVPROC)load("glGetProgramiv"); 1689 | glad_glGetProgramInfoLog = (PFNGLGETPROGRAMINFOLOGPROC)load("glGetProgramInfoLog"); 1690 | glad_glGetShaderiv = (PFNGLGETSHADERIVPROC)load("glGetShaderiv"); 1691 | glad_glGetShaderInfoLog = (PFNGLGETSHADERINFOLOGPROC)load("glGetShaderInfoLog"); 1692 | glad_glGetShaderSource = (PFNGLGETSHADERSOURCEPROC)load("glGetShaderSource"); 1693 | glad_glGetUniformLocation = (PFNGLGETUNIFORMLOCATIONPROC)load("glGetUniformLocation"); 1694 | glad_glGetUniformfv = (PFNGLGETUNIFORMFVPROC)load("glGetUniformfv"); 1695 | glad_glGetUniformiv = (PFNGLGETUNIFORMIVPROC)load("glGetUniformiv"); 1696 | glad_glGetVertexAttribdv = (PFNGLGETVERTEXATTRIBDVPROC)load("glGetVertexAttribdv"); 1697 | glad_glGetVertexAttribfv = (PFNGLGETVERTEXATTRIBFVPROC)load("glGetVertexAttribfv"); 1698 | glad_glGetVertexAttribiv = (PFNGLGETVERTEXATTRIBIVPROC)load("glGetVertexAttribiv"); 1699 | glad_glGetVertexAttribPointerv = (PFNGLGETVERTEXATTRIBPOINTERVPROC)load("glGetVertexAttribPointerv"); 1700 | glad_glIsProgram = (PFNGLISPROGRAMPROC)load("glIsProgram"); 1701 | glad_glIsShader = (PFNGLISSHADERPROC)load("glIsShader"); 1702 | glad_glLinkProgram = (PFNGLLINKPROGRAMPROC)load("glLinkProgram"); 1703 | glad_glShaderSource = (PFNGLSHADERSOURCEPROC)load("glShaderSource"); 1704 | glad_glUseProgram = (PFNGLUSEPROGRAMPROC)load("glUseProgram"); 1705 | glad_glUniform1f = (PFNGLUNIFORM1FPROC)load("glUniform1f"); 1706 | glad_glUniform2f = (PFNGLUNIFORM2FPROC)load("glUniform2f"); 1707 | glad_glUniform3f = (PFNGLUNIFORM3FPROC)load("glUniform3f"); 1708 | glad_glUniform4f = (PFNGLUNIFORM4FPROC)load("glUniform4f"); 1709 | glad_glUniform1i = (PFNGLUNIFORM1IPROC)load("glUniform1i"); 1710 | glad_glUniform2i = (PFNGLUNIFORM2IPROC)load("glUniform2i"); 1711 | glad_glUniform3i = (PFNGLUNIFORM3IPROC)load("glUniform3i"); 1712 | glad_glUniform4i = (PFNGLUNIFORM4IPROC)load("glUniform4i"); 1713 | glad_glUniform1fv = (PFNGLUNIFORM1FVPROC)load("glUniform1fv"); 1714 | glad_glUniform2fv = (PFNGLUNIFORM2FVPROC)load("glUniform2fv"); 1715 | glad_glUniform3fv = (PFNGLUNIFORM3FVPROC)load("glUniform3fv"); 1716 | glad_glUniform4fv = (PFNGLUNIFORM4FVPROC)load("glUniform4fv"); 1717 | glad_glUniform1iv = (PFNGLUNIFORM1IVPROC)load("glUniform1iv"); 1718 | glad_glUniform2iv = (PFNGLUNIFORM2IVPROC)load("glUniform2iv"); 1719 | glad_glUniform3iv = (PFNGLUNIFORM3IVPROC)load("glUniform3iv"); 1720 | glad_glUniform4iv = (PFNGLUNIFORM4IVPROC)load("glUniform4iv"); 1721 | glad_glUniformMatrix2fv = (PFNGLUNIFORMMATRIX2FVPROC)load("glUniformMatrix2fv"); 1722 | glad_glUniformMatrix3fv = (PFNGLUNIFORMMATRIX3FVPROC)load("glUniformMatrix3fv"); 1723 | glad_glUniformMatrix4fv = (PFNGLUNIFORMMATRIX4FVPROC)load("glUniformMatrix4fv"); 1724 | glad_glValidateProgram = (PFNGLVALIDATEPROGRAMPROC)load("glValidateProgram"); 1725 | glad_glVertexAttrib1d = (PFNGLVERTEXATTRIB1DPROC)load("glVertexAttrib1d"); 1726 | glad_glVertexAttrib1dv = (PFNGLVERTEXATTRIB1DVPROC)load("glVertexAttrib1dv"); 1727 | glad_glVertexAttrib1f = (PFNGLVERTEXATTRIB1FPROC)load("glVertexAttrib1f"); 1728 | glad_glVertexAttrib1fv = (PFNGLVERTEXATTRIB1FVPROC)load("glVertexAttrib1fv"); 1729 | glad_glVertexAttrib1s = (PFNGLVERTEXATTRIB1SPROC)load("glVertexAttrib1s"); 1730 | glad_glVertexAttrib1sv = (PFNGLVERTEXATTRIB1SVPROC)load("glVertexAttrib1sv"); 1731 | glad_glVertexAttrib2d = (PFNGLVERTEXATTRIB2DPROC)load("glVertexAttrib2d"); 1732 | glad_glVertexAttrib2dv = (PFNGLVERTEXATTRIB2DVPROC)load("glVertexAttrib2dv"); 1733 | glad_glVertexAttrib2f = (PFNGLVERTEXATTRIB2FPROC)load("glVertexAttrib2f"); 1734 | glad_glVertexAttrib2fv = (PFNGLVERTEXATTRIB2FVPROC)load("glVertexAttrib2fv"); 1735 | glad_glVertexAttrib2s = (PFNGLVERTEXATTRIB2SPROC)load("glVertexAttrib2s"); 1736 | glad_glVertexAttrib2sv = (PFNGLVERTEXATTRIB2SVPROC)load("glVertexAttrib2sv"); 1737 | glad_glVertexAttrib3d = (PFNGLVERTEXATTRIB3DPROC)load("glVertexAttrib3d"); 1738 | glad_glVertexAttrib3dv = (PFNGLVERTEXATTRIB3DVPROC)load("glVertexAttrib3dv"); 1739 | glad_glVertexAttrib3f = (PFNGLVERTEXATTRIB3FPROC)load("glVertexAttrib3f"); 1740 | glad_glVertexAttrib3fv = (PFNGLVERTEXATTRIB3FVPROC)load("glVertexAttrib3fv"); 1741 | glad_glVertexAttrib3s = (PFNGLVERTEXATTRIB3SPROC)load("glVertexAttrib3s"); 1742 | glad_glVertexAttrib3sv = (PFNGLVERTEXATTRIB3SVPROC)load("glVertexAttrib3sv"); 1743 | glad_glVertexAttrib4Nbv = (PFNGLVERTEXATTRIB4NBVPROC)load("glVertexAttrib4Nbv"); 1744 | glad_glVertexAttrib4Niv = (PFNGLVERTEXATTRIB4NIVPROC)load("glVertexAttrib4Niv"); 1745 | glad_glVertexAttrib4Nsv = (PFNGLVERTEXATTRIB4NSVPROC)load("glVertexAttrib4Nsv"); 1746 | glad_glVertexAttrib4Nub = (PFNGLVERTEXATTRIB4NUBPROC)load("glVertexAttrib4Nub"); 1747 | glad_glVertexAttrib4Nubv = (PFNGLVERTEXATTRIB4NUBVPROC)load("glVertexAttrib4Nubv"); 1748 | glad_glVertexAttrib4Nuiv = (PFNGLVERTEXATTRIB4NUIVPROC)load("glVertexAttrib4Nuiv"); 1749 | glad_glVertexAttrib4Nusv = (PFNGLVERTEXATTRIB4NUSVPROC)load("glVertexAttrib4Nusv"); 1750 | glad_glVertexAttrib4bv = (PFNGLVERTEXATTRIB4BVPROC)load("glVertexAttrib4bv"); 1751 | glad_glVertexAttrib4d = (PFNGLVERTEXATTRIB4DPROC)load("glVertexAttrib4d"); 1752 | glad_glVertexAttrib4dv = (PFNGLVERTEXATTRIB4DVPROC)load("glVertexAttrib4dv"); 1753 | glad_glVertexAttrib4f = (PFNGLVERTEXATTRIB4FPROC)load("glVertexAttrib4f"); 1754 | glad_glVertexAttrib4fv = (PFNGLVERTEXATTRIB4FVPROC)load("glVertexAttrib4fv"); 1755 | glad_glVertexAttrib4iv = (PFNGLVERTEXATTRIB4IVPROC)load("glVertexAttrib4iv"); 1756 | glad_glVertexAttrib4s = (PFNGLVERTEXATTRIB4SPROC)load("glVertexAttrib4s"); 1757 | glad_glVertexAttrib4sv = (PFNGLVERTEXATTRIB4SVPROC)load("glVertexAttrib4sv"); 1758 | glad_glVertexAttrib4ubv = (PFNGLVERTEXATTRIB4UBVPROC)load("glVertexAttrib4ubv"); 1759 | glad_glVertexAttrib4uiv = (PFNGLVERTEXATTRIB4UIVPROC)load("glVertexAttrib4uiv"); 1760 | glad_glVertexAttrib4usv = (PFNGLVERTEXATTRIB4USVPROC)load("glVertexAttrib4usv"); 1761 | glad_glVertexAttribPointer = (PFNGLVERTEXATTRIBPOINTERPROC)load("glVertexAttribPointer"); 1762 | } 1763 | static void load_GL_VERSION_2_1(GLADloadproc load) { 1764 | if(!GLAD_GL_VERSION_2_1) return; 1765 | glad_glUniformMatrix2x3fv = (PFNGLUNIFORMMATRIX2X3FVPROC)load("glUniformMatrix2x3fv"); 1766 | glad_glUniformMatrix3x2fv = (PFNGLUNIFORMMATRIX3X2FVPROC)load("glUniformMatrix3x2fv"); 1767 | glad_glUniformMatrix2x4fv = (PFNGLUNIFORMMATRIX2X4FVPROC)load("glUniformMatrix2x4fv"); 1768 | glad_glUniformMatrix4x2fv = (PFNGLUNIFORMMATRIX4X2FVPROC)load("glUniformMatrix4x2fv"); 1769 | glad_glUniformMatrix3x4fv = (PFNGLUNIFORMMATRIX3X4FVPROC)load("glUniformMatrix3x4fv"); 1770 | glad_glUniformMatrix4x3fv = (PFNGLUNIFORMMATRIX4X3FVPROC)load("glUniformMatrix4x3fv"); 1771 | } 1772 | static void load_GL_VERSION_3_0(GLADloadproc load) { 1773 | if(!GLAD_GL_VERSION_3_0) return; 1774 | glad_glColorMaski = (PFNGLCOLORMASKIPROC)load("glColorMaski"); 1775 | glad_glGetBooleani_v = (PFNGLGETBOOLEANI_VPROC)load("glGetBooleani_v"); 1776 | glad_glGetIntegeri_v = (PFNGLGETINTEGERI_VPROC)load("glGetIntegeri_v"); 1777 | glad_glEnablei = (PFNGLENABLEIPROC)load("glEnablei"); 1778 | glad_glDisablei = (PFNGLDISABLEIPROC)load("glDisablei"); 1779 | glad_glIsEnabledi = (PFNGLISENABLEDIPROC)load("glIsEnabledi"); 1780 | glad_glBeginTransformFeedback = (PFNGLBEGINTRANSFORMFEEDBACKPROC)load("glBeginTransformFeedback"); 1781 | glad_glEndTransformFeedback = (PFNGLENDTRANSFORMFEEDBACKPROC)load("glEndTransformFeedback"); 1782 | glad_glBindBufferRange = (PFNGLBINDBUFFERRANGEPROC)load("glBindBufferRange"); 1783 | glad_glBindBufferBase = (PFNGLBINDBUFFERBASEPROC)load("glBindBufferBase"); 1784 | glad_glTransformFeedbackVaryings = (PFNGLTRANSFORMFEEDBACKVARYINGSPROC)load("glTransformFeedbackVaryings"); 1785 | glad_glGetTransformFeedbackVarying = (PFNGLGETTRANSFORMFEEDBACKVARYINGPROC)load("glGetTransformFeedbackVarying"); 1786 | glad_glClampColor = (PFNGLCLAMPCOLORPROC)load("glClampColor"); 1787 | glad_glBeginConditionalRender = (PFNGLBEGINCONDITIONALRENDERPROC)load("glBeginConditionalRender"); 1788 | glad_glEndConditionalRender = (PFNGLENDCONDITIONALRENDERPROC)load("glEndConditionalRender"); 1789 | glad_glVertexAttribIPointer = (PFNGLVERTEXATTRIBIPOINTERPROC)load("glVertexAttribIPointer"); 1790 | glad_glGetVertexAttribIiv = (PFNGLGETVERTEXATTRIBIIVPROC)load("glGetVertexAttribIiv"); 1791 | glad_glGetVertexAttribIuiv = (PFNGLGETVERTEXATTRIBIUIVPROC)load("glGetVertexAttribIuiv"); 1792 | glad_glVertexAttribI1i = (PFNGLVERTEXATTRIBI1IPROC)load("glVertexAttribI1i"); 1793 | glad_glVertexAttribI2i = (PFNGLVERTEXATTRIBI2IPROC)load("glVertexAttribI2i"); 1794 | glad_glVertexAttribI3i = (PFNGLVERTEXATTRIBI3IPROC)load("glVertexAttribI3i"); 1795 | glad_glVertexAttribI4i = (PFNGLVERTEXATTRIBI4IPROC)load("glVertexAttribI4i"); 1796 | glad_glVertexAttribI1ui = (PFNGLVERTEXATTRIBI1UIPROC)load("glVertexAttribI1ui"); 1797 | glad_glVertexAttribI2ui = (PFNGLVERTEXATTRIBI2UIPROC)load("glVertexAttribI2ui"); 1798 | glad_glVertexAttribI3ui = (PFNGLVERTEXATTRIBI3UIPROC)load("glVertexAttribI3ui"); 1799 | glad_glVertexAttribI4ui = (PFNGLVERTEXATTRIBI4UIPROC)load("glVertexAttribI4ui"); 1800 | glad_glVertexAttribI1iv = (PFNGLVERTEXATTRIBI1IVPROC)load("glVertexAttribI1iv"); 1801 | glad_glVertexAttribI2iv = (PFNGLVERTEXATTRIBI2IVPROC)load("glVertexAttribI2iv"); 1802 | glad_glVertexAttribI3iv = (PFNGLVERTEXATTRIBI3IVPROC)load("glVertexAttribI3iv"); 1803 | glad_glVertexAttribI4iv = (PFNGLVERTEXATTRIBI4IVPROC)load("glVertexAttribI4iv"); 1804 | glad_glVertexAttribI1uiv = (PFNGLVERTEXATTRIBI1UIVPROC)load("glVertexAttribI1uiv"); 1805 | glad_glVertexAttribI2uiv = (PFNGLVERTEXATTRIBI2UIVPROC)load("glVertexAttribI2uiv"); 1806 | glad_glVertexAttribI3uiv = (PFNGLVERTEXATTRIBI3UIVPROC)load("glVertexAttribI3uiv"); 1807 | glad_glVertexAttribI4uiv = (PFNGLVERTEXATTRIBI4UIVPROC)load("glVertexAttribI4uiv"); 1808 | glad_glVertexAttribI4bv = (PFNGLVERTEXATTRIBI4BVPROC)load("glVertexAttribI4bv"); 1809 | glad_glVertexAttribI4sv = (PFNGLVERTEXATTRIBI4SVPROC)load("glVertexAttribI4sv"); 1810 | glad_glVertexAttribI4ubv = (PFNGLVERTEXATTRIBI4UBVPROC)load("glVertexAttribI4ubv"); 1811 | glad_glVertexAttribI4usv = (PFNGLVERTEXATTRIBI4USVPROC)load("glVertexAttribI4usv"); 1812 | glad_glGetUniformuiv = (PFNGLGETUNIFORMUIVPROC)load("glGetUniformuiv"); 1813 | glad_glBindFragDataLocation = (PFNGLBINDFRAGDATALOCATIONPROC)load("glBindFragDataLocation"); 1814 | glad_glGetFragDataLocation = (PFNGLGETFRAGDATALOCATIONPROC)load("glGetFragDataLocation"); 1815 | glad_glUniform1ui = (PFNGLUNIFORM1UIPROC)load("glUniform1ui"); 1816 | glad_glUniform2ui = (PFNGLUNIFORM2UIPROC)load("glUniform2ui"); 1817 | glad_glUniform3ui = (PFNGLUNIFORM3UIPROC)load("glUniform3ui"); 1818 | glad_glUniform4ui = (PFNGLUNIFORM4UIPROC)load("glUniform4ui"); 1819 | glad_glUniform1uiv = (PFNGLUNIFORM1UIVPROC)load("glUniform1uiv"); 1820 | glad_glUniform2uiv = (PFNGLUNIFORM2UIVPROC)load("glUniform2uiv"); 1821 | glad_glUniform3uiv = (PFNGLUNIFORM3UIVPROC)load("glUniform3uiv"); 1822 | glad_glUniform4uiv = (PFNGLUNIFORM4UIVPROC)load("glUniform4uiv"); 1823 | glad_glTexParameterIiv = (PFNGLTEXPARAMETERIIVPROC)load("glTexParameterIiv"); 1824 | glad_glTexParameterIuiv = (PFNGLTEXPARAMETERIUIVPROC)load("glTexParameterIuiv"); 1825 | glad_glGetTexParameterIiv = (PFNGLGETTEXPARAMETERIIVPROC)load("glGetTexParameterIiv"); 1826 | glad_glGetTexParameterIuiv = (PFNGLGETTEXPARAMETERIUIVPROC)load("glGetTexParameterIuiv"); 1827 | glad_glClearBufferiv = (PFNGLCLEARBUFFERIVPROC)load("glClearBufferiv"); 1828 | glad_glClearBufferuiv = (PFNGLCLEARBUFFERUIVPROC)load("glClearBufferuiv"); 1829 | glad_glClearBufferfv = (PFNGLCLEARBUFFERFVPROC)load("glClearBufferfv"); 1830 | glad_glClearBufferfi = (PFNGLCLEARBUFFERFIPROC)load("glClearBufferfi"); 1831 | glad_glGetStringi = (PFNGLGETSTRINGIPROC)load("glGetStringi"); 1832 | glad_glIsRenderbuffer = (PFNGLISRENDERBUFFERPROC)load("glIsRenderbuffer"); 1833 | glad_glBindRenderbuffer = (PFNGLBINDRENDERBUFFERPROC)load("glBindRenderbuffer"); 1834 | glad_glDeleteRenderbuffers = (PFNGLDELETERENDERBUFFERSPROC)load("glDeleteRenderbuffers"); 1835 | glad_glGenRenderbuffers = (PFNGLGENRENDERBUFFERSPROC)load("glGenRenderbuffers"); 1836 | glad_glRenderbufferStorage = (PFNGLRENDERBUFFERSTORAGEPROC)load("glRenderbufferStorage"); 1837 | glad_glGetRenderbufferParameteriv = (PFNGLGETRENDERBUFFERPARAMETERIVPROC)load("glGetRenderbufferParameteriv"); 1838 | glad_glIsFramebuffer = (PFNGLISFRAMEBUFFERPROC)load("glIsFramebuffer"); 1839 | glad_glBindFramebuffer = (PFNGLBINDFRAMEBUFFERPROC)load("glBindFramebuffer"); 1840 | glad_glDeleteFramebuffers = (PFNGLDELETEFRAMEBUFFERSPROC)load("glDeleteFramebuffers"); 1841 | glad_glGenFramebuffers = (PFNGLGENFRAMEBUFFERSPROC)load("glGenFramebuffers"); 1842 | glad_glCheckFramebufferStatus = (PFNGLCHECKFRAMEBUFFERSTATUSPROC)load("glCheckFramebufferStatus"); 1843 | glad_glFramebufferTexture1D = (PFNGLFRAMEBUFFERTEXTURE1DPROC)load("glFramebufferTexture1D"); 1844 | glad_glFramebufferTexture2D = (PFNGLFRAMEBUFFERTEXTURE2DPROC)load("glFramebufferTexture2D"); 1845 | glad_glFramebufferTexture3D = (PFNGLFRAMEBUFFERTEXTURE3DPROC)load("glFramebufferTexture3D"); 1846 | glad_glFramebufferRenderbuffer = (PFNGLFRAMEBUFFERRENDERBUFFERPROC)load("glFramebufferRenderbuffer"); 1847 | glad_glGetFramebufferAttachmentParameteriv = (PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC)load("glGetFramebufferAttachmentParameteriv"); 1848 | glad_glGenerateMipmap = (PFNGLGENERATEMIPMAPPROC)load("glGenerateMipmap"); 1849 | glad_glBlitFramebuffer = (PFNGLBLITFRAMEBUFFERPROC)load("glBlitFramebuffer"); 1850 | glad_glRenderbufferStorageMultisample = (PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC)load("glRenderbufferStorageMultisample"); 1851 | glad_glFramebufferTextureLayer = (PFNGLFRAMEBUFFERTEXTURELAYERPROC)load("glFramebufferTextureLayer"); 1852 | glad_glMapBufferRange = (PFNGLMAPBUFFERRANGEPROC)load("glMapBufferRange"); 1853 | glad_glFlushMappedBufferRange = (PFNGLFLUSHMAPPEDBUFFERRANGEPROC)load("glFlushMappedBufferRange"); 1854 | glad_glBindVertexArray = (PFNGLBINDVERTEXARRAYPROC)load("glBindVertexArray"); 1855 | glad_glDeleteVertexArrays = (PFNGLDELETEVERTEXARRAYSPROC)load("glDeleteVertexArrays"); 1856 | glad_glGenVertexArrays = (PFNGLGENVERTEXARRAYSPROC)load("glGenVertexArrays"); 1857 | glad_glIsVertexArray = (PFNGLISVERTEXARRAYPROC)load("glIsVertexArray"); 1858 | } 1859 | static void load_GL_VERSION_3_1(GLADloadproc load) { 1860 | if(!GLAD_GL_VERSION_3_1) return; 1861 | glad_glDrawArraysInstanced = (PFNGLDRAWARRAYSINSTANCEDPROC)load("glDrawArraysInstanced"); 1862 | glad_glDrawElementsInstanced = (PFNGLDRAWELEMENTSINSTANCEDPROC)load("glDrawElementsInstanced"); 1863 | glad_glTexBuffer = (PFNGLTEXBUFFERPROC)load("glTexBuffer"); 1864 | glad_glPrimitiveRestartIndex = (PFNGLPRIMITIVERESTARTINDEXPROC)load("glPrimitiveRestartIndex"); 1865 | glad_glCopyBufferSubData = (PFNGLCOPYBUFFERSUBDATAPROC)load("glCopyBufferSubData"); 1866 | glad_glGetUniformIndices = (PFNGLGETUNIFORMINDICESPROC)load("glGetUniformIndices"); 1867 | glad_glGetActiveUniformsiv = (PFNGLGETACTIVEUNIFORMSIVPROC)load("glGetActiveUniformsiv"); 1868 | glad_glGetActiveUniformName = (PFNGLGETACTIVEUNIFORMNAMEPROC)load("glGetActiveUniformName"); 1869 | glad_glGetUniformBlockIndex = (PFNGLGETUNIFORMBLOCKINDEXPROC)load("glGetUniformBlockIndex"); 1870 | glad_glGetActiveUniformBlockiv = (PFNGLGETACTIVEUNIFORMBLOCKIVPROC)load("glGetActiveUniformBlockiv"); 1871 | glad_glGetActiveUniformBlockName = (PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC)load("glGetActiveUniformBlockName"); 1872 | glad_glUniformBlockBinding = (PFNGLUNIFORMBLOCKBINDINGPROC)load("glUniformBlockBinding"); 1873 | glad_glBindBufferRange = (PFNGLBINDBUFFERRANGEPROC)load("glBindBufferRange"); 1874 | glad_glBindBufferBase = (PFNGLBINDBUFFERBASEPROC)load("glBindBufferBase"); 1875 | glad_glGetIntegeri_v = (PFNGLGETINTEGERI_VPROC)load("glGetIntegeri_v"); 1876 | } 1877 | static void load_GL_VERSION_3_2(GLADloadproc load) { 1878 | if(!GLAD_GL_VERSION_3_2) return; 1879 | glad_glDrawElementsBaseVertex = (PFNGLDRAWELEMENTSBASEVERTEXPROC)load("glDrawElementsBaseVertex"); 1880 | glad_glDrawRangeElementsBaseVertex = (PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC)load("glDrawRangeElementsBaseVertex"); 1881 | glad_glDrawElementsInstancedBaseVertex = (PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC)load("glDrawElementsInstancedBaseVertex"); 1882 | glad_glMultiDrawElementsBaseVertex = (PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC)load("glMultiDrawElementsBaseVertex"); 1883 | glad_glProvokingVertex = (PFNGLPROVOKINGVERTEXPROC)load("glProvokingVertex"); 1884 | glad_glFenceSync = (PFNGLFENCESYNCPROC)load("glFenceSync"); 1885 | glad_glIsSync = (PFNGLISSYNCPROC)load("glIsSync"); 1886 | glad_glDeleteSync = (PFNGLDELETESYNCPROC)load("glDeleteSync"); 1887 | glad_glClientWaitSync = (PFNGLCLIENTWAITSYNCPROC)load("glClientWaitSync"); 1888 | glad_glWaitSync = (PFNGLWAITSYNCPROC)load("glWaitSync"); 1889 | glad_glGetInteger64v = (PFNGLGETINTEGER64VPROC)load("glGetInteger64v"); 1890 | glad_glGetSynciv = (PFNGLGETSYNCIVPROC)load("glGetSynciv"); 1891 | glad_glGetInteger64i_v = (PFNGLGETINTEGER64I_VPROC)load("glGetInteger64i_v"); 1892 | glad_glGetBufferParameteri64v = (PFNGLGETBUFFERPARAMETERI64VPROC)load("glGetBufferParameteri64v"); 1893 | glad_glFramebufferTexture = (PFNGLFRAMEBUFFERTEXTUREPROC)load("glFramebufferTexture"); 1894 | glad_glTexImage2DMultisample = (PFNGLTEXIMAGE2DMULTISAMPLEPROC)load("glTexImage2DMultisample"); 1895 | glad_glTexImage3DMultisample = (PFNGLTEXIMAGE3DMULTISAMPLEPROC)load("glTexImage3DMultisample"); 1896 | glad_glGetMultisamplefv = (PFNGLGETMULTISAMPLEFVPROC)load("glGetMultisamplefv"); 1897 | glad_glSampleMaski = (PFNGLSAMPLEMASKIPROC)load("glSampleMaski"); 1898 | } 1899 | static void load_GL_VERSION_3_3(GLADloadproc load) { 1900 | if(!GLAD_GL_VERSION_3_3) return; 1901 | glad_glBindFragDataLocationIndexed = (PFNGLBINDFRAGDATALOCATIONINDEXEDPROC)load("glBindFragDataLocationIndexed"); 1902 | glad_glGetFragDataIndex = (PFNGLGETFRAGDATAINDEXPROC)load("glGetFragDataIndex"); 1903 | glad_glGenSamplers = (PFNGLGENSAMPLERSPROC)load("glGenSamplers"); 1904 | glad_glDeleteSamplers = (PFNGLDELETESAMPLERSPROC)load("glDeleteSamplers"); 1905 | glad_glIsSampler = (PFNGLISSAMPLERPROC)load("glIsSampler"); 1906 | glad_glBindSampler = (PFNGLBINDSAMPLERPROC)load("glBindSampler"); 1907 | glad_glSamplerParameteri = (PFNGLSAMPLERPARAMETERIPROC)load("glSamplerParameteri"); 1908 | glad_glSamplerParameteriv = (PFNGLSAMPLERPARAMETERIVPROC)load("glSamplerParameteriv"); 1909 | glad_glSamplerParameterf = (PFNGLSAMPLERPARAMETERFPROC)load("glSamplerParameterf"); 1910 | glad_glSamplerParameterfv = (PFNGLSAMPLERPARAMETERFVPROC)load("glSamplerParameterfv"); 1911 | glad_glSamplerParameterIiv = (PFNGLSAMPLERPARAMETERIIVPROC)load("glSamplerParameterIiv"); 1912 | glad_glSamplerParameterIuiv = (PFNGLSAMPLERPARAMETERIUIVPROC)load("glSamplerParameterIuiv"); 1913 | glad_glGetSamplerParameteriv = (PFNGLGETSAMPLERPARAMETERIVPROC)load("glGetSamplerParameteriv"); 1914 | glad_glGetSamplerParameterIiv = (PFNGLGETSAMPLERPARAMETERIIVPROC)load("glGetSamplerParameterIiv"); 1915 | glad_glGetSamplerParameterfv = (PFNGLGETSAMPLERPARAMETERFVPROC)load("glGetSamplerParameterfv"); 1916 | glad_glGetSamplerParameterIuiv = (PFNGLGETSAMPLERPARAMETERIUIVPROC)load("glGetSamplerParameterIuiv"); 1917 | glad_glQueryCounter = (PFNGLQUERYCOUNTERPROC)load("glQueryCounter"); 1918 | glad_glGetQueryObjecti64v = (PFNGLGETQUERYOBJECTI64VPROC)load("glGetQueryObjecti64v"); 1919 | glad_glGetQueryObjectui64v = (PFNGLGETQUERYOBJECTUI64VPROC)load("glGetQueryObjectui64v"); 1920 | glad_glVertexAttribDivisor = (PFNGLVERTEXATTRIBDIVISORPROC)load("glVertexAttribDivisor"); 1921 | glad_glVertexAttribP1ui = (PFNGLVERTEXATTRIBP1UIPROC)load("glVertexAttribP1ui"); 1922 | glad_glVertexAttribP1uiv = (PFNGLVERTEXATTRIBP1UIVPROC)load("glVertexAttribP1uiv"); 1923 | glad_glVertexAttribP2ui = (PFNGLVERTEXATTRIBP2UIPROC)load("glVertexAttribP2ui"); 1924 | glad_glVertexAttribP2uiv = (PFNGLVERTEXATTRIBP2UIVPROC)load("glVertexAttribP2uiv"); 1925 | glad_glVertexAttribP3ui = (PFNGLVERTEXATTRIBP3UIPROC)load("glVertexAttribP3ui"); 1926 | glad_glVertexAttribP3uiv = (PFNGLVERTEXATTRIBP3UIVPROC)load("glVertexAttribP3uiv"); 1927 | glad_glVertexAttribP4ui = (PFNGLVERTEXATTRIBP4UIPROC)load("glVertexAttribP4ui"); 1928 | glad_glVertexAttribP4uiv = (PFNGLVERTEXATTRIBP4UIVPROC)load("glVertexAttribP4uiv"); 1929 | glad_glVertexP2ui = (PFNGLVERTEXP2UIPROC)load("glVertexP2ui"); 1930 | glad_glVertexP2uiv = (PFNGLVERTEXP2UIVPROC)load("glVertexP2uiv"); 1931 | glad_glVertexP3ui = (PFNGLVERTEXP3UIPROC)load("glVertexP3ui"); 1932 | glad_glVertexP3uiv = (PFNGLVERTEXP3UIVPROC)load("glVertexP3uiv"); 1933 | glad_glVertexP4ui = (PFNGLVERTEXP4UIPROC)load("glVertexP4ui"); 1934 | glad_glVertexP4uiv = (PFNGLVERTEXP4UIVPROC)load("glVertexP4uiv"); 1935 | glad_glTexCoordP1ui = (PFNGLTEXCOORDP1UIPROC)load("glTexCoordP1ui"); 1936 | glad_glTexCoordP1uiv = (PFNGLTEXCOORDP1UIVPROC)load("glTexCoordP1uiv"); 1937 | glad_glTexCoordP2ui = (PFNGLTEXCOORDP2UIPROC)load("glTexCoordP2ui"); 1938 | glad_glTexCoordP2uiv = (PFNGLTEXCOORDP2UIVPROC)load("glTexCoordP2uiv"); 1939 | glad_glTexCoordP3ui = (PFNGLTEXCOORDP3UIPROC)load("glTexCoordP3ui"); 1940 | glad_glTexCoordP3uiv = (PFNGLTEXCOORDP3UIVPROC)load("glTexCoordP3uiv"); 1941 | glad_glTexCoordP4ui = (PFNGLTEXCOORDP4UIPROC)load("glTexCoordP4ui"); 1942 | glad_glTexCoordP4uiv = (PFNGLTEXCOORDP4UIVPROC)load("glTexCoordP4uiv"); 1943 | glad_glMultiTexCoordP1ui = (PFNGLMULTITEXCOORDP1UIPROC)load("glMultiTexCoordP1ui"); 1944 | glad_glMultiTexCoordP1uiv = (PFNGLMULTITEXCOORDP1UIVPROC)load("glMultiTexCoordP1uiv"); 1945 | glad_glMultiTexCoordP2ui = (PFNGLMULTITEXCOORDP2UIPROC)load("glMultiTexCoordP2ui"); 1946 | glad_glMultiTexCoordP2uiv = (PFNGLMULTITEXCOORDP2UIVPROC)load("glMultiTexCoordP2uiv"); 1947 | glad_glMultiTexCoordP3ui = (PFNGLMULTITEXCOORDP3UIPROC)load("glMultiTexCoordP3ui"); 1948 | glad_glMultiTexCoordP3uiv = (PFNGLMULTITEXCOORDP3UIVPROC)load("glMultiTexCoordP3uiv"); 1949 | glad_glMultiTexCoordP4ui = (PFNGLMULTITEXCOORDP4UIPROC)load("glMultiTexCoordP4ui"); 1950 | glad_glMultiTexCoordP4uiv = (PFNGLMULTITEXCOORDP4UIVPROC)load("glMultiTexCoordP4uiv"); 1951 | glad_glNormalP3ui = (PFNGLNORMALP3UIPROC)load("glNormalP3ui"); 1952 | glad_glNormalP3uiv = (PFNGLNORMALP3UIVPROC)load("glNormalP3uiv"); 1953 | glad_glColorP3ui = (PFNGLCOLORP3UIPROC)load("glColorP3ui"); 1954 | glad_glColorP3uiv = (PFNGLCOLORP3UIVPROC)load("glColorP3uiv"); 1955 | glad_glColorP4ui = (PFNGLCOLORP4UIPROC)load("glColorP4ui"); 1956 | glad_glColorP4uiv = (PFNGLCOLORP4UIVPROC)load("glColorP4uiv"); 1957 | glad_glSecondaryColorP3ui = (PFNGLSECONDARYCOLORP3UIPROC)load("glSecondaryColorP3ui"); 1958 | glad_glSecondaryColorP3uiv = (PFNGLSECONDARYCOLORP3UIVPROC)load("glSecondaryColorP3uiv"); 1959 | } 1960 | static void load_GL_VERSION_4_0(GLADloadproc load) { 1961 | if(!GLAD_GL_VERSION_4_0) return; 1962 | glad_glMinSampleShading = (PFNGLMINSAMPLESHADINGPROC)load("glMinSampleShading"); 1963 | glad_glBlendEquationi = (PFNGLBLENDEQUATIONIPROC)load("glBlendEquationi"); 1964 | glad_glBlendEquationSeparatei = (PFNGLBLENDEQUATIONSEPARATEIPROC)load("glBlendEquationSeparatei"); 1965 | glad_glBlendFunci = (PFNGLBLENDFUNCIPROC)load("glBlendFunci"); 1966 | glad_glBlendFuncSeparatei = (PFNGLBLENDFUNCSEPARATEIPROC)load("glBlendFuncSeparatei"); 1967 | glad_glDrawArraysIndirect = (PFNGLDRAWARRAYSINDIRECTPROC)load("glDrawArraysIndirect"); 1968 | glad_glDrawElementsIndirect = (PFNGLDRAWELEMENTSINDIRECTPROC)load("glDrawElementsIndirect"); 1969 | glad_glUniform1d = (PFNGLUNIFORM1DPROC)load("glUniform1d"); 1970 | glad_glUniform2d = (PFNGLUNIFORM2DPROC)load("glUniform2d"); 1971 | glad_glUniform3d = (PFNGLUNIFORM3DPROC)load("glUniform3d"); 1972 | glad_glUniform4d = (PFNGLUNIFORM4DPROC)load("glUniform4d"); 1973 | glad_glUniform1dv = (PFNGLUNIFORM1DVPROC)load("glUniform1dv"); 1974 | glad_glUniform2dv = (PFNGLUNIFORM2DVPROC)load("glUniform2dv"); 1975 | glad_glUniform3dv = (PFNGLUNIFORM3DVPROC)load("glUniform3dv"); 1976 | glad_glUniform4dv = (PFNGLUNIFORM4DVPROC)load("glUniform4dv"); 1977 | glad_glUniformMatrix2dv = (PFNGLUNIFORMMATRIX2DVPROC)load("glUniformMatrix2dv"); 1978 | glad_glUniformMatrix3dv = (PFNGLUNIFORMMATRIX3DVPROC)load("glUniformMatrix3dv"); 1979 | glad_glUniformMatrix4dv = (PFNGLUNIFORMMATRIX4DVPROC)load("glUniformMatrix4dv"); 1980 | glad_glUniformMatrix2x3dv = (PFNGLUNIFORMMATRIX2X3DVPROC)load("glUniformMatrix2x3dv"); 1981 | glad_glUniformMatrix2x4dv = (PFNGLUNIFORMMATRIX2X4DVPROC)load("glUniformMatrix2x4dv"); 1982 | glad_glUniformMatrix3x2dv = (PFNGLUNIFORMMATRIX3X2DVPROC)load("glUniformMatrix3x2dv"); 1983 | glad_glUniformMatrix3x4dv = (PFNGLUNIFORMMATRIX3X4DVPROC)load("glUniformMatrix3x4dv"); 1984 | glad_glUniformMatrix4x2dv = (PFNGLUNIFORMMATRIX4X2DVPROC)load("glUniformMatrix4x2dv"); 1985 | glad_glUniformMatrix4x3dv = (PFNGLUNIFORMMATRIX4X3DVPROC)load("glUniformMatrix4x3dv"); 1986 | glad_glGetUniformdv = (PFNGLGETUNIFORMDVPROC)load("glGetUniformdv"); 1987 | glad_glGetSubroutineUniformLocation = (PFNGLGETSUBROUTINEUNIFORMLOCATIONPROC)load("glGetSubroutineUniformLocation"); 1988 | glad_glGetSubroutineIndex = (PFNGLGETSUBROUTINEINDEXPROC)load("glGetSubroutineIndex"); 1989 | glad_glGetActiveSubroutineUniformiv = (PFNGLGETACTIVESUBROUTINEUNIFORMIVPROC)load("glGetActiveSubroutineUniformiv"); 1990 | glad_glGetActiveSubroutineUniformName = (PFNGLGETACTIVESUBROUTINEUNIFORMNAMEPROC)load("glGetActiveSubroutineUniformName"); 1991 | glad_glGetActiveSubroutineName = (PFNGLGETACTIVESUBROUTINENAMEPROC)load("glGetActiveSubroutineName"); 1992 | glad_glUniformSubroutinesuiv = (PFNGLUNIFORMSUBROUTINESUIVPROC)load("glUniformSubroutinesuiv"); 1993 | glad_glGetUniformSubroutineuiv = (PFNGLGETUNIFORMSUBROUTINEUIVPROC)load("glGetUniformSubroutineuiv"); 1994 | glad_glGetProgramStageiv = (PFNGLGETPROGRAMSTAGEIVPROC)load("glGetProgramStageiv"); 1995 | glad_glPatchParameteri = (PFNGLPATCHPARAMETERIPROC)load("glPatchParameteri"); 1996 | glad_glPatchParameterfv = (PFNGLPATCHPARAMETERFVPROC)load("glPatchParameterfv"); 1997 | glad_glBindTransformFeedback = (PFNGLBINDTRANSFORMFEEDBACKPROC)load("glBindTransformFeedback"); 1998 | glad_glDeleteTransformFeedbacks = (PFNGLDELETETRANSFORMFEEDBACKSPROC)load("glDeleteTransformFeedbacks"); 1999 | glad_glGenTransformFeedbacks = (PFNGLGENTRANSFORMFEEDBACKSPROC)load("glGenTransformFeedbacks"); 2000 | glad_glIsTransformFeedback = (PFNGLISTRANSFORMFEEDBACKPROC)load("glIsTransformFeedback"); 2001 | glad_glPauseTransformFeedback = (PFNGLPAUSETRANSFORMFEEDBACKPROC)load("glPauseTransformFeedback"); 2002 | glad_glResumeTransformFeedback = (PFNGLRESUMETRANSFORMFEEDBACKPROC)load("glResumeTransformFeedback"); 2003 | glad_glDrawTransformFeedback = (PFNGLDRAWTRANSFORMFEEDBACKPROC)load("glDrawTransformFeedback"); 2004 | glad_glDrawTransformFeedbackStream = (PFNGLDRAWTRANSFORMFEEDBACKSTREAMPROC)load("glDrawTransformFeedbackStream"); 2005 | glad_glBeginQueryIndexed = (PFNGLBEGINQUERYINDEXEDPROC)load("glBeginQueryIndexed"); 2006 | glad_glEndQueryIndexed = (PFNGLENDQUERYINDEXEDPROC)load("glEndQueryIndexed"); 2007 | glad_glGetQueryIndexediv = (PFNGLGETQUERYINDEXEDIVPROC)load("glGetQueryIndexediv"); 2008 | } 2009 | static void load_GL_VERSION_4_1(GLADloadproc load) { 2010 | if(!GLAD_GL_VERSION_4_1) return; 2011 | glad_glReleaseShaderCompiler = (PFNGLRELEASESHADERCOMPILERPROC)load("glReleaseShaderCompiler"); 2012 | glad_glShaderBinary = (PFNGLSHADERBINARYPROC)load("glShaderBinary"); 2013 | glad_glGetShaderPrecisionFormat = (PFNGLGETSHADERPRECISIONFORMATPROC)load("glGetShaderPrecisionFormat"); 2014 | glad_glDepthRangef = (PFNGLDEPTHRANGEFPROC)load("glDepthRangef"); 2015 | glad_glClearDepthf = (PFNGLCLEARDEPTHFPROC)load("glClearDepthf"); 2016 | glad_glGetProgramBinary = (PFNGLGETPROGRAMBINARYPROC)load("glGetProgramBinary"); 2017 | glad_glProgramBinary = (PFNGLPROGRAMBINARYPROC)load("glProgramBinary"); 2018 | glad_glProgramParameteri = (PFNGLPROGRAMPARAMETERIPROC)load("glProgramParameteri"); 2019 | glad_glUseProgramStages = (PFNGLUSEPROGRAMSTAGESPROC)load("glUseProgramStages"); 2020 | glad_glActiveShaderProgram = (PFNGLACTIVESHADERPROGRAMPROC)load("glActiveShaderProgram"); 2021 | glad_glCreateShaderProgramv = (PFNGLCREATESHADERPROGRAMVPROC)load("glCreateShaderProgramv"); 2022 | glad_glBindProgramPipeline = (PFNGLBINDPROGRAMPIPELINEPROC)load("glBindProgramPipeline"); 2023 | glad_glDeleteProgramPipelines = (PFNGLDELETEPROGRAMPIPELINESPROC)load("glDeleteProgramPipelines"); 2024 | glad_glGenProgramPipelines = (PFNGLGENPROGRAMPIPELINESPROC)load("glGenProgramPipelines"); 2025 | glad_glIsProgramPipeline = (PFNGLISPROGRAMPIPELINEPROC)load("glIsProgramPipeline"); 2026 | glad_glGetProgramPipelineiv = (PFNGLGETPROGRAMPIPELINEIVPROC)load("glGetProgramPipelineiv"); 2027 | glad_glProgramParameteri = (PFNGLPROGRAMPARAMETERIPROC)load("glProgramParameteri"); 2028 | glad_glProgramUniform1i = (PFNGLPROGRAMUNIFORM1IPROC)load("glProgramUniform1i"); 2029 | glad_glProgramUniform1iv = (PFNGLPROGRAMUNIFORM1IVPROC)load("glProgramUniform1iv"); 2030 | glad_glProgramUniform1f = (PFNGLPROGRAMUNIFORM1FPROC)load("glProgramUniform1f"); 2031 | glad_glProgramUniform1fv = (PFNGLPROGRAMUNIFORM1FVPROC)load("glProgramUniform1fv"); 2032 | glad_glProgramUniform1d = (PFNGLPROGRAMUNIFORM1DPROC)load("glProgramUniform1d"); 2033 | glad_glProgramUniform1dv = (PFNGLPROGRAMUNIFORM1DVPROC)load("glProgramUniform1dv"); 2034 | glad_glProgramUniform1ui = (PFNGLPROGRAMUNIFORM1UIPROC)load("glProgramUniform1ui"); 2035 | glad_glProgramUniform1uiv = (PFNGLPROGRAMUNIFORM1UIVPROC)load("glProgramUniform1uiv"); 2036 | glad_glProgramUniform2i = (PFNGLPROGRAMUNIFORM2IPROC)load("glProgramUniform2i"); 2037 | glad_glProgramUniform2iv = (PFNGLPROGRAMUNIFORM2IVPROC)load("glProgramUniform2iv"); 2038 | glad_glProgramUniform2f = (PFNGLPROGRAMUNIFORM2FPROC)load("glProgramUniform2f"); 2039 | glad_glProgramUniform2fv = (PFNGLPROGRAMUNIFORM2FVPROC)load("glProgramUniform2fv"); 2040 | glad_glProgramUniform2d = (PFNGLPROGRAMUNIFORM2DPROC)load("glProgramUniform2d"); 2041 | glad_glProgramUniform2dv = (PFNGLPROGRAMUNIFORM2DVPROC)load("glProgramUniform2dv"); 2042 | glad_glProgramUniform2ui = (PFNGLPROGRAMUNIFORM2UIPROC)load("glProgramUniform2ui"); 2043 | glad_glProgramUniform2uiv = (PFNGLPROGRAMUNIFORM2UIVPROC)load("glProgramUniform2uiv"); 2044 | glad_glProgramUniform3i = (PFNGLPROGRAMUNIFORM3IPROC)load("glProgramUniform3i"); 2045 | glad_glProgramUniform3iv = (PFNGLPROGRAMUNIFORM3IVPROC)load("glProgramUniform3iv"); 2046 | glad_glProgramUniform3f = (PFNGLPROGRAMUNIFORM3FPROC)load("glProgramUniform3f"); 2047 | glad_glProgramUniform3fv = (PFNGLPROGRAMUNIFORM3FVPROC)load("glProgramUniform3fv"); 2048 | glad_glProgramUniform3d = (PFNGLPROGRAMUNIFORM3DPROC)load("glProgramUniform3d"); 2049 | glad_glProgramUniform3dv = (PFNGLPROGRAMUNIFORM3DVPROC)load("glProgramUniform3dv"); 2050 | glad_glProgramUniform3ui = (PFNGLPROGRAMUNIFORM3UIPROC)load("glProgramUniform3ui"); 2051 | glad_glProgramUniform3uiv = (PFNGLPROGRAMUNIFORM3UIVPROC)load("glProgramUniform3uiv"); 2052 | glad_glProgramUniform4i = (PFNGLPROGRAMUNIFORM4IPROC)load("glProgramUniform4i"); 2053 | glad_glProgramUniform4iv = (PFNGLPROGRAMUNIFORM4IVPROC)load("glProgramUniform4iv"); 2054 | glad_glProgramUniform4f = (PFNGLPROGRAMUNIFORM4FPROC)load("glProgramUniform4f"); 2055 | glad_glProgramUniform4fv = (PFNGLPROGRAMUNIFORM4FVPROC)load("glProgramUniform4fv"); 2056 | glad_glProgramUniform4d = (PFNGLPROGRAMUNIFORM4DPROC)load("glProgramUniform4d"); 2057 | glad_glProgramUniform4dv = (PFNGLPROGRAMUNIFORM4DVPROC)load("glProgramUniform4dv"); 2058 | glad_glProgramUniform4ui = (PFNGLPROGRAMUNIFORM4UIPROC)load("glProgramUniform4ui"); 2059 | glad_glProgramUniform4uiv = (PFNGLPROGRAMUNIFORM4UIVPROC)load("glProgramUniform4uiv"); 2060 | glad_glProgramUniformMatrix2fv = (PFNGLPROGRAMUNIFORMMATRIX2FVPROC)load("glProgramUniformMatrix2fv"); 2061 | glad_glProgramUniformMatrix3fv = (PFNGLPROGRAMUNIFORMMATRIX3FVPROC)load("glProgramUniformMatrix3fv"); 2062 | glad_glProgramUniformMatrix4fv = (PFNGLPROGRAMUNIFORMMATRIX4FVPROC)load("glProgramUniformMatrix4fv"); 2063 | glad_glProgramUniformMatrix2dv = (PFNGLPROGRAMUNIFORMMATRIX2DVPROC)load("glProgramUniformMatrix2dv"); 2064 | glad_glProgramUniformMatrix3dv = (PFNGLPROGRAMUNIFORMMATRIX3DVPROC)load("glProgramUniformMatrix3dv"); 2065 | glad_glProgramUniformMatrix4dv = (PFNGLPROGRAMUNIFORMMATRIX4DVPROC)load("glProgramUniformMatrix4dv"); 2066 | glad_glProgramUniformMatrix2x3fv = (PFNGLPROGRAMUNIFORMMATRIX2X3FVPROC)load("glProgramUniformMatrix2x3fv"); 2067 | glad_glProgramUniformMatrix3x2fv = (PFNGLPROGRAMUNIFORMMATRIX3X2FVPROC)load("glProgramUniformMatrix3x2fv"); 2068 | glad_glProgramUniformMatrix2x4fv = (PFNGLPROGRAMUNIFORMMATRIX2X4FVPROC)load("glProgramUniformMatrix2x4fv"); 2069 | glad_glProgramUniformMatrix4x2fv = (PFNGLPROGRAMUNIFORMMATRIX4X2FVPROC)load("glProgramUniformMatrix4x2fv"); 2070 | glad_glProgramUniformMatrix3x4fv = (PFNGLPROGRAMUNIFORMMATRIX3X4FVPROC)load("glProgramUniformMatrix3x4fv"); 2071 | glad_glProgramUniformMatrix4x3fv = (PFNGLPROGRAMUNIFORMMATRIX4X3FVPROC)load("glProgramUniformMatrix4x3fv"); 2072 | glad_glProgramUniformMatrix2x3dv = (PFNGLPROGRAMUNIFORMMATRIX2X3DVPROC)load("glProgramUniformMatrix2x3dv"); 2073 | glad_glProgramUniformMatrix3x2dv = (PFNGLPROGRAMUNIFORMMATRIX3X2DVPROC)load("glProgramUniformMatrix3x2dv"); 2074 | glad_glProgramUniformMatrix2x4dv = (PFNGLPROGRAMUNIFORMMATRIX2X4DVPROC)load("glProgramUniformMatrix2x4dv"); 2075 | glad_glProgramUniformMatrix4x2dv = (PFNGLPROGRAMUNIFORMMATRIX4X2DVPROC)load("glProgramUniformMatrix4x2dv"); 2076 | glad_glProgramUniformMatrix3x4dv = (PFNGLPROGRAMUNIFORMMATRIX3X4DVPROC)load("glProgramUniformMatrix3x4dv"); 2077 | glad_glProgramUniformMatrix4x3dv = (PFNGLPROGRAMUNIFORMMATRIX4X3DVPROC)load("glProgramUniformMatrix4x3dv"); 2078 | glad_glValidateProgramPipeline = (PFNGLVALIDATEPROGRAMPIPELINEPROC)load("glValidateProgramPipeline"); 2079 | glad_glGetProgramPipelineInfoLog = (PFNGLGETPROGRAMPIPELINEINFOLOGPROC)load("glGetProgramPipelineInfoLog"); 2080 | glad_glVertexAttribL1d = (PFNGLVERTEXATTRIBL1DPROC)load("glVertexAttribL1d"); 2081 | glad_glVertexAttribL2d = (PFNGLVERTEXATTRIBL2DPROC)load("glVertexAttribL2d"); 2082 | glad_glVertexAttribL3d = (PFNGLVERTEXATTRIBL3DPROC)load("glVertexAttribL3d"); 2083 | glad_glVertexAttribL4d = (PFNGLVERTEXATTRIBL4DPROC)load("glVertexAttribL4d"); 2084 | glad_glVertexAttribL1dv = (PFNGLVERTEXATTRIBL1DVPROC)load("glVertexAttribL1dv"); 2085 | glad_glVertexAttribL2dv = (PFNGLVERTEXATTRIBL2DVPROC)load("glVertexAttribL2dv"); 2086 | glad_glVertexAttribL3dv = (PFNGLVERTEXATTRIBL3DVPROC)load("glVertexAttribL3dv"); 2087 | glad_glVertexAttribL4dv = (PFNGLVERTEXATTRIBL4DVPROC)load("glVertexAttribL4dv"); 2088 | glad_glVertexAttribLPointer = (PFNGLVERTEXATTRIBLPOINTERPROC)load("glVertexAttribLPointer"); 2089 | glad_glGetVertexAttribLdv = (PFNGLGETVERTEXATTRIBLDVPROC)load("glGetVertexAttribLdv"); 2090 | glad_glViewportArrayv = (PFNGLVIEWPORTARRAYVPROC)load("glViewportArrayv"); 2091 | glad_glViewportIndexedf = (PFNGLVIEWPORTINDEXEDFPROC)load("glViewportIndexedf"); 2092 | glad_glViewportIndexedfv = (PFNGLVIEWPORTINDEXEDFVPROC)load("glViewportIndexedfv"); 2093 | glad_glScissorArrayv = (PFNGLSCISSORARRAYVPROC)load("glScissorArrayv"); 2094 | glad_glScissorIndexed = (PFNGLSCISSORINDEXEDPROC)load("glScissorIndexed"); 2095 | glad_glScissorIndexedv = (PFNGLSCISSORINDEXEDVPROC)load("glScissorIndexedv"); 2096 | glad_glDepthRangeArrayv = (PFNGLDEPTHRANGEARRAYVPROC)load("glDepthRangeArrayv"); 2097 | glad_glDepthRangeIndexed = (PFNGLDEPTHRANGEINDEXEDPROC)load("glDepthRangeIndexed"); 2098 | glad_glGetFloati_v = (PFNGLGETFLOATI_VPROC)load("glGetFloati_v"); 2099 | glad_glGetDoublei_v = (PFNGLGETDOUBLEI_VPROC)load("glGetDoublei_v"); 2100 | } 2101 | static void load_GL_VERSION_4_2(GLADloadproc load) { 2102 | if(!GLAD_GL_VERSION_4_2) return; 2103 | glad_glDrawArraysInstancedBaseInstance = (PFNGLDRAWARRAYSINSTANCEDBASEINSTANCEPROC)load("glDrawArraysInstancedBaseInstance"); 2104 | glad_glDrawElementsInstancedBaseInstance = (PFNGLDRAWELEMENTSINSTANCEDBASEINSTANCEPROC)load("glDrawElementsInstancedBaseInstance"); 2105 | glad_glDrawElementsInstancedBaseVertexBaseInstance = (PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCEPROC)load("glDrawElementsInstancedBaseVertexBaseInstance"); 2106 | glad_glGetInternalformativ = (PFNGLGETINTERNALFORMATIVPROC)load("glGetInternalformativ"); 2107 | glad_glGetActiveAtomicCounterBufferiv = (PFNGLGETACTIVEATOMICCOUNTERBUFFERIVPROC)load("glGetActiveAtomicCounterBufferiv"); 2108 | glad_glBindImageTexture = (PFNGLBINDIMAGETEXTUREPROC)load("glBindImageTexture"); 2109 | glad_glMemoryBarrier = (PFNGLMEMORYBARRIERPROC)load("glMemoryBarrier"); 2110 | glad_glTexStorage1D = (PFNGLTEXSTORAGE1DPROC)load("glTexStorage1D"); 2111 | glad_glTexStorage2D = (PFNGLTEXSTORAGE2DPROC)load("glTexStorage2D"); 2112 | glad_glTexStorage3D = (PFNGLTEXSTORAGE3DPROC)load("glTexStorage3D"); 2113 | glad_glDrawTransformFeedbackInstanced = (PFNGLDRAWTRANSFORMFEEDBACKINSTANCEDPROC)load("glDrawTransformFeedbackInstanced"); 2114 | glad_glDrawTransformFeedbackStreamInstanced = (PFNGLDRAWTRANSFORMFEEDBACKSTREAMINSTANCEDPROC)load("glDrawTransformFeedbackStreamInstanced"); 2115 | } 2116 | static void load_GL_VERSION_4_3(GLADloadproc load) { 2117 | if(!GLAD_GL_VERSION_4_3) return; 2118 | glad_glClearBufferData = (PFNGLCLEARBUFFERDATAPROC)load("glClearBufferData"); 2119 | glad_glClearBufferSubData = (PFNGLCLEARBUFFERSUBDATAPROC)load("glClearBufferSubData"); 2120 | glad_glDispatchCompute = (PFNGLDISPATCHCOMPUTEPROC)load("glDispatchCompute"); 2121 | glad_glDispatchComputeIndirect = (PFNGLDISPATCHCOMPUTEINDIRECTPROC)load("glDispatchComputeIndirect"); 2122 | glad_glCopyImageSubData = (PFNGLCOPYIMAGESUBDATAPROC)load("glCopyImageSubData"); 2123 | glad_glFramebufferParameteri = (PFNGLFRAMEBUFFERPARAMETERIPROC)load("glFramebufferParameteri"); 2124 | glad_glGetFramebufferParameteriv = (PFNGLGETFRAMEBUFFERPARAMETERIVPROC)load("glGetFramebufferParameteriv"); 2125 | glad_glGetInternalformati64v = (PFNGLGETINTERNALFORMATI64VPROC)load("glGetInternalformati64v"); 2126 | glad_glInvalidateTexSubImage = (PFNGLINVALIDATETEXSUBIMAGEPROC)load("glInvalidateTexSubImage"); 2127 | glad_glInvalidateTexImage = (PFNGLINVALIDATETEXIMAGEPROC)load("glInvalidateTexImage"); 2128 | glad_glInvalidateBufferSubData = (PFNGLINVALIDATEBUFFERSUBDATAPROC)load("glInvalidateBufferSubData"); 2129 | glad_glInvalidateBufferData = (PFNGLINVALIDATEBUFFERDATAPROC)load("glInvalidateBufferData"); 2130 | glad_glInvalidateFramebuffer = (PFNGLINVALIDATEFRAMEBUFFERPROC)load("glInvalidateFramebuffer"); 2131 | glad_glInvalidateSubFramebuffer = (PFNGLINVALIDATESUBFRAMEBUFFERPROC)load("glInvalidateSubFramebuffer"); 2132 | glad_glMultiDrawArraysIndirect = (PFNGLMULTIDRAWARRAYSINDIRECTPROC)load("glMultiDrawArraysIndirect"); 2133 | glad_glMultiDrawElementsIndirect = (PFNGLMULTIDRAWELEMENTSINDIRECTPROC)load("glMultiDrawElementsIndirect"); 2134 | glad_glGetProgramInterfaceiv = (PFNGLGETPROGRAMINTERFACEIVPROC)load("glGetProgramInterfaceiv"); 2135 | glad_glGetProgramResourceIndex = (PFNGLGETPROGRAMRESOURCEINDEXPROC)load("glGetProgramResourceIndex"); 2136 | glad_glGetProgramResourceName = (PFNGLGETPROGRAMRESOURCENAMEPROC)load("glGetProgramResourceName"); 2137 | glad_glGetProgramResourceiv = (PFNGLGETPROGRAMRESOURCEIVPROC)load("glGetProgramResourceiv"); 2138 | glad_glGetProgramResourceLocation = (PFNGLGETPROGRAMRESOURCELOCATIONPROC)load("glGetProgramResourceLocation"); 2139 | glad_glGetProgramResourceLocationIndex = (PFNGLGETPROGRAMRESOURCELOCATIONINDEXPROC)load("glGetProgramResourceLocationIndex"); 2140 | glad_glShaderStorageBlockBinding = (PFNGLSHADERSTORAGEBLOCKBINDINGPROC)load("glShaderStorageBlockBinding"); 2141 | glad_glTexBufferRange = (PFNGLTEXBUFFERRANGEPROC)load("glTexBufferRange"); 2142 | glad_glTexStorage2DMultisample = (PFNGLTEXSTORAGE2DMULTISAMPLEPROC)load("glTexStorage2DMultisample"); 2143 | glad_glTexStorage3DMultisample = (PFNGLTEXSTORAGE3DMULTISAMPLEPROC)load("glTexStorage3DMultisample"); 2144 | glad_glTextureView = (PFNGLTEXTUREVIEWPROC)load("glTextureView"); 2145 | glad_glBindVertexBuffer = (PFNGLBINDVERTEXBUFFERPROC)load("glBindVertexBuffer"); 2146 | glad_glVertexAttribFormat = (PFNGLVERTEXATTRIBFORMATPROC)load("glVertexAttribFormat"); 2147 | glad_glVertexAttribIFormat = (PFNGLVERTEXATTRIBIFORMATPROC)load("glVertexAttribIFormat"); 2148 | glad_glVertexAttribLFormat = (PFNGLVERTEXATTRIBLFORMATPROC)load("glVertexAttribLFormat"); 2149 | glad_glVertexAttribBinding = (PFNGLVERTEXATTRIBBINDINGPROC)load("glVertexAttribBinding"); 2150 | glad_glVertexBindingDivisor = (PFNGLVERTEXBINDINGDIVISORPROC)load("glVertexBindingDivisor"); 2151 | glad_glDebugMessageControl = (PFNGLDEBUGMESSAGECONTROLPROC)load("glDebugMessageControl"); 2152 | glad_glDebugMessageInsert = (PFNGLDEBUGMESSAGEINSERTPROC)load("glDebugMessageInsert"); 2153 | glad_glDebugMessageCallback = (PFNGLDEBUGMESSAGECALLBACKPROC)load("glDebugMessageCallback"); 2154 | glad_glGetDebugMessageLog = (PFNGLGETDEBUGMESSAGELOGPROC)load("glGetDebugMessageLog"); 2155 | glad_glPushDebugGroup = (PFNGLPUSHDEBUGGROUPPROC)load("glPushDebugGroup"); 2156 | glad_glPopDebugGroup = (PFNGLPOPDEBUGGROUPPROC)load("glPopDebugGroup"); 2157 | glad_glObjectLabel = (PFNGLOBJECTLABELPROC)load("glObjectLabel"); 2158 | glad_glGetObjectLabel = (PFNGLGETOBJECTLABELPROC)load("glGetObjectLabel"); 2159 | glad_glObjectPtrLabel = (PFNGLOBJECTPTRLABELPROC)load("glObjectPtrLabel"); 2160 | glad_glGetObjectPtrLabel = (PFNGLGETOBJECTPTRLABELPROC)load("glGetObjectPtrLabel"); 2161 | glad_glGetPointerv = (PFNGLGETPOINTERVPROC)load("glGetPointerv"); 2162 | } 2163 | static void load_GL_VERSION_4_4(GLADloadproc load) { 2164 | if(!GLAD_GL_VERSION_4_4) return; 2165 | glad_glBufferStorage = (PFNGLBUFFERSTORAGEPROC)load("glBufferStorage"); 2166 | glad_glClearTexImage = (PFNGLCLEARTEXIMAGEPROC)load("glClearTexImage"); 2167 | glad_glClearTexSubImage = (PFNGLCLEARTEXSUBIMAGEPROC)load("glClearTexSubImage"); 2168 | glad_glBindBuffersBase = (PFNGLBINDBUFFERSBASEPROC)load("glBindBuffersBase"); 2169 | glad_glBindBuffersRange = (PFNGLBINDBUFFERSRANGEPROC)load("glBindBuffersRange"); 2170 | glad_glBindTextures = (PFNGLBINDTEXTURESPROC)load("glBindTextures"); 2171 | glad_glBindSamplers = (PFNGLBINDSAMPLERSPROC)load("glBindSamplers"); 2172 | glad_glBindImageTextures = (PFNGLBINDIMAGETEXTURESPROC)load("glBindImageTextures"); 2173 | glad_glBindVertexBuffers = (PFNGLBINDVERTEXBUFFERSPROC)load("glBindVertexBuffers"); 2174 | } 2175 | static int find_extensionsGL(void) { 2176 | if (!get_exts()) return 0; 2177 | (void)&has_ext; 2178 | free_exts(); 2179 | return 1; 2180 | } 2181 | 2182 | static void find_coreGL(void) { 2183 | 2184 | /* Thank you @elmindreda 2185 | * https://github.com/elmindreda/greg/blob/master/templates/greg.c.in#L176 2186 | * https://github.com/glfw/glfw/blob/master/src/context.c#L36 2187 | */ 2188 | int i, major, minor; 2189 | 2190 | const char* version; 2191 | const char* prefixes[] = { 2192 | "OpenGL ES-CM ", 2193 | "OpenGL ES-CL ", 2194 | "OpenGL ES ", 2195 | NULL 2196 | }; 2197 | 2198 | version = (const char*) glGetString(GL_VERSION); 2199 | if (!version) return; 2200 | 2201 | for (i = 0; prefixes[i]; i++) { 2202 | const size_t length = strlen(prefixes[i]); 2203 | if (strncmp(version, prefixes[i], length) == 0) { 2204 | version += length; 2205 | break; 2206 | } 2207 | } 2208 | 2209 | /* PR #18 */ 2210 | #ifdef _MSC_VER 2211 | sscanf_s(version, "%d.%d", &major, &minor); 2212 | #else 2213 | sscanf(version, "%d.%d", &major, &minor); 2214 | #endif 2215 | 2216 | GLVersion.major = major; GLVersion.minor = minor; 2217 | max_loaded_major = major; max_loaded_minor = minor; 2218 | GLAD_GL_VERSION_1_0 = (major == 1 && minor >= 0) || major > 1; 2219 | GLAD_GL_VERSION_1_1 = (major == 1 && minor >= 1) || major > 1; 2220 | GLAD_GL_VERSION_1_2 = (major == 1 && minor >= 2) || major > 1; 2221 | GLAD_GL_VERSION_1_3 = (major == 1 && minor >= 3) || major > 1; 2222 | GLAD_GL_VERSION_1_4 = (major == 1 && minor >= 4) || major > 1; 2223 | GLAD_GL_VERSION_1_5 = (major == 1 && minor >= 5) || major > 1; 2224 | GLAD_GL_VERSION_2_0 = (major == 2 && minor >= 0) || major > 2; 2225 | GLAD_GL_VERSION_2_1 = (major == 2 && minor >= 1) || major > 2; 2226 | GLAD_GL_VERSION_3_0 = (major == 3 && minor >= 0) || major > 3; 2227 | GLAD_GL_VERSION_3_1 = (major == 3 && minor >= 1) || major > 3; 2228 | GLAD_GL_VERSION_3_2 = (major == 3 && minor >= 2) || major > 3; 2229 | GLAD_GL_VERSION_3_3 = (major == 3 && minor >= 3) || major > 3; 2230 | GLAD_GL_VERSION_4_0 = (major == 4 && minor >= 0) || major > 4; 2231 | GLAD_GL_VERSION_4_1 = (major == 4 && minor >= 1) || major > 4; 2232 | GLAD_GL_VERSION_4_2 = (major == 4 && minor >= 2) || major > 4; 2233 | GLAD_GL_VERSION_4_3 = (major == 4 && minor >= 3) || major > 4; 2234 | GLAD_GL_VERSION_4_4 = (major == 4 && minor >= 4) || major > 4; 2235 | if (GLVersion.major > 4 || (GLVersion.major >= 4 && GLVersion.minor >= 4)) { 2236 | max_loaded_major = 4; 2237 | max_loaded_minor = 4; 2238 | } 2239 | } 2240 | 2241 | int gladLoadGLLoader(GLADloadproc load) { 2242 | GLVersion.major = 0; GLVersion.minor = 0; 2243 | glGetString = (PFNGLGETSTRINGPROC)load("glGetString"); 2244 | if(glGetString == NULL) return 0; 2245 | if(glGetString(GL_VERSION) == NULL) return 0; 2246 | find_coreGL(); 2247 | load_GL_VERSION_1_0(load); 2248 | load_GL_VERSION_1_1(load); 2249 | load_GL_VERSION_1_2(load); 2250 | load_GL_VERSION_1_3(load); 2251 | load_GL_VERSION_1_4(load); 2252 | load_GL_VERSION_1_5(load); 2253 | load_GL_VERSION_2_0(load); 2254 | load_GL_VERSION_2_1(load); 2255 | load_GL_VERSION_3_0(load); 2256 | load_GL_VERSION_3_1(load); 2257 | load_GL_VERSION_3_2(load); 2258 | load_GL_VERSION_3_3(load); 2259 | load_GL_VERSION_4_0(load); 2260 | load_GL_VERSION_4_1(load); 2261 | load_GL_VERSION_4_2(load); 2262 | load_GL_VERSION_4_3(load); 2263 | load_GL_VERSION_4_4(load); 2264 | 2265 | if (!find_extensionsGL()) return 0; 2266 | return GLVersion.major != 0 || GLVersion.minor != 0; 2267 | } 2268 | -------------------------------------------------------------------------------- /screenshots/banner.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cgerikj/binary-greedy-meshing/af8c688ed3af63e98f9631c05774f30e1350a021/screenshots/banner.png -------------------------------------------------------------------------------- /screenshots/wireframe.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cgerikj/binary-greedy-meshing/af8c688ed3af63e98f9631c05774f30e1350a021/screenshots/wireframe.png -------------------------------------------------------------------------------- /src/data/level_file.h: -------------------------------------------------------------------------------- 1 | #ifndef LEVEL_FILE_H 2 | #define LEVEL_FILE_H 3 | 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include "rle.h" 14 | 15 | /* 16 | * File structure: 17 | * 1 byte: Square world size (0-255 chunks in x and z) 18 | * size * size * sizeof(ChunkTableEntry) bytes: Lookup table of RLE compressed chunks 19 | * The rest of the buffer contain the chunks. Indices in the table origate from byte 0 in the buffer. 20 | */ 21 | 22 | #if defined _WIN32 || defined __CYGWIN__ 23 | #define PATH_SEP "\\" 24 | #else 25 | #define PATH_SEP "/" 26 | #endif 27 | 28 | struct ChunkTableEntry { 29 | uint32_t key, rleDataBegin, rleDataSize; 30 | }; 31 | 32 | class LevelFile { 33 | public: 34 | std::vector chunkTable; 35 | std::vector buffer; 36 | 37 | void initialize(int s) { 38 | size = s; 39 | dataBufferHead = 1 + (size * size * sizeof(ChunkTableEntry)); 40 | 41 | uint32_t maxFileSize = 1e5 * size * size; 42 | buffer.reserve(maxFileSize); 43 | buffer.assign(maxFileSize, 0); 44 | } 45 | 46 | uint8_t getSize() { 47 | return size; 48 | } 49 | 50 | void loadFromFile(std::string levelName) { 51 | std::ifstream file(".." PATH_SEP "levels" PATH_SEP + levelName, std::ios::binary); 52 | file.unsetf(std::ios::skipws); 53 | 54 | if (file.is_open()) { 55 | std::streampos fileSize; 56 | file.seekg(0, std::ios::end); 57 | fileSize = file.tellg(); 58 | file.seekg(0, std::ios::beg); 59 | 60 | buffer.reserve(fileSize); 61 | buffer.insert(buffer.begin(), std::istream_iterator(file), std::istream_iterator()); 62 | 63 | int bufferHead = 0; 64 | 65 | size = buffer[0]; 66 | bufferHead++; 67 | 68 | uint32_t tableLength = size * size; 69 | uint32_t tableSize = tableLength * sizeof(ChunkTableEntry); 70 | 71 | chunkTable.resize(tableLength); 72 | 73 | std::memcpy(chunkTable.data(), &buffer[bufferHead], tableSize); 74 | 75 | file.close(); 76 | } 77 | } 78 | 79 | void compressAndAddChunk(std::vector& voxels, uint32_t key) { 80 | auto rleVoxels = std::vector(); 81 | rle::compress(voxels, rleVoxels); 82 | 83 | chunkTable.push_back(ChunkTableEntry({ 84 | key, 85 | dataBufferHead, 86 | (uint32_t)rleVoxels.size() 87 | })); 88 | 89 | memcpy(buffer.data() + dataBufferHead, rleVoxels.data(), rleVoxels.size()); 90 | dataBufferHead += rleVoxels.size(); 91 | } 92 | 93 | void saveToFile(std::string newLevelName) { 94 | buffer[0] = size; 95 | 96 | memcpy(buffer.data() + 1, chunkTable.data(), chunkTable.size() * sizeof(ChunkTableEntry)); 97 | 98 | buffer.resize(dataBufferHead + 1); 99 | 100 | std::string saveDir = ".." PATH_SEP "levels" PATH_SEP; 101 | std::filesystem::create_directory(saveDir); 102 | 103 | std::ofstream file; 104 | file.open(saveDir + newLevelName, std::ios::out | std::ios::binary); 105 | file.write((char*)buffer.data(), dataBufferHead); 106 | file.close(); 107 | } 108 | 109 | private: 110 | uint8_t size = 0; 111 | uint32_t dataBufferHead = 1; 112 | }; 113 | 114 | #endif 115 | -------------------------------------------------------------------------------- /src/data/rle.h: -------------------------------------------------------------------------------- 1 | #ifndef RLE_H 2 | #define RLE_H 3 | 4 | #include 5 | #include 6 | 7 | inline void addRleRun(std::vector& rleVoxels, uint8_t type, uint32_t length) { 8 | uint8_t subLength = 0; 9 | if (length <= 255) { 10 | subLength = length; 11 | length = 0; 12 | } 13 | else { 14 | subLength = 255; 15 | length -= 255; 16 | } 17 | 18 | rleVoxels.insert(rleVoxels.end(), { type, subLength }); 19 | 20 | if (length > 0) { 21 | addRleRun(rleVoxels, type, length); 22 | } 23 | } 24 | 25 | namespace rle { 26 | void compress(std::vector &voxels, std::vector &rleVoxels) { 27 | uint8_t type = 0; 28 | uint32_t length = 0; 29 | 30 | for (const uint8_t& iType : voxels) { 31 | if (type == iType) { 32 | length++; 33 | } 34 | else { 35 | addRleRun(rleVoxels, type, length); 36 | 37 | type = iType; 38 | length = 1; 39 | } 40 | } 41 | 42 | addRleRun(rleVoxels, (uint8_t)type, length); 43 | } 44 | 45 | inline const uint64_t getBitRange(uint8_t low, uint8_t high) { 46 | return ((1ULL << (high - low + 1)) - 1) << low; 47 | } 48 | 49 | void decompressToVoxelsAndOpaqueMask(uint8_t* rleVoxels, int rleSize, uint8_t* voxels, uint64_t* opaqueMask) { 50 | uint8_t* p = rleVoxels; 51 | uint8_t* p_end = rleVoxels + rleSize; 52 | uint8_t* u_p = voxels; 53 | 54 | int opaqueMaskIndex = 0; 55 | int opaqueMaskBitIndex = 0; 56 | 57 | while (p != p_end) { 58 | uint8_t type = *p; 59 | uint8_t len = *(p + 1); 60 | 61 | std::memset(u_p, type, len); 62 | 63 | // Decompress into opaqueMask 64 | int remainingLength = len; 65 | while (remainingLength) { 66 | int remainingBitsInIndex = 64 - opaqueMaskBitIndex; 67 | // Partial same int 68 | if (remainingLength < remainingBitsInIndex) { 69 | if (type) { 70 | opaqueMask[opaqueMaskIndex] |= getBitRange(opaqueMaskBitIndex, opaqueMaskBitIndex + remainingLength - 1); 71 | } 72 | opaqueMaskBitIndex += remainingLength; 73 | remainingLength = 0; 74 | } 75 | // Set n integers 76 | else if (remainingLength >= 64 && opaqueMaskBitIndex == 0) { 77 | int count = std::floor(remainingLength / 64); 78 | if (type) { 79 | memset(&opaqueMask[opaqueMaskIndex], (uint64_t)-1, count * sizeof(uint64_t)); 80 | } 81 | opaqueMaskIndex += count; 82 | remainingLength -= count * 64; 83 | } 84 | // Rest of int + left over 85 | else if (remainingLength >= remainingBitsInIndex) { 86 | if (type) { 87 | opaqueMask[opaqueMaskIndex] |= getBitRange(opaqueMaskBitIndex, 63); 88 | } 89 | remainingLength -= remainingBitsInIndex; 90 | opaqueMaskIndex++; 91 | opaqueMaskBitIndex = 0; 92 | } 93 | } 94 | 95 | u_p += len; 96 | p += 2; 97 | } 98 | } 99 | }; 100 | 101 | #endif 102 | -------------------------------------------------------------------------------- /src/main.cpp: -------------------------------------------------------------------------------- 1 | #define GLFW_INCLUDE_NONE 2 | #include 3 | 4 | #include 5 | #include 6 | #include "misc/shader.h" 7 | #include "misc/camera.h" 8 | #include "misc/noise.h" 9 | #include "misc/utility.h" 10 | #include "misc/timer.h" 11 | #include "rendering/chunk_renderer.h" 12 | #include "data/level_file.h" 13 | #include "data/rle.h" 14 | #include "cxxpool.h" 15 | #include 16 | 17 | #define BM_IMPLEMENTATION 18 | #include "mesher.h" 19 | 20 | void createTestChunk(); 21 | 22 | const std::string DEMO_LEVEL_FILE = "demo_terrain_96"; 23 | 24 | const int WINDOW_WIDTH = 1920; 25 | const int WINDOW_HEIGHT = 1080; 26 | const bool FULLSCREEN = false; 27 | 28 | const int MESHING_THREADS = std::max((std::thread::hardware_concurrency() / 2) - 1, 2u); 29 | const int MAX_MESHING_FUTURES = MESHING_THREADS * 4; 30 | 31 | GLFWwindow* init_window() { 32 | glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4); 33 | glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 4); 34 | glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); 35 | glfwWindowHint(GLFW_SAMPLES, 2); 36 | 37 | GLFWwindow* window = glfwCreateWindow(WINDOW_WIDTH, WINDOW_HEIGHT, "Binary Greedy Meshing V2", FULLSCREEN ? glfwGetPrimaryMonitor() : nullptr, nullptr); 38 | if (!window) { 39 | fprintf(stderr, "Unable to create GLFW window\n"); 40 | glfwDestroyWindow(window); 41 | glfwTerminate(); 42 | return nullptr; 43 | } 44 | 45 | glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED); 46 | glfwMakeContextCurrent(window); 47 | 48 | if (!gladLoadGL()) { 49 | fprintf(stderr, "Unable to initialize glad\n"); 50 | glfwDestroyWindow(window); 51 | glfwTerminate(); 52 | return nullptr; 53 | } 54 | 55 | return window; 56 | } 57 | 58 | void GLAPIENTRY message_callback( 59 | GLenum source, 60 | GLenum type, 61 | GLuint id, 62 | GLenum severity, 63 | GLsizei length, 64 | const GLchar* message, 65 | const void* userParam 66 | ) { 67 | std::string SEVERITY = ""; 68 | switch (severity) { 69 | case GL_DEBUG_SEVERITY_LOW: 70 | SEVERITY = "LOW"; 71 | break; 72 | case GL_DEBUG_SEVERITY_MEDIUM: 73 | SEVERITY = "MEDIUM"; 74 | break; 75 | case GL_DEBUG_SEVERITY_HIGH: 76 | SEVERITY = "HIGH"; 77 | break; 78 | case GL_DEBUG_SEVERITY_NOTIFICATION: 79 | SEVERITY = "NOTIFICATION"; 80 | break; 81 | } 82 | fprintf(stderr, "GL CALLBACK: %s type = 0x%x, severity = %s, message = %s\n", 83 | type == GL_DEBUG_TYPE_ERROR ? "** GL ERROR **" : "", 84 | type, SEVERITY.c_str(), message); 85 | } 86 | 87 | bool init_opengl() { 88 | glEnable(GL_DEBUG_OUTPUT); 89 | glDebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DEBUG_SEVERITY_NOTIFICATION, 0, nullptr, GL_FALSE); 90 | glDebugMessageCallback(message_callback, 0); 91 | 92 | glEnable(GL_DEPTH_TEST); 93 | 94 | glFrontFace(GL_CCW); 95 | glCullFace(GL_BACK); 96 | glEnable(GL_CULL_FACE); 97 | 98 | glClearColor(0.529f, 0.808f, 0.922f, 0.0f); 99 | 100 | glEnable(GL_MULTISAMPLE); 101 | 102 | return true; 103 | }; 104 | 105 | void glfw_error_callback(int error, const char* description) { 106 | fprintf(stderr, "GLFW error %d: %s\n", error, description); 107 | } 108 | 109 | Shader* shader = nullptr; 110 | Camera* camera = nullptr; 111 | Noise noise; 112 | 113 | float last_x = 0.0f; 114 | float last_y = 0.0f; 115 | 116 | enum class MESH_TYPE : int { 117 | SPHERE, 118 | TERRAIN, 119 | RANDOM, 120 | CHECKERBOARD, 121 | EMPTY, 122 | Count 123 | }; 124 | 125 | int mesh_type = (int) MESH_TYPE::SPHERE; 126 | 127 | struct ChunkRenderData { 128 | glm::ivec3 chunkPos = glm::ivec3(0); 129 | std::vector faceDrawCommands = { nullptr, nullptr, nullptr, nullptr, nullptr, nullptr }; 130 | }; 131 | 132 | struct ThreadData { 133 | uint8_t* voxels; 134 | MeshData* meshData; 135 | }; 136 | 137 | struct MeshingResponse { 138 | ChunkTableEntry* tableEntry; 139 | ThreadData* threadData; 140 | long long decompressionDurationUs; 141 | long long meshingDurationUs; 142 | }; 143 | 144 | MeshData mainThreadMeshData; 145 | ChunkRenderer chunkRenderer; 146 | std::vector chunkRenderData; 147 | ChunkRenderData testChunkRenderData; 148 | LevelFile levelFile; 149 | 150 | void mouse_callback(GLFWwindow* window, double xpos, double ypos) { 151 | camera->processMouseMovement(xpos - last_x, last_y - ypos); 152 | last_x = xpos; 153 | last_y = ypos; 154 | } 155 | 156 | void key_callback(GLFWwindow* window, int key, int scancode, int action, int mods) { 157 | if (key == GLFW_KEY_ESCAPE && action == GLFW_RELEASE) { 158 | glfwSetWindowShouldClose(window, true); 159 | } 160 | 161 | else if (key == GLFW_KEY_X && action == GLFW_RELEASE) { 162 | GLint lastPolyMode[2]; 163 | glGetIntegerv(GL_POLYGON_MODE, lastPolyMode); 164 | if (lastPolyMode[0] == GL_FILL) { 165 | glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); 166 | } else { 167 | glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); 168 | } 169 | } 170 | 171 | else if (key == GLFW_KEY_1 && action == GLFW_RELEASE) { 172 | printf("Forward: %.1f, %.1f, %.1f \n", camera->front.x, camera->front.y, camera->front.z); 173 | } 174 | 175 | else if (key == GLFW_KEY_SPACE && action == GLFW_RELEASE) { 176 | createTestChunk(); 177 | } 178 | 179 | else if (key == GLFW_KEY_TAB && action == GLFW_RELEASE) { 180 | mesh_type++; 181 | if (mesh_type >= (int) MESH_TYPE::Count) { 182 | mesh_type = 0; 183 | } 184 | createTestChunk(); 185 | } 186 | } 187 | 188 | void createTestChunk() { 189 | uint8_t* voxels = new uint8_t[CS_P3] { 0 }; 190 | memset(voxels, 0, CS_P3); 191 | memset(mainThreadMeshData.opaqueMask, 0, CS_P2 * sizeof(uint64_t)); 192 | 193 | switch (mesh_type) { 194 | case (int) MESH_TYPE::TERRAIN: { 195 | noise.generateTerrainV1(voxels, mainThreadMeshData.opaqueMask, 30); 196 | break; 197 | } 198 | 199 | case (int) MESH_TYPE::RANDOM: { 200 | noise.generateWhiteNoiseTerrain(voxels, mainThreadMeshData.opaqueMask, 30); 201 | break; 202 | } 203 | 204 | case (int) MESH_TYPE::CHECKERBOARD: { 205 | for (int x = 1; x < CS_P; x++) { 206 | for (int y = 1; y < CS_P; y++) { 207 | for (int z = 1; z < CS_P; z++) { 208 | if (x % 2 == 0 && y % 2 == 0 && z % 2 == 0) { 209 | voxels[get_zxy_index(x, y, z)] = 1; 210 | mainThreadMeshData.opaqueMask[(y * CS_P) + x] |= 1ull << z; 211 | 212 | voxels[get_zxy_index(x - 1, y - 1, z)] = 2; 213 | mainThreadMeshData.opaqueMask[((y - 1) * CS_P) + (x - 1)] |= 1ull << z; 214 | 215 | voxels[get_zxy_index(x - 1, y, z - 1)] = 3; 216 | mainThreadMeshData.opaqueMask[(y * CS_P) + (x - 1)] |= 1ull << (z - 1); 217 | 218 | voxels[get_zxy_index(x, y - 1, z - 1)] = 4; 219 | mainThreadMeshData.opaqueMask[((y - 1) * CS_P) + x] |= 1ull << (z - 1); 220 | } 221 | } 222 | } 223 | } 224 | break; 225 | } 226 | 227 | case (int) MESH_TYPE::SPHERE: { 228 | int r = CS_P / 2; 229 | for (int x = -r; x < r; x++) { 230 | for (int y = -r; y < r; y++) { 231 | for (int z = -r; z < r; z++) { 232 | if (std::sqrt(x * x + y * y + z * z) < 30.0f) { 233 | voxels[get_zxy_index(x + r, y + r, z + r)] = 8; 234 | mainThreadMeshData.opaqueMask[((y + r) * CS_P) + (x + r)] |= 1ull << (z + r); 235 | } 236 | } 237 | } 238 | } 239 | break; 240 | } 241 | 242 | case (int) MESH_TYPE::EMPTY: { 243 | // empty! 244 | break; 245 | } 246 | } 247 | 248 | { 249 | int iterations = 1000; 250 | Timer timer(std::to_string(iterations) + " iterations", true); 251 | 252 | for (int i = 0; i < iterations; i++) { 253 | mesh(voxels, mainThreadMeshData); 254 | } 255 | } 256 | 257 | for (auto& cmd : testChunkRenderData.faceDrawCommands) { 258 | if (cmd) { 259 | chunkRenderer.removeDrawCommand(cmd); 260 | delete cmd; 261 | cmd = nullptr; 262 | } 263 | } 264 | 265 | if (mainThreadMeshData.vertexCount) { 266 | uint32_t y = 0; 267 | glm::ivec3 chunkPos = glm::ivec3(levelFile.getSize() / 2, 1, levelFile.getSize() / 2); 268 | 269 | for (uint32_t i = 0; i <= 5; i++) { 270 | if (mainThreadMeshData.faceVertexLength[i]) { 271 | uint32_t baseInstance = (i << 24) | (chunkPos.z << 16) | (chunkPos.y << 8) | chunkPos.x; 272 | 273 | auto drawCommand = chunkRenderer.getDrawCommand(mainThreadMeshData.faceVertexLength[i], baseInstance); 274 | 275 | testChunkRenderData.faceDrawCommands[i] = drawCommand; 276 | 277 | chunkRenderer.buffer(*drawCommand, mainThreadMeshData.vertices->data() + mainThreadMeshData.faceVertexBegin[i]); 278 | } 279 | } 280 | } 281 | 282 | printf("vertex count: %i\n", mainThreadMeshData.vertexCount); 283 | } 284 | 285 | auto meshLambda = [](ChunkTableEntry* tableEntry, ThreadData* threadData) -> MeshingResponse { 286 | Timer decompressionTimer("", true); 287 | memset(threadData->meshData->opaqueMask, 0, CS_P2 * sizeof(uint64_t)); 288 | rle::decompressToVoxelsAndOpaqueMask(levelFile.buffer.data() + tableEntry->rleDataBegin, tableEntry->rleDataSize, threadData->voxels, threadData->meshData->opaqueMask); 289 | auto decompressionDurationUs = decompressionTimer.end(); 290 | 291 | Timer meshingTimer("", true); 292 | mesh(threadData->voxels, *threadData->meshData); 293 | auto meshingDurationUs = meshingTimer.end(); 294 | 295 | return MeshingResponse({ tableEntry, threadData, decompressionDurationUs, meshingDurationUs }); 296 | }; 297 | 298 | int main(int argc, char* argv[]) { 299 | glfwSetErrorCallback(glfw_error_callback); 300 | 301 | if (!glfwInit()) { 302 | fprintf(stderr, "Unable to initialize GLFW\n"); 303 | return 1; 304 | } 305 | 306 | auto window = init_window(); 307 | if (!window) { 308 | return 1; 309 | } 310 | glfwSetWindowPos(window, 0, 31); 311 | glfwSwapInterval(0); 312 | 313 | glfwSetCursorPosCallback(window, mouse_callback); 314 | glfwSetKeyCallback(window, key_callback); 315 | 316 | if (!init_opengl()) { 317 | fprintf(stderr, "Unable to initialize glad/opengl\n"); 318 | return 1; 319 | } 320 | 321 | mainThreadMeshData.opaqueMask = new uint64_t[CS_P2] { 0 }; 322 | mainThreadMeshData.faceMasks = new uint64_t[CS_2 * 6] { 0 }; 323 | mainThreadMeshData.forwardMerged = new uint8_t[CS_2] { 0 }; 324 | mainThreadMeshData.rightMerged = new uint8_t[CS] { 0 }; 325 | mainThreadMeshData.vertices = new std::vector(10000); 326 | mainThreadMeshData.maxVertices = 10000; 327 | 328 | chunkRenderer.init(); 329 | 330 | // Load 331 | if (true) { 332 | { 333 | Timer loadFileTimer("loading level file", true); 334 | levelFile.loadFromFile(DEMO_LEVEL_FILE); 335 | } 336 | 337 | long long totalMeshingDurationUs = 0; 338 | long long totalDecompressionDurationUs = 0; 339 | long long totalMeshBufferingDurationUs = 0; 340 | 341 | // Create a temporary thread pool for meshing all chunks on load 342 | cxxpool::thread_pool threadPool{ (size_t)MESHING_THREADS }; 343 | std::unordered_map> meshFutures; 344 | 345 | // Create MAX_MESHING_FUTURES instances of ThreadData 346 | std::queue threadingMeshData = {}; 347 | for (int i = 0; i < MAX_MESHING_FUTURES; i++) { 348 | auto meshData = new MeshData(); 349 | meshData->opaqueMask = new uint64_t[CS_P2] { 0 }; 350 | meshData->faceMasks = new uint64_t[CS_2 * 6] { 0 }; 351 | meshData->forwardMerged = new uint8_t[CS_2] { 0 }; 352 | meshData->rightMerged = new uint8_t[CS] { 0 }; 353 | meshData->vertices = new std::vector(10000); 354 | meshData->maxVertices = 10000; 355 | auto threadData = new ThreadData(); 356 | threadData->meshData = meshData; 357 | threadData->voxels = new uint8_t[CS_P3] { 0 }; 358 | threadingMeshData.push(threadData); 359 | } 360 | 361 | // Create a queue of all chunks 362 | std::queue meshQueue = {}; 363 | for (auto& tableEntry : levelFile.chunkTable) { 364 | meshQueue.push(&tableEntry); 365 | } 366 | 367 | while (meshFutures.size() || meshQueue.size()) { 368 | 369 | // Create new futures 370 | while (meshFutures.size() < MAX_MESHING_FUTURES && threadingMeshData.size() && meshQueue.size()) { 371 | auto threadData = threadingMeshData.front(); 372 | threadingMeshData.pop(); 373 | 374 | ChunkTableEntry* entry = meshQueue.front(); 375 | meshQueue.pop(); 376 | 377 | meshFutures.emplace(entry->key, threadPool.push(meshLambda, entry, threadData)); 378 | } 379 | 380 | // Handle completed futures 381 | std::vector finishedMeshKeys; 382 | for (auto& [future_key, future] : meshFutures) { 383 | if (future.wait_for(std::chrono::seconds(0)) == std::future_status::ready) { 384 | finishedMeshKeys.push_back(future_key); 385 | 386 | auto response = future.get(); 387 | threadingMeshData.push(response.threadData); 388 | 389 | auto meshData = *response.threadData->meshData; 390 | totalDecompressionDurationUs += response.decompressionDurationUs; 391 | totalMeshingDurationUs += response.meshingDurationUs; 392 | 393 | Timer meshBufferingTimer("", true); 394 | if (meshData.vertexCount) { 395 | uint32_t y = 0; 396 | glm::ivec3 chunkPos = parse_xyz_key(response.tableEntry->key); 397 | std::vector commands = { nullptr, nullptr, nullptr, nullptr, nullptr, nullptr }; 398 | 399 | for (uint32_t i = 0; i <= 5; i++) { 400 | if (response.threadData->meshData->faceVertexLength[i]) { 401 | uint32_t baseInstance = (i << 24) | (chunkPos.z << 16) | (chunkPos.y << 8) | chunkPos.x; 402 | 403 | auto drawCommand = chunkRenderer.getDrawCommand(meshData.faceVertexLength[i], baseInstance); 404 | 405 | commands[i] = drawCommand; 406 | 407 | chunkRenderer.buffer(*drawCommand, meshData.vertices->data() + meshData.faceVertexBegin[i]); 408 | } 409 | } 410 | chunkRenderData.push_back(ChunkRenderData({ chunkPos, commands })); 411 | } 412 | totalMeshBufferingDurationUs += meshBufferingTimer.end(); 413 | } 414 | } 415 | 416 | for (auto key : finishedMeshKeys) { 417 | meshFutures.erase(key); 418 | } 419 | } 420 | 421 | // TODO: Clean up memory! 422 | 423 | printf("\n------------------------------------\n"); 424 | printf("Finished loading %llu chunks:\n", levelFile.chunkTable.size()); 425 | printf("\ Decompression: %lluus avg\n", totalDecompressionDurationUs / levelFile.chunkTable.size()); 426 | printf("\ Meshing: %lluus avg \n", totalMeshingDurationUs / levelFile.chunkTable.size()); 427 | printf("\ Buffering: %lluus avg \n", totalMeshBufferingDurationUs / levelFile.chunkTable.size()); 428 | printf("------------------------------------\n\n"); 429 | } 430 | 431 | // Generate terrain 432 | else { 433 | int size = 16; 434 | levelFile.initialize(size); 435 | 436 | std::vector* voxels = new std::vector(CS_P3); 437 | for (uint32_t x = 0; x < size; x++) { 438 | for (uint32_t z = 0; z < size; z++) { 439 | uint32_t y = 0; 440 | 441 | memset(voxels->data(), 0, CS_P3); 442 | memset(mainThreadMeshData.opaqueMask, 0, CS_P2 * sizeof(uint64_t)); 443 | 444 | noise.generateTerrainV2(voxels->data(), mainThreadMeshData.opaqueMask, x, z, 30); 445 | 446 | levelFile.compressAndAddChunk(*voxels, get_xyz_key(x, y, z)); 447 | } 448 | } 449 | 450 | levelFile.saveToFile("demo_terrain_" + std::to_string(size)); 451 | } 452 | 453 | createTestChunk(); 454 | 455 | shader = new Shader("main", "main"); 456 | camera = new Camera(glm::vec3(levelFile.getSize() * CS / 2, 100, (levelFile.getSize() * CS / 2) - 30)); 457 | camera->handleResolution(WINDOW_WIDTH, WINDOW_HEIGHT); 458 | 459 | float forwardMove = 0.0f; 460 | float rightMove = 0.0f; 461 | float noclipSpeed = 250.0f; 462 | 463 | float deltaTime = 0.0f; 464 | 465 | auto lastFrame = glfwGetTime(); 466 | while (!glfwWindowShouldClose(window)) { 467 | glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); 468 | 469 | float currentFrame = glfwGetTime(); 470 | deltaTime = currentFrame - lastFrame; 471 | lastFrame = currentFrame; 472 | 473 | if (glfwGetKey(window, GLFW_KEY_W) == GLFW_PRESS) forwardMove = 1.0f; 474 | else if (glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS) forwardMove = -1.0f; 475 | else forwardMove = 0.0f; 476 | 477 | if (glfwGetKey(window, GLFW_KEY_D) == GLFW_PRESS) rightMove = 1.0f; 478 | else if (glfwGetKey(window, GLFW_KEY_A) == GLFW_PRESS) rightMove = -1.0f; 479 | else rightMove = 0.0f; 480 | auto wishdir = (camera->front * forwardMove) + (camera->right * rightMove); 481 | camera->position += noclipSpeed * wishdir * deltaTime; 482 | 483 | for (const auto& testCmd : testChunkRenderData.faceDrawCommands) { 484 | if (testCmd) { 485 | chunkRenderer.addDrawCommand(*testCmd); 486 | } 487 | } 488 | 489 | glm::ivec3 cameraChunkPos = glm::floor(camera->position / glm::vec3(CS)); 490 | 491 | for (const auto& data : chunkRenderData) { 492 | for (int i = 0; i < 6; i++) { 493 | auto& d = data.faceDrawCommands[i]; 494 | if (d) { 495 | switch (i) { 496 | case 0: 497 | if (cameraChunkPos.y >= data.chunkPos.y) { 498 | chunkRenderer.addDrawCommand(*d); 499 | } 500 | break; 501 | 502 | case 1: 503 | if (cameraChunkPos.y <= data.chunkPos.y) { 504 | chunkRenderer.addDrawCommand(*d); 505 | } 506 | break; 507 | 508 | case 2: 509 | if (cameraChunkPos.x >= data.chunkPos.x) { 510 | chunkRenderer.addDrawCommand(*d); 511 | } 512 | break; 513 | 514 | case 3: 515 | if (cameraChunkPos.x <= data.chunkPos.x) { 516 | chunkRenderer.addDrawCommand(*d); 517 | } 518 | break; 519 | 520 | case 4: 521 | if (cameraChunkPos.z >= data.chunkPos.z) { 522 | chunkRenderer.addDrawCommand(*d); 523 | } 524 | break; 525 | 526 | case 5: 527 | if (cameraChunkPos.z <= data.chunkPos.z) { 528 | chunkRenderer.addDrawCommand(*d); 529 | } 530 | break; 531 | } 532 | } 533 | } 534 | } 535 | 536 | chunkRenderer.render(*shader, *camera); 537 | 538 | glfwSwapBuffers(window); 539 | glfwPollEvents(); 540 | } 541 | 542 | return 0; 543 | } -------------------------------------------------------------------------------- /src/mesher.h: -------------------------------------------------------------------------------- 1 | /* 2 | MIT License 3 | 4 | Copyright (c) 2020 Erik Johansson 5 | 6 | Permission is hereby granted, free of charge, to any person obtaining a copy 7 | of this software and associated documentation files (the "Software"), to deal 8 | in the Software without restriction, including without limitation the rights 9 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 10 | copies of the Software, and to permit persons to whom the Software is 11 | furnished to do so, subject to the following conditions: 12 | 13 | The above copyright notice and this permission notice shall be included in all 14 | copies or substantial portions of the Software. 15 | 16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 19 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 20 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 21 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 22 | SOFTWARE. 23 | */ 24 | 25 | // Define BM_IMPLEMENTATION in exactly one source file to include the implementation 26 | // and include the mesher.h without that define as often as needed 27 | // 28 | // it could look like this 29 | // 30 | // #define BM_IMPLEMENTATION 31 | // #include "mesher.h" 32 | // 33 | // There are other defines to control the behaviour of the library. 34 | // * Define BM_VECTOR with your own vector implementation - otherwise it will use std::vector 35 | 36 | #ifndef MESHER_H 37 | #define MESHER_H 38 | 39 | #ifndef BM_VECTOR 40 | #include 41 | #define BM_VECTOR std::vector 42 | #endif 43 | 44 | #include 45 | 46 | // CS = chunk size (max 62) 47 | static constexpr int CS = 62; 48 | 49 | // Padded chunk size 50 | static constexpr int CS_P = CS + 2; 51 | static constexpr int CS_2 = CS * CS; 52 | static constexpr int CS_P2 = CS_P * CS_P; 53 | static constexpr int CS_P3 = CS_P * CS_P * CS_P; 54 | 55 | struct MeshData { 56 | uint64_t* faceMasks = nullptr; // CS_2 * 6 57 | uint64_t* opaqueMask = nullptr; //CS_P2 58 | uint8_t* forwardMerged = nullptr; // CS_2 59 | uint8_t* rightMerged = nullptr; // CS 60 | BM_VECTOR* vertices = nullptr; 61 | int vertexCount = 0; 62 | int maxVertices = 0; 63 | int faceVertexBegin[6] = { 0 }; 64 | int faceVertexLength[6] = { 0 }; 65 | }; 66 | 67 | // @param[in] voxels: The input data includes duplicate edge data from neighboring chunks which is used 68 | // for visibility culling. For optimal performance, your world data should already be structured 69 | // this way so that you can feed the data straight into this algorithm. 70 | // Input data is ordered in ZXY and is 64^3 which results in a 62^3 mesh. 71 | // 72 | // @param[out] meshData The allocated vertices in MeshData with a length of meshData.vertexCount. 73 | void mesh(const uint8_t* voxels, MeshData& meshData); 74 | 75 | #endif // MESHER_H 76 | 77 | #ifdef BM_IMPLEMENTATION 78 | 79 | #ifndef BM_MEMSET 80 | #define BM_MEMSET memset 81 | #include // memset 82 | #endif 83 | 84 | static inline const int getAxisIndex(const int axis, const int a, const int b, const int c) { 85 | if (axis == 0) return b + (a * CS_P) + (c * CS_P2); 86 | else if (axis == 1) return b + (c * CS_P) + (a * CS_P2); 87 | else return c + (a * CS_P) + (b * CS_P2); 88 | } 89 | 90 | static inline const void insertQuad(BM_VECTOR& vertices, uint64_t quad, int& vertexI, int& maxVertices) { 91 | if (vertexI >= maxVertices - 6) { 92 | vertices.resize(maxVertices * 2, 0); 93 | maxVertices *= 2; 94 | } 95 | 96 | vertices[vertexI] = quad; 97 | 98 | vertexI++; 99 | } 100 | 101 | static inline const uint64_t getQuad(uint64_t x, uint64_t y, uint64_t z, uint64_t w, uint64_t h, uint64_t type) { 102 | return (type << 32) | (h << 24) | (w << 18) | (z << 12) | (y << 6) | x; 103 | } 104 | 105 | constexpr uint64_t P_MASK = ~(1ull << 63 | 1); 106 | 107 | void mesh(const uint8_t* voxels, MeshData& meshData) { 108 | meshData.vertexCount = 0; 109 | int vertexI = 0; 110 | 111 | uint64_t* opaqueMask = meshData.opaqueMask; 112 | uint64_t* faceMasks = meshData.faceMasks; 113 | uint8_t* forwardMerged = meshData.forwardMerged; 114 | uint8_t* rightMerged = meshData.rightMerged; 115 | 116 | // Hidden face culling 117 | for (int a = 1; a < CS_P - 1; a++) { 118 | const int aCS_P = a * CS_P; 119 | 120 | for (int b = 1; b < CS_P - 1; b++) { 121 | const uint64_t columnBits = opaqueMask[(a * CS_P) + b] & P_MASK; 122 | const int baIndex = (b - 1) + (a - 1) * CS; 123 | const int abIndex = (a - 1) + (b - 1) * CS; 124 | 125 | faceMasks[baIndex + 0 * CS_2] = (columnBits & ~opaqueMask[aCS_P + CS_P + b]) >> 1; 126 | faceMasks[baIndex + 1 * CS_2] = (columnBits & ~opaqueMask[aCS_P - CS_P + b]) >> 1; 127 | 128 | faceMasks[abIndex + 2 * CS_2] = (columnBits & ~opaqueMask[aCS_P + (b + 1)]) >> 1; 129 | faceMasks[abIndex + 3 * CS_2] = (columnBits & ~opaqueMask[aCS_P + (b - 1)]) >> 1; 130 | 131 | faceMasks[baIndex + 4 * CS_2] = columnBits & ~(opaqueMask[aCS_P + b] >> 1); 132 | faceMasks[baIndex + 5 * CS_2] = columnBits & ~(opaqueMask[aCS_P + b] << 1); 133 | } 134 | } 135 | 136 | // Greedy meshing faces 0-3 137 | for (int face = 0; face < 4; face++) { 138 | const int axis = face / 2; 139 | 140 | const int faceVertexBegin = vertexI; 141 | 142 | for (int layer = 0; layer < CS; layer++) { 143 | const int bitsLocation = layer * CS + face * CS_2; 144 | 145 | for (int forward = 0; forward < CS; forward++) { 146 | uint64_t bitsHere = faceMasks[forward + bitsLocation]; 147 | if (bitsHere == 0) continue; 148 | 149 | const uint64_t bitsNext = forward + 1 < CS ? faceMasks[(forward + 1) + bitsLocation] : 0; 150 | 151 | uint8_t rightMerged = 1; 152 | while (bitsHere) { 153 | unsigned long bitPos; 154 | #ifdef _MSC_VER 155 | _BitScanForward64(&bitPos, bitsHere); 156 | #else 157 | bitPos = __builtin_ctzll(bitsHere); 158 | #endif 159 | 160 | const uint8_t type = voxels[getAxisIndex(axis, forward + 1, bitPos + 1, layer + 1)]; 161 | uint8_t& forwardMergedRef = forwardMerged[bitPos]; 162 | 163 | if ((bitsNext >> bitPos & 1) && type == voxels[getAxisIndex(axis, forward + 2, bitPos + 1, layer + 1)]) { 164 | forwardMergedRef++; 165 | bitsHere &= ~(1ull << bitPos); 166 | continue; 167 | } 168 | 169 | for (int right = bitPos + 1; right < CS; right++) { 170 | if (!(bitsHere >> right & 1) || forwardMergedRef != forwardMerged[right] || type != voxels[getAxisIndex(axis, forward + 1, right + 1, layer + 1)]) break; 171 | forwardMerged[right] = 0; 172 | rightMerged++; 173 | } 174 | bitsHere &= ~((1ull << (bitPos + rightMerged)) - 1); 175 | 176 | const uint8_t meshFront = forward - forwardMergedRef; 177 | const uint8_t meshLeft = bitPos; 178 | const uint8_t meshUp = layer + (~face & 1); 179 | 180 | const uint8_t meshWidth = rightMerged; 181 | const uint8_t meshLength = forwardMergedRef + 1; 182 | 183 | forwardMergedRef = 0; 184 | rightMerged = 1; 185 | 186 | uint64_t quad; 187 | switch (face) { 188 | case 0: 189 | case 1: 190 | quad = getQuad(meshFront + (face == 1 ? meshLength : 0), meshUp, meshLeft, meshLength, meshWidth, type); 191 | break; 192 | case 2: 193 | case 3: 194 | quad = getQuad(meshUp, meshFront + (face == 2 ? meshLength : 0), meshLeft, meshLength, meshWidth, type); 195 | break; 196 | } 197 | 198 | insertQuad(*meshData.vertices, quad, vertexI, meshData.maxVertices); 199 | } 200 | } 201 | } 202 | 203 | const int faceVertexLength = vertexI - faceVertexBegin; 204 | meshData.faceVertexBegin[face] = faceVertexBegin; 205 | meshData.faceVertexLength[face] =faceVertexLength; 206 | } 207 | 208 | // Greedy meshing faces 4-5 209 | for (int face = 4; face < 6; face++) { 210 | const int axis = face / 2; 211 | 212 | const int faceVertexBegin = vertexI; 213 | 214 | for (int forward = 0; forward < CS; forward++) { 215 | const int bitsLocation = forward * CS + face * CS_2; 216 | const int bitsForwardLocation = (forward + 1) * CS + face * CS_2; 217 | 218 | for (int right = 0; right < CS; right++) { 219 | uint64_t bitsHere = faceMasks[right + bitsLocation]; 220 | if (bitsHere == 0) continue; 221 | 222 | const uint64_t bitsForward = forward < CS - 1 ? faceMasks[right + bitsForwardLocation] : 0; 223 | const uint64_t bitsRight = right < CS - 1 ? faceMasks[right + 1 + bitsLocation] : 0; 224 | const int rightCS = right * CS; 225 | 226 | while (bitsHere) { 227 | unsigned long bitPos; 228 | #ifdef _MSC_VER 229 | _BitScanForward64(&bitPos, bitsHere); 230 | #else 231 | bitPos = __builtin_ctzll(bitsHere); 232 | #endif 233 | 234 | bitsHere &= ~(1ull << bitPos); 235 | 236 | const uint8_t type = voxels[getAxisIndex(axis, right + 1, forward + 1, bitPos)]; 237 | uint8_t& forwardMergedRef = forwardMerged[rightCS + (bitPos - 1)]; 238 | uint8_t& rightMergedRef = rightMerged[bitPos - 1]; 239 | 240 | if (rightMergedRef == 0 && (bitsForward >> bitPos & 1) && type == voxels[getAxisIndex(axis, right + 1, forward + 2, bitPos)]) { 241 | forwardMergedRef++; 242 | continue; 243 | } 244 | 245 | if ((bitsRight >> bitPos & 1) && forwardMergedRef == forwardMerged[(rightCS + CS) + (bitPos - 1)] && type == voxels[getAxisIndex(axis, right + 2, forward + 1, bitPos)]) { 246 | forwardMergedRef = 0; 247 | rightMergedRef++; 248 | continue; 249 | } 250 | 251 | const uint8_t meshLeft = right - rightMergedRef; 252 | const uint8_t meshFront = forward - forwardMergedRef; 253 | const uint8_t meshUp = bitPos - 1 + (~face & 1); 254 | 255 | const uint8_t meshWidth = 1 + rightMergedRef; 256 | const uint8_t meshLength = 1 + forwardMergedRef; 257 | 258 | forwardMergedRef = 0; 259 | rightMergedRef = 0; 260 | 261 | const uint64_t quad = getQuad(meshLeft + (face == 4 ? meshWidth : 0), meshFront, meshUp, meshWidth, meshLength, type); 262 | 263 | insertQuad(*meshData.vertices, quad, vertexI, meshData.maxVertices); 264 | } 265 | } 266 | } 267 | 268 | const int faceVertexLength = vertexI - faceVertexBegin; 269 | meshData.faceVertexBegin[face] = faceVertexBegin; 270 | meshData.faceVertexLength[face] =faceVertexLength; 271 | } 272 | 273 | meshData.vertexCount = vertexI + 1; 274 | } 275 | 276 | #endif // BM_IMPLEMENTATION 277 | -------------------------------------------------------------------------------- /src/misc/camera.h: -------------------------------------------------------------------------------- 1 | #ifndef CAMERA_H 2 | #define CAMERA_H 3 | 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | 10 | const float YAW = 0.0f; 11 | const float PITCH = 0.0f; 12 | const float SENSITIVITY = 0.075f; 13 | const float FOV = 80.0f; 14 | 15 | class Camera { 16 | public: 17 | glm::vec3 position; 18 | glm::vec3 front = glm::vec3(0.0f, 0.0f, -1.0f); 19 | glm::vec3 up = glm::vec3(0.0f, 1.0f, 0.0f); 20 | glm::vec3 right; 21 | glm::vec3 worldUp = glm::vec3(0.0f, 1.0f, 0.0f); 22 | glm::mat4 projection; 23 | float yaw = YAW; 24 | float pitch = PITCH; 25 | float mouseSensitivity = SENSITIVITY; 26 | float fov = FOV; 27 | float nearD = 1.0f; 28 | float farD = 10000.0f; 29 | float ratio; 30 | 31 | Camera(glm::vec3 position) : position(position) { 32 | const GLFWvidmode* mode = glfwGetVideoMode(glfwGetPrimaryMonitor()); 33 | 34 | handleResolution(mode->width, mode->height); 35 | updateCameraVectors(); 36 | } 37 | 38 | void handleResolution(int width, int height) { 39 | ratio = (float)width / (float)height; 40 | 41 | projection = glm::perspective(glm::radians(fov), ratio, nearD, farD); 42 | } 43 | 44 | void updatePosition(glm::vec3 pos) { 45 | position = pos; 46 | } 47 | 48 | glm::mat4 getViewMatrix() { 49 | glm::vec3 intraVoxelPos = position - floor(position); 50 | return glm::lookAt(intraVoxelPos, intraVoxelPos + front, up); 51 | } 52 | 53 | void processMouseMovement(float xOffset, float yOffset) { 54 | xOffset *= mouseSensitivity; 55 | yOffset *= mouseSensitivity; 56 | 57 | yaw += xOffset; 58 | pitch += yOffset; 59 | 60 | if (pitch > 89.9f) pitch = 89.9f; 61 | if (pitch < -89.9f) pitch = -89.9f; 62 | 63 | updateCameraVectors(); 64 | } 65 | 66 | private: 67 | void updateCameraVectors() { 68 | glm::vec3 f; 69 | f.x = cos(glm::radians(yaw)) * cos(glm::radians(pitch)); 70 | f.y = sin(glm::radians(pitch)); 71 | f.z = sin(glm::radians(yaw)) * cos(glm::radians(pitch)); 72 | front = glm::normalize(f); 73 | right = glm::normalize(glm::cross(front, worldUp)); 74 | up = glm::normalize(glm::cross(right, front)); 75 | } 76 | }; 77 | 78 | #endif -------------------------------------------------------------------------------- /src/misc/noise.h: -------------------------------------------------------------------------------- 1 | #ifndef NOISE_H 2 | #define NOISE_H 3 | 4 | #include 5 | #include 6 | #include "../libraries/FastNoise/FastNoise.h" 7 | #include "utility.h" 8 | 9 | class Noise { 10 | public: 11 | Noise() { 12 | noise1.SetFrequency(0.02); 13 | noise1.SetFractalType(FastNoise::FBM); 14 | noise1.SetFractalOctaves(5); 15 | noise1.SetFractalLacunarity(2.0); 16 | 17 | noise2.SetFrequency(0.006); 18 | noise2.SetFractalType(FastNoise::FBM); 19 | noise2.SetFractalOctaves(5); 20 | noise2.SetFractalLacunarity(2.0); 21 | } 22 | 23 | void generateTerrainV1(uint8_t* voxels, uint64_t* opaqueMask, int seed) { 24 | noise1.SetSeed(seed); 25 | 26 | for (int x = 0; x < CS_P; x++) { 27 | for (int y = CS_P - 1; y--;) { 28 | for (int z = 0; z < CS_P; z++) { 29 | float val = ((noise1.GetSimplexFractal(x, y, z)) + 1.0f) / 2.0f; 30 | 31 | if (val > glm::smoothstep(0.15f, 1.0f, (float) y / (float) CS_P)) { 32 | int i = get_zxy_index(x, y, z); 33 | int i_above = get_zxy_index(x, y + 1, z); 34 | 35 | opaqueMask[(y * CS_P) + x] |= 1ull << z; 36 | 37 | switch (voxels[i_above]) { 38 | case 0: 39 | voxels[i] = 3; 40 | break; 41 | default: 42 | voxels[i] = 2; 43 | break; 44 | } 45 | } 46 | } 47 | } 48 | } 49 | } 50 | 51 | void generateTerrainV2(uint8_t* voxels, uint64_t* opaqueMask, int offsetX, int offsetZ, int seed) { 52 | noise2.SetSeed(seed); 53 | 54 | for (int x = 0; x < CS_P; x++) { 55 | for (int y = CS_P - 1; y--;) { 56 | for (int z = 0; z < CS_P; z++) { 57 | float val = (noise2.GetSimplexFractal((offsetX * CS) + x, y, (offsetZ * CS) + z) + 0.6f) / 1.35f; 58 | 59 | int i = get_zxy_index(x, y, z); 60 | 61 | if (val > (float) y / (float) CS_P) { 62 | int i_above = get_zxy_index(x, y + 1, z); 63 | 64 | opaqueMask[(y * CS_P) + x] |= 1ull << z; 65 | 66 | switch (voxels[i_above]) { 67 | case 0: 68 | voxels[i] = 3; 69 | break; 70 | default: 71 | voxels[i] = 2; 72 | break; 73 | } 74 | } 75 | else if (y < 25) { 76 | opaqueMask[(y * CS_P) + x] |= 1ull << z; 77 | voxels[i] = 1; 78 | } 79 | } 80 | } 81 | } 82 | } 83 | 84 | void generateWhiteNoiseTerrain(uint8_t* voxels, uint64_t* opaqueMask, int seed) { 85 | whiteNoise.SetSeed(seed); 86 | 87 | for (int x = 1; x < CS_P; x++) { 88 | for (int y = CS_P; y--;) { 89 | for (int z = 1; z < CS_P; z++) { 90 | float noise = (whiteNoise.GetWhiteNoise(x, y, z)); 91 | int i = get_zxy_index(x, y, z); 92 | 93 | if (noise > 0.5f) opaqueMask[(y * CS_P) + x] |= 1ull << z; 94 | 95 | if (noise > 0.8f) { 96 | voxels[i] = 1; 97 | } else if (noise > 0.6f) { 98 | voxels[i] = 2; 99 | } else if (noise > 0.5f) { 100 | voxels[i] = 3; 101 | } 102 | } 103 | } 104 | } 105 | } 106 | 107 | FastNoise noise1; 108 | FastNoise noise2; 109 | FastNoise whiteNoise; 110 | }; 111 | 112 | #endif -------------------------------------------------------------------------------- /src/misc/shader.h: -------------------------------------------------------------------------------- 1 | #ifndef SHADER_H 2 | #define SHADER_H 3 | 4 | #include 5 | #include 6 | 7 | #include 8 | #include 9 | #include 10 | #include 11 | 12 | class Shader { 13 | public: 14 | unsigned int ID; 15 | std::string vertex_name; 16 | std::string fragment_name; 17 | 18 | Shader(std::string vertex_name, std::string fragment_name): vertex_name(vertex_name), fragment_name(fragment_name) { 19 | std::string vShaderCode; 20 | std::fstream vertexFile("../src/shaders/" + vertex_name + ".vs", std::ios::in); 21 | if (vertexFile.is_open()) { 22 | std::stringstream buffer; 23 | buffer << vertexFile.rdbuf(); 24 | vShaderCode = buffer.str(); 25 | } else { 26 | std::cout << "COULD NOT OPEN SHADER FILE" << std::endl; 27 | } 28 | 29 | unsigned int vertex = glCreateShader(GL_VERTEX_SHADER); 30 | const char *vertex_c_str = vShaderCode.c_str(); 31 | glShaderSource(vertex, 1, &vertex_c_str, NULL); 32 | glCompileShader(vertex); 33 | checkCompileErrors(vertex, vertex_name, "VERTEX"); 34 | 35 | 36 | std::string fShaderCode; 37 | std::fstream fragmentFile("../src/shaders/" + fragment_name + ".fs", std::ios::in); 38 | if (fragmentFile.is_open()) { 39 | std::stringstream buffer; 40 | buffer << fragmentFile.rdbuf(); 41 | fShaderCode = buffer.str(); 42 | } else { 43 | std::cout << "COULD NOT OPEN SHADER FILE" << std::endl; 44 | } 45 | 46 | unsigned int fragment = glCreateShader(GL_FRAGMENT_SHADER); 47 | const char *frag_c_str = fShaderCode.c_str(); 48 | glShaderSource(fragment, 1, &frag_c_str, NULL); 49 | glCompileShader(fragment); 50 | checkCompileErrors(fragment, fragment_name, "FRAGMENT"); 51 | 52 | ID = glCreateProgram(); 53 | glAttachShader(ID, vertex); 54 | glAttachShader(ID, fragment); 55 | glLinkProgram(ID); 56 | checkCompileErrors(ID, "program", "PROGRAM"); 57 | 58 | glDeleteShader(vertex); 59 | glDeleteShader(fragment); 60 | 61 | printf("Shader '%s, %s' compiled with ID %u \n", vertex_name.c_str(), vertex_name.c_str(), ID); 62 | } 63 | 64 | void use() { 65 | glUseProgram(ID); 66 | } 67 | 68 | GLuint getUniformLocation(std::string name) { 69 | return glGetUniformLocation(ID, name.c_str()); 70 | } 71 | 72 | void setBool(const std::string &name, bool value) const { 73 | glUniform1i(glGetUniformLocation(ID, name.c_str()), (int)value); 74 | } 75 | 76 | void setInt(const std::string &name, int value) const { 77 | glUniform1i(glGetUniformLocation(ID, name.c_str()), value); 78 | } 79 | 80 | void setFloat(const std::string &name, float value) const { 81 | glUniform1f(glGetUniformLocation(ID, name.c_str()), value); 82 | } 83 | 84 | void setVec2(const std::string &name, const glm::vec2 &value) const { 85 | glUniform2fv(glGetUniformLocation(ID, name.c_str()), 1, &value[0]); 86 | } 87 | 88 | void setVec2(const std::string &name, float x, float y) const { 89 | glUniform2f(glGetUniformLocation(ID, name.c_str()), x, y); 90 | } 91 | 92 | void setVec3(const std::string &name, const glm::vec3 &value) const { 93 | glUniform3fv(glGetUniformLocation(ID, name.c_str()), 1, &value[0]); 94 | } 95 | 96 | void setVec3(const std::string &name, float x, float y, float z) const { 97 | glUniform3f(glGetUniformLocation(ID, name.c_str()), x, y, z); 98 | } 99 | 100 | void setIVec3(const std::string &name, const glm::ivec3 &value) const { 101 | glUniform3iv(glGetUniformLocation(ID, name.c_str()), 1, &value[0]); 102 | } 103 | 104 | void setVec4(const std::string &name, const glm::vec4 &value) const { 105 | glUniform4fv(glGetUniformLocation(ID, name.c_str()), 1, &value[0]); 106 | } 107 | 108 | void setVec4(const std::string &name, float x, float y, float z, float w) { 109 | glUniform4f(glGetUniformLocation(ID, name.c_str()), x, y, z, w); 110 | } 111 | 112 | void setMat2(const std::string &name, const glm::mat2 &mat) const { 113 | glUniformMatrix2fv(glGetUniformLocation(ID, name.c_str()), 1, GL_FALSE, &mat[0][0]); 114 | } 115 | 116 | void setMat3(const std::string &name, const glm::mat3 &mat) const { 117 | glUniformMatrix3fv(glGetUniformLocation(ID, name.c_str()), 1, GL_FALSE, &mat[0][0]); 118 | } 119 | 120 | void setMat4(const std::string &name, const glm::mat4 &mat) const { 121 | glUniformMatrix4fv(glGetUniformLocation(ID, name.c_str()), 1, GL_FALSE, &mat[0][0]); 122 | } 123 | 124 | private: 125 | void checkCompileErrors(GLuint shader, std::string name, std::string type) { 126 | GLint success; 127 | GLchar infoLog[1024]; 128 | if (type != "PROGRAM") { 129 | glGetShaderiv(shader, GL_COMPILE_STATUS, &success); 130 | if (!success) { 131 | glGetShaderInfoLog(shader, 1024, NULL, infoLog); 132 | std::cout << "ERROR::SHADER_COMPILATION_ERROR in: " << type << " in shader '" << name << "'\n" << infoLog << "\n -- --------------------------------------------------- -- " << std::endl; 133 | exit(1); 134 | } 135 | } else { 136 | glGetProgramiv(shader, GL_LINK_STATUS, &success); 137 | if(!success) { 138 | glGetProgramInfoLog(shader, 1024, NULL, infoLog); 139 | std::cout << "ERROR::PROGRAM_LINKING_ERROR of type: " << type << " in shader '" << name << "'\n" << infoLog << "\n -- --------------------------------------------------- -- " << std::endl; 140 | exit(1); 141 | } 142 | } 143 | } 144 | }; 145 | 146 | #endif -------------------------------------------------------------------------------- /src/misc/timer.h: -------------------------------------------------------------------------------- 1 | #ifndef TIMER_H 2 | #define TIMER_H 3 | 4 | #include 5 | #include 6 | #include 7 | 8 | class Timer { 9 | private: 10 | bool started = false; 11 | bool ended = false; 12 | std::chrono::time_point t1; 13 | std::string description; 14 | 15 | public: 16 | Timer(std::string description = "", bool start_ = false): description(description) { 17 | if (start_) { 18 | start(); 19 | } 20 | }; 21 | 22 | void start() { 23 | started = true; 24 | ended = false; 25 | t1 = std::chrono::high_resolution_clock::now(); 26 | } 27 | 28 | long long end() { 29 | if (!started || ended) return 0; 30 | auto t2 = std::chrono::high_resolution_clock::now(); 31 | long long duration_us = std::chrono::duration_cast(t2 - t1).count(); 32 | auto duration_ms = duration_us / 1000.0f; 33 | if (description != "") { 34 | std::cout << description << " took " << duration_us << "us (" << duration_ms << "ms)" << std::endl; 35 | } 36 | ended = true; 37 | return duration_us; 38 | } 39 | 40 | ~Timer() { 41 | end(); 42 | }; 43 | }; 44 | 45 | #endif -------------------------------------------------------------------------------- /src/misc/utility.h: -------------------------------------------------------------------------------- 1 | #ifndef UTILITY_H 2 | #define UTILITY_H 3 | 4 | #include 5 | #include "../mesher.h" 6 | 7 | inline int get_zxy_index(int x, int y, int z) { 8 | return z + (x * CS_P) + (y * CS_P2); 9 | } 10 | 11 | uint32_t get_xyz_key(int8_t x, int8_t y, int8_t z) { 12 | return (((uint32_t)z << 16) | ((uint32_t)y << 8) | (uint32_t)x); 13 | } 14 | 15 | glm::ivec3 parse_xyz_key(uint32_t key) { 16 | return glm::ivec3( 17 | (key & 255), 18 | (key >> 8 & 255), 19 | (key >> 16 & 255) 20 | ); 21 | } 22 | 23 | #endif -------------------------------------------------------------------------------- /src/rendering/chunk_renderer.h: -------------------------------------------------------------------------------- 1 | #ifndef CHUNK_RENDERER 2 | #define CHUNK_RENDERER 3 | 4 | #include 5 | #include 6 | #include 7 | 8 | static const int BUFFER_SIZE = 5e8; // 500 mb 9 | static const uint32_t QUAD_SIZE = 8; 10 | static const int MAX_DRAW_COMMANDS = 100000; 11 | 12 | struct BufferSlot { 13 | uint32_t startByte; 14 | uint32_t sizeBytes; 15 | }; 16 | 17 | struct DrawElementsIndirectCommand { 18 | uint32_t indexCount; // (count) Quad count * 6 19 | uint32_t instanceCount; // 1 20 | uint32_t firstIndex; // 0 21 | uint32_t baseQuad; // (baseVertex) Starting index in the SSBO 22 | uint32_t baseInstance; // Chunk x, y z, face index 23 | }; 24 | 25 | struct BufferFit { 26 | uint32_t pos; 27 | uint32_t space; 28 | std::vector::iterator iter; 29 | }; 30 | 31 | class ChunkRenderer { 32 | public: 33 | void init() { 34 | glGenVertexArrays(1, &VAO); 35 | glBindVertexArray(VAO); 36 | glGenBuffers(1, &commandBuffer); 37 | glGenBuffers(1, &SSBO); 38 | glBindBuffer(GL_SHADER_STORAGE_BUFFER, SSBO); 39 | glBufferStorage(GL_SHADER_STORAGE_BUFFER, BUFFER_SIZE, nullptr, GL_DYNAMIC_STORAGE_BIT); 40 | 41 | glGenBuffers(1, &IBO); 42 | int maxQuads = CS * CS * CS * 6; 43 | std::vector indices; 44 | for (uint32_t i = 0; i < maxQuads; i++) { 45 | indices.push_back((i << 2) | 2u); 46 | indices.push_back((i << 2) | 0u); 47 | indices.push_back((i << 2) | 1u); 48 | indices.push_back((i << 2) | 1u); 49 | indices.push_back((i << 2) | 3u); 50 | indices.push_back((i << 2) | 2u); 51 | } 52 | glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, IBO); 53 | glBufferData(GL_ELEMENT_ARRAY_BUFFER, indices.size(), indices.data(), GL_DYNAMIC_DRAW); 54 | 55 | glBindVertexArray(VAO); 56 | glBindBuffer(GL_DRAW_INDIRECT_BUFFER, commandBuffer); 57 | glBufferData(GL_DRAW_INDIRECT_BUFFER, MAX_DRAW_COMMANDS * sizeof(DrawElementsIndirectCommand), nullptr, GL_DYNAMIC_DRAW); 58 | glBindVertexArray(0); 59 | }; 60 | 61 | // TODO: Deallocate buffers 62 | ~ChunkRenderer() { }; 63 | 64 | DrawElementsIndirectCommand* getDrawCommand(int quadCount, uint32_t baseInstance) { 65 | unsigned int requestedSize = quadCount * QUAD_SIZE; 66 | 67 | // Allocate at the end if possible 68 | if ((BUFFER_SIZE - allocationEnd) > requestedSize) { 69 | auto slot = new BufferSlot({ allocationEnd, requestedSize }); 70 | usedSlots.push_back(slot); 71 | allocationEnd += requestedSize; 72 | return createCommand(*slot, baseInstance); 73 | } 74 | 75 | // Otherwise, iterate through and find gaps to allocate in 76 | // Slow! 77 | 78 | auto prev = usedSlots.begin(); 79 | BufferFit bestFit; 80 | bool foundFit = false; 81 | 82 | unsigned int spaceInFront = usedSlots.front()->startByte; 83 | if (spaceInFront >= requestedSize) { 84 | foundFit = true; 85 | bestFit = BufferFit({ 86 | 0, 87 | spaceInFront, 88 | usedSlots.begin() 89 | }); 90 | } 91 | 92 | if (usedSlots.size() == 1) { 93 | auto slot = new BufferSlot({ usedSlots.back()->startByte + usedSlots.back()->sizeBytes, requestedSize }); 94 | usedSlots.insert(usedSlots.end(), slot); 95 | return createCommand(*slot, baseInstance); 96 | } 97 | 98 | for (auto it = usedSlots.begin() + 1; it != usedSlots.end(); ++it) { 99 | unsigned int pos = (*prev)->startByte + (*prev)->sizeBytes; 100 | unsigned int spaceBetween = (*it)->startByte - pos; 101 | if (spaceBetween >= requestedSize && (!foundFit || spaceBetween < bestFit.space)) { 102 | foundFit = true; 103 | bestFit = BufferFit({ 104 | pos, 105 | spaceBetween, 106 | it 107 | }); 108 | } 109 | prev = it; 110 | } 111 | 112 | if (foundFit) { 113 | auto slot = new BufferSlot({ bestFit.pos, requestedSize }); 114 | usedSlots.insert(bestFit.iter, slot); 115 | return createCommand(*slot, baseInstance); 116 | } 117 | 118 | auto slot = new BufferSlot({ usedSlots.back()->startByte + usedSlots.back()->sizeBytes, requestedSize }); 119 | usedSlots.insert(usedSlots.end(), slot); 120 | return createCommand(*slot, baseInstance); 121 | }; 122 | 123 | void removeDrawCommand(const DrawElementsIndirectCommand* command) { 124 | for (auto it = begin(usedSlots); it != end(usedSlots); ++it) { 125 | if ((*it)->startByte == (command->baseQuad >> 2) * QUAD_SIZE) { 126 | usedSlots.erase(it); 127 | return; 128 | } 129 | } 130 | } 131 | 132 | void buffer(const DrawElementsIndirectCommand& command, void* vertices) { 133 | glBindBuffer(GL_SHADER_STORAGE_BUFFER, SSBO); 134 | glBufferSubData( 135 | GL_SHADER_STORAGE_BUFFER, 136 | (command.baseQuad >> 2) * QUAD_SIZE, 137 | (command.indexCount / 6) * QUAD_SIZE, 138 | vertices 139 | ); 140 | glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0); 141 | } 142 | 143 | inline void addDrawCommand(const DrawElementsIndirectCommand& command) { 144 | drawCommands.insert(drawCommands.end(), command); 145 | }; 146 | 147 | void render(Shader& shader, Camera& camera) { 148 | int numCommands = drawCommands.size(); 149 | 150 | if (numCommands == 0) { 151 | return; 152 | } 153 | 154 | shader.use(); 155 | shader.setMat4("u_projection", camera.projection); 156 | shader.setMat4("u_view", camera.getViewMatrix()); 157 | shader.setVec3("eye_position", camera.position); 158 | 159 | glm::ivec3 intCamPosition = glm::ivec3(floor(camera.position)); 160 | shader.setIVec3("eye_position_int", intCamPosition); 161 | 162 | glBindBuffer(GL_DRAW_INDIRECT_BUFFER, commandBuffer); 163 | glBufferData(GL_DRAW_INDIRECT_BUFFER, numCommands * sizeof(DrawElementsIndirectCommand), drawCommands.data(), GL_DYNAMIC_DRAW); 164 | 165 | glBindVertexArray(VAO); 166 | glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, IBO); 167 | glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, SSBO); 168 | 169 | glMultiDrawElementsIndirect( 170 | GL_TRIANGLES, 171 | GL_UNSIGNED_INT, 172 | (void*)0, 173 | numCommands, 174 | 0 175 | ); 176 | 177 | glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, 0); 178 | glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); 179 | glBindBuffer(GL_DRAW_INDIRECT_BUFFER, 0); 180 | glBindVertexArray(0); 181 | 182 | // clear but don't deallocate 183 | drawCommands.clear(); 184 | }; 185 | 186 | private: 187 | DrawElementsIndirectCommand* createCommand(BufferSlot& slot, uint32_t baseInstance) { 188 | return new DrawElementsIndirectCommand({ 189 | (slot.sizeBytes / QUAD_SIZE) * 6, 190 | 1, 191 | 0, 192 | (slot.startByte / QUAD_SIZE) << 2, 193 | baseInstance 194 | }); 195 | } 196 | 197 | unsigned int VAO = 0; 198 | unsigned int IBO = 0; 199 | unsigned int SSBO = 0; 200 | unsigned int commandBuffer = 0; 201 | 202 | std::vector usedSlots; 203 | std::vector drawCommands; 204 | uint32_t allocationEnd = 0; 205 | }; 206 | 207 | #endif -------------------------------------------------------------------------------- /src/shaders/main.fs: -------------------------------------------------------------------------------- 1 | #version 460 core 2 | 3 | layout(location=0) out vec3 out_color; 4 | 5 | in VS_OUT { 6 | vec3 pos; 7 | flat vec3 normal; 8 | flat vec3 color; 9 | } fs_in; 10 | 11 | uniform vec3 eye_position; 12 | 13 | const vec3 diffuse_color = vec3(0.15, 0.15, 0.15); 14 | const vec3 rim_color = vec3(0.04, 0.04, 0.04); 15 | const vec3 sun_position = vec3(250.0, 1000.0, 750.0) * 10000; 16 | 17 | void main() { 18 | vec3 L = normalize(sun_position - fs_in.pos); 19 | vec3 V = normalize(eye_position - fs_in.pos); 20 | 21 | float rim = 1 - max(dot(V, fs_in.normal), 0.0); 22 | rim = smoothstep(0.6, 1.0, rim); 23 | 24 | out_color = 25 | fs_in.color + 26 | (diffuse_color * max(0, dot(L, fs_in.normal))) + 27 | (rim_color * vec3(rim, rim, rim)) 28 | ; 29 | } -------------------------------------------------------------------------------- /src/shaders/main.vs: -------------------------------------------------------------------------------- 1 | #version 460 core 2 | 3 | struct QuadData { 4 | uint quadData1; 5 | uint quadData2; 6 | }; 7 | 8 | layout(binding = 0, std430) readonly buffer ssbo1 { 9 | QuadData data[]; 10 | }; 11 | 12 | uniform mat4 u_view; 13 | uniform mat4 u_projection; 14 | 15 | uniform ivec3 eye_position_int; 16 | 17 | out VS_OUT { 18 | out vec3 pos; 19 | flat vec3 normal; 20 | flat vec3 color; 21 | } vs_out; 22 | 23 | const vec3 normalLookup[6] = { 24 | vec3( 0, 1, 0 ), 25 | vec3(0, -1, 0 ), 26 | vec3( 1, 0, 0 ), 27 | vec3( -1, 0, 0 ), 28 | vec3( 0, 0, 1 ), 29 | vec3( 0, 0, -1 ) 30 | }; 31 | 32 | const vec3 colorLookup[8] = { 33 | vec3(0.2, 0.659, 0.839), 34 | vec3(0.302, 0.302, 0.302), 35 | vec3(0.278, 0.600, 0.141), 36 | vec3(0.1, 0.1, 0.6), 37 | vec3(0.1, 0.6, 0.6), 38 | vec3(0.6, 0.1, 0.6), 39 | vec3(0.6, 0.6, 0.1), 40 | vec3(0.6, 0.1, 0.1) 41 | }; 42 | 43 | const int flipLookup[6] = int[6](1, -1, -1, 1, -1, 1); 44 | 45 | void main() { 46 | ivec3 chunkOffsetPos = ivec3(gl_BaseInstance&255u, gl_BaseInstance>>8&255u, gl_BaseInstance>>16&255u) * 62; 47 | uint face = gl_BaseInstance>>24; 48 | 49 | int vertexID = int(gl_VertexID&3u); 50 | uint ssboIndex = gl_VertexID >> 2u; 51 | 52 | uint quadData1 = data[ssboIndex].quadData1; 53 | uint quadData2 = data[ssboIndex].quadData2; 54 | 55 | ivec3 iVertexPos = ivec3(quadData1, quadData1 >> 6u, quadData1 >> 12u) & 63; 56 | iVertexPos += chunkOffsetPos; 57 | 58 | int w = int((quadData1 >> 18u)&63u), h = int((quadData1 >> 24u)&63u); 59 | uint wDir = (face & 2) >> 1, hDir = 2 - (face >> 2); 60 | int wMod = vertexID >> 1, hMod = vertexID & 1; 61 | 62 | iVertexPos[wDir] += (w * wMod * flipLookup[face]); 63 | iVertexPos[hDir] += (h * hMod); 64 | 65 | vs_out.pos = iVertexPos; 66 | vs_out.normal = normalLookup[face]; 67 | vs_out.color = colorLookup[(quadData2&255u) - 1]; 68 | 69 | vec3 vertexPos = iVertexPos - eye_position_int; 70 | vertexPos[wDir] += 0.0007 * flipLookup[face] * (wMod * 2 - 1); 71 | vertexPos[hDir] += 0.0007 * (hMod * 2 - 1); 72 | 73 | gl_Position = u_projection * u_view * vec4(vertexPos, 1); 74 | } --------------------------------------------------------------------------------