repo_name
stringlengths 5
122
| path
stringlengths 3
232
| text
stringlengths 6
1.05M
|
|---|---|---|
danesh-d/do-sort
|
src/bubble_sort.h
|
<reponame>danesh-d/do-sort<gh_stars>0
#ifndef BUBBLE_SORT_H
#define BUBBLE_SORT_H
#include "do_sort.h"
using namespace std;
namespace do_sort {
// --- Bubble sort.
template <class T>
class bubble_sort : public sort<T> {
protected:
void specific_do_sort() {
LL n = sort<T>::size();
if (n <= 1) {
return;
}
LL upper_bound = n - 1;
LL lower_bound = 0;
bool swapped = true;
if (sort<T>::asc) {
// The data will be sorted in ascending order.
while (swapped) {
swapped = false;
LL tmp_upper = 0;
LL tmp_lower = 0;
for (LL i = lower_bound; i < upper_bound; ++i) {
if (sort<T>::v[i] > sort<T>::v[i + 1]) {
swap(sort<T>::v[i], sort<T>::v[i + 1]);
swapped = true;
if (tmp_upper == 0) {
lower_bound = i - 1;
}
// Save the place of last swap. The process in the next round
// will continue up to this point since the rest of the list
// will be remain sorted if no swap has happened.
tmp_upper = i;
} else {
// This might slow down a bit for an array with uniformly
// distributed random numbers. But if the list is partially
// sorted at the begining then it will move the lower bound so
// in the next round, the sorting will start after the sorted
// sequence.
if (!swapped) {
tmp_lower = i;
}
}
}
// Shrink the range of the sorting since it is needed to continue
// the process up to the last non-sorted element in the list. Also,
// jump over all sorted elements at the begining of teh array.
upper_bound = tmp_upper;
lower_bound = tmp_lower;
}
} else {
// The data will be sorted in descending order.
while (swapped) {
swapped = false;
LL tmp_upper = 0;
LL tmp_lower = 0;
for (LL i = lower_bound; i < upper_bound; ++i) {
if (sort<T>::v[i] < sort<T>::v[i + 1]) {
swap(sort<T>::v[i], sort<T>::v[i + 1]);
swapped = true;
if (tmp_upper == 0) {
lower_bound = i - 1;
}
// Save the place of last swap. The process in the next round
// will continue up to this point since the rest of the list
// will be remain sorted if no swap has happened.
tmp_upper = i;
} else {
// This might slow down a bit for an array with uniformly
// distributed random numbers. But if the list is partially
// sorted at the begining then it will move the lower bound so
// in the next round, the sorting will start after the sorted
// sequence.
if (!swapped) {
tmp_lower = i;
}
}
}
// Shrink the range of the sorting since it is needed to continue
// the process up to the last non-sorted element in the list. Also,
// jump over all sorted elements at the begining of teh array.
upper_bound = tmp_upper;
lower_bound = tmp_lower;
}
}
}
public:
bubble_sort() {
}
virtual ~bubble_sort() {
}
};
}
#endif /* BUBBLE_SORT_H */
|
danesh-d/do-sort
|
src/BST.h
|
#ifndef BST_H
#define BST_H
#include "do_sort.h"
using namespace std;
namespace do_sort {
// --- Binary Search Tree (BST).
template <class T>
class BST {
private:
ULL num_nodes;
vector<T> intern_vec;
// The structure uses only pointers to the original data in the tree.
// Therefore, the data will be dumped when it is needed into an internal
// vectore before it is returned. This is mostly done for the sake of
// efficiency first to avoid copying data and also to support non-POD data
// types like strings.
struct btree {
T *key;
struct btree *left, *right;
};
struct btree *root;
// Add a new hanging node.
struct btree* newNode(T *key) {
struct btree *temp = new btree;
temp->key = key;
temp->left = temp->right = nullptr;
return temp;
}
struct btree* tree_insert(struct btree *node, T *key) {
// If the tree is empty, return a new node.
if (node == nullptr) {
// The first node is always root.
if (num_nodes == 1) {
root = newNode(key);
return root;
}
return newNode(key);
}
// Otherwise, recur down the tree.
if (*key <= *(node->key)) {
node->left = tree_insert(node->left, key);
} else if (key > node->key) {
node->right = tree_insert(node->right, key);
}
return node;
}
// Traverse the BST and return all sorted nodes in the ascending order.
void tree_inorder_ascending(struct btree *node) {
if (node != nullptr) {
tree_inorder_ascending(node->left);
intern_vec.push_back(*(node->key));
tree_inorder_ascending(node->right);
}
}
// Traverse the BST and return all sorted nodes in the descending order.
void tree_inorder_descending(struct btree *node) {
if (node != nullptr) {
tree_inorder_descending(node->right);
intern_vec.push_back(*(node->key));
tree_inorder_descending(node->left);
}
}
// Destroy the subtree from a node, or the whole tree if node points to
// the root of the BST.
void tree_destroy(struct btree *node) {
if (node != nullptr) {
// First destroy subtrees.
tree_destroy(node->left);
tree_destroy(node->right);
// Node release the node and make to point to nullptr.
delete node;
--num_nodes;
node->left = nullptr;
node->right = nullptr;
node = nullptr;
}
}
// Return depth of the tree. Zero will be returned if the tree is empty.
LL tree_depth(struct btree *node) {
return node ? max(tree_depth(node->left),
tree_depth(node->right)) + 1
: 0;
}
// Return number of nodes in the tree. Note that the result of this
// function will be equal to "num_nodes" variable only if the function is
// called from root. Otherwise, the function will retuen number of the
// nodes from the given node.
LL tree_num_nodes(struct btree *node) {
return node ? tree_num_nodes(node->left) +
tree_num_nodes(node->right) + 1
: 0;
}
void clear_tree() {
root = nullptr;
num_nodes = 0;
intern_vec.clear();
}
protected:
bool is_empty() {
return (root == nullptr);
}
// Insert a key into a BST. It will remain sorted.
void insert(T *key) {
++num_nodes;
tree_insert(root, key);
}
// Dump the BST in ascending or descending order.
void dump(vector<T>& vec, bool asc) {
if (asc) {
tree_inorder_ascending(root);
} else {
tree_inorder_descending(root);
}
vec = intern_vec;
}
// Destroy the current tree.
void destroy() {
tree_destroy(root);
clear_tree();
}
public:
BST() {
clear_tree();
}
virtual ~BST() {
// If the tree is not destroyed yet, destroy it before the class'
// instance is being released.
if (num_nodes > 0) {
destroy();
}
}
};
}
#endif /* BST_H */
|
danesh-d/do-sort
|
src/strand_sort.h
|
<gh_stars>0
#ifndef STRAND_SORT_H
#define STRAND_SORT_H
#include "do_sort.h"
using namespace std;
namespace do_sort {
// --- Strand sort implementation.
template <class T>
class strand_sort : public sort<T> {
private:
list<T> sorted_list;
protected:
// Perform the strand sort. This sorting algorithm utilizes a linked list
// instead of a simple array (vector) because frequent add/remove
// operations are needed to be done which can be done efficiently in a
// linked list with lower cost.
void specific_do_sort() {
if (sort<T>::size() <= 1) {
return;
}
// Copy the vector which holds all input data to a linked list. The
// interface is kept as vector to maintain compatibility and consistency
// with all other sorting algorithms.
copy(sort<T>::v.begin(), sort<T>::v.end(), back_inserter(sort<T>::l));
sort<T>::v.clear();
// This list holds sorted sub-list in each iteration.
list<T> sorted_sublist;
while (!sort<T>::l.empty()) {
// Copy the head of the list into the sorted sub-list and then add all
// elements which are less or equal to the recently added element to
// the sub-list iteratively.
sorted_sublist.push_back(sort<T>::l.front());
sort<T>::l.pop_front();
for (typename list<T>::iterator it = sort<T>::l.begin();
it != sort<T>::l.end();) {
if (sorted_sublist.back() <= *it) {
sorted_sublist.push_back(*it);
it = sort<T>::l.erase(it);
} else {
++it;
}
}
// Merge the sorted sub-list with the final sorted list. The sub-list
// will be released after each merge automatically.
sorted_list.merge(sorted_sublist);
}
if (!sort<T>::asc) {
// The sorted list should be in descending order so just revert the
// list. Since it is a linked list, so the complexity will be O(n)
// which is quite low.
sorted_list.reverse();
}
copy(sorted_list.begin(),
sorted_list.end(),
back_inserter(sort<T>::v));
sorted_list.clear();
}
public:
strand_sort() {
}
virtual ~strand_sort() {
}
};
}
#endif /* STRNAD_SORT_H */
|
danesh-d/do-sort
|
src/comb_sort.h
|
#ifndef COMB_SORT_H
#define COMB_SORT_H
#include "do_sort.h"
using namespace std;
namespace do_sort {
// --- Heap sort.
template <class T>
class comb_sort : public sort<T> {
private:
float shrinkFactor;
int nextGap(int gap) {
gap = (int)(gap / shrinkFactor);
return gap < 1 ? 1 : gap;
}
protected:
void specific_do_sort() {
LL n = sort<T>::size();
if (n <= 1) {
return;
}
LL gap = n;
bool swapped = true;
// Loop over the input data until the gap is not equal to one and at
// at least one swap has been done during the last traverse.
while (gap != 1 || swapped) {
gap = nextGap(gap);
swapped = false;
// Sort the data within the current gap.
for (LL i = 0; i < n - gap; ++i) {
if (sort<T>::asc) {
if (sort<T>::v[i] > sort<T>::v[i + gap]) {
swap(sort<T>::v[i], sort<T>::v[i + gap]);
swapped = true;
}
} else {
if (sort<T>::v[i] < sort<T>::v[i + gap]) {
swap(sort<T>::v[i], sort<T>::v[i + gap]);
swapped = true;
}
}
}
}
}
public:
comb_sort() {
// This sorting algorithm is in fact an improvement to Bubble sort where
// inversions are removed one by one. In this algorithm a gap is used
// which is more than 1 (unlike Bubble sort with gap of size 1) so at
// each swap more then one inversion is removed. The gap size is reduced
// in each iteration by factor of 1.3 which is proven to be the best
// constant.
shrinkFactor = 1.3;
}
virtual ~comb_sort() {
}
};
}
#endif /* COMB_SORT_H */
|
danesh-d/do-sort
|
src/merge_sort.h
|
#ifndef MERGE_SORT_H
#define MERGE_SORT_H
#include "do_sort.h"
using namespace std;
namespace do_sort {
// --- Merge sort.
template <class T>
class merge_sort : public sort<T> {
private:
vector<T> aux;
void recursive_msort(vector<T>& v,
vector<T>& aux,
LL low,
LL high,
bool asc) {
if (low < high) {
LL mid = (low + high) >> 1;
// The original list is partitioned at the middle and each part will
// be sorted separately while each sub-list will be divided and sorted
// recursively until the list consists of two elements and then they
// wil be merged.
recursive_msort(v, aux, low, mid, asc);
recursive_msort(v, aux, mid + 1, high, asc);
// Both lists partitioned at the middle have been sorted and now will
// be merged while the order will be preserved.
sort<T>::merge(v, aux, low, mid + 1, high, asc);
}
}
protected:
void specific_do_sort() {
LL n = sort<T>::size();
if (n <= 1) {
return;
}
aux.resize(n);
recursive_msort(sort<T>::v, aux, 0, n - 1, sort<T>::asc);
aux.clear();
}
public:
merge_sort() {
}
virtual ~merge_sort() {
aux.clear();
}
};
}
#endif /* MERGE_SORT_H */
|
danesh-d/do-sort
|
src/gnome_sort.h
|
#ifndef GNOME_SORT_H
#define GNOME_SORT_H
#include "do_sort.h"
using namespace std;
// Note: This method can be highly ineffective.
namespace do_sort {
// --- Gnome sort.
template <class T>
class gnome_sort : public sort<T> {
private:
void gnome_sort_bounded(LL upper_bound, bool asc) {
LL pos = upper_bound;
if (asc) {
// Sort the data in ascending order.
while ((pos > 0) && (sort<T>::v[pos - 1] > sort<T>::v[pos])) {
swap(sort<T>::v[pos], sort<T>::v[pos - 1]);
--pos;
}
} else {
// Sort the data in descending order.
while ((pos > 0) && (sort<T>::v[pos - 1] < sort<T>::v[pos])) {
swap(sort<T>::v[pos], sort<T>::v[pos - 1]);
--pos;
}
}
}
protected:
void specific_do_sort() {
LL n = sort<T>::size();
if (n <= 1) {
return;
}
for (LL i = 1; i < n; ++i) {
gnome_sort_bounded(i, sort<T>::asc);
}
}
public:
gnome_sort() {
}
virtual ~gnome_sort() {
}
};
}
#endif /* GNOME_SORT_H */
|
DonLakeFlyer/VHFCollarTracker
|
custom/src/VHFTrackerSettings.h
|
/****************************************************************************
*
* (c) 2009-2016 QGROUNDCONTROL PROJECT <http://www.qgroundcontrol.org>
*
* QGroundControl is licensed according to the terms in the file
* COPYING.md in the root of the source code directory.
*
****************************************************************************/
#pragma once
#include "SettingsGroup.h"
class VHFTrackerSettings : public SettingsGroup
{
Q_OBJECT
public:
VHFTrackerSettings(QObject* parent = nullptr);
Q_PROPERTY(Fact* altitude READ altitude CONSTANT)
Q_PROPERTY(Fact* divisions READ divisions CONSTANT)
Q_PROPERTY(Fact* tagId READ tagId CONSTANT)
Q_PROPERTY(Fact* frequency READ frequency CONSTANT)
Q_PROPERTY(Fact* frequencyDelta READ frequencyDelta CONSTANT)
Q_PROPERTY(Fact* pulseDuration READ pulseDuration CONSTANT)
Q_PROPERTY(Fact* intraPulse1 READ intraPulse1 CONSTANT)
Q_PROPERTY(Fact* intraPulse2 READ intraPulse2 CONSTANT)
Q_PROPERTY(Fact* intraPulseUncertainty READ intraPulseUncertainty CONSTANT)
Q_PROPERTY(Fact* intraPulseJitter READ intraPulseJitter CONSTANT)
Q_PROPERTY(Fact* maxPulse READ maxPulse CONSTANT)
Q_PROPERTY(Fact* gain READ gain CONSTANT)
Fact* altitude (void);
Fact* divisions (void);
Fact* tagId (void);
Fact* frequency (void);
Fact* frequencyDelta (void);
Fact* pulseDuration (void);
Fact* intraPulse1 (void);
Fact* intraPulse2 (void);
Fact* intraPulseUncertainty (void);
Fact* intraPulseJitter (void);
Fact* maxPulse (void);
Fact* gain (void);
private:
SettingsFact* _altitudeFact;
SettingsFact* _divisionsFact;
SettingsFact* _tagIdFact;
SettingsFact* _frequencyFact;
SettingsFact* _frequencyDeltaFact;
SettingsFact* _pulseDurationFact;
SettingsFact* _intraPulse1Fact;
SettingsFact* _intraPulse2Fact;
SettingsFact* _intraPulseUncertaintyFact;
SettingsFact* _intraPulseJitterFact;
SettingsFact* _maxPulseFact;
SettingsFact* _gainFact;
static const char* _settingsGroup;
static const char* _altitudeFactName;
static const char* _divisionsFactName;
static const char* _tagIdFactName;
static const char* _frequencyFactName;
static const char* _frequencyDeltaFactName;
static const char* _pulseDurationFactName;
static const char* _intraPulse1FactName;
static const char* _intraPulse2FactName;
static const char* _intraPulseUncertaintyFactName;
static const char* _intraPulseJitterFactName;
static const char* _maxPulseFactName;
static const char* _gainFactName;
};
|
DonLakeFlyer/VHFCollarTracker
|
custom/src/VHFTrackerQGCPlugin.h
|
<filename>custom/src/VHFTrackerQGCPlugin.h
#pragma once
#include "QGCCorePlugin.h"
#include "QmlObjectListModel.h"
#include "SettingsFact.h"
#include "VHFTrackerQGCOptions.h"
#include "QGCLoggingCategory.h"
#include <QElapsedTimer>
#include <QGeoCoordinate>
#include <QTimer>
class VHFTrackerSettings;
Q_DECLARE_LOGGING_CATEGORY(VHFTrackerQGCPluginLog)
class VHFTrackerQGCPlugin : public QGCCorePlugin
{
Q_OBJECT
public:
VHFTrackerQGCPlugin(QGCApplication* app, QGCToolbox* toolbox);
~VHFTrackerQGCPlugin();
Q_PROPERTY(VHFTrackerSettings* vhfSettings MEMBER _vhfSettings CONSTANT)
Q_PROPERTY(qreal beepStrength MEMBER _beepStrength NOTIFY beepStrengthChanged)
Q_PROPERTY(qreal temp MEMBER _temp NOTIFY tempChanged)
Q_PROPERTY(int bpm MEMBER _bpm NOTIFY bpmChanged)
Q_PROPERTY(QVariantList angleRatios MEMBER _rgAngleRatios NOTIFY angleRatiosChanged)
Q_PROPERTY(int strongestAngle MEMBER _strongestAngle NOTIFY strongestAngleChanged)
Q_PROPERTY(int strongestPulsePct MEMBER _strongestPulsePct NOTIFY strongestPulsePctChanged)
Q_PROPERTY(bool flightMachineActive MEMBER _flightMachineActive NOTIFY flightMachineActiveChanged)
Q_PROPERTY(int vehicleFrequency MEMBER _vehicleFrequency NOTIFY vehicleFrequencyChanged)
Q_PROPERTY(int missedPulseCount MEMBER _missedPulseCount NOTIFY missedPulseCountChanged)
Q_INVOKABLE void start (void);
Q_INVOKABLE void cancelAndReturn(void);
Q_INVOKABLE void sendTag (void);
// Overrides from QGCCorePlugin
QString brandImageIndoor (void) const final;
QString brandImageOutdoor (void) const final;
QVariantList& settingsPages (void) final;
QVariantList& instrumentPages (void) final;
bool mavlinkMessage (Vehicle* vehicle, LinkInterface* link, mavlink_message_t message) final;
QGCOptions* options (void) final { return qobject_cast<QGCOptions*>(_vhfQGCOptions); }
bool adjustSettingMetaData (const QString& settingsGroup, FactMetaData& metaData) final;
// Overrides from QGCTool
void setToolbox(QGCToolbox* toolbox) final;
signals:
void beepStrengthChanged (qreal beepStrength);
void tempChanged (qreal temp);
void bpmChanged (int bpm);
void angleRatiosChanged (void);
void strongestAngleChanged (int strongestAngle);
void strongestPulsePctChanged (int strongestPulsePct);
void flightMachineActiveChanged (bool flightMachineActive);
void vehicleFrequencyChanged (int vehicleFrequency);
void missedPulseCountChanged (int missedPulseCount);
private slots:
void _vehicleStateRawValueChanged (QVariant rawValue);
void _nextVehicleState (void);
void _detectComplete (void);
void _delayComplete (void);
void _targetValueFailed (void);
void _updateFlightMachineActive (bool flightMachineActive);
void _mavCommandResult (int vehicleId, int component, int command, int result, bool noResponseFromVehicle);
void _simulatePulse (void);
void _vhfCommandAckFailed (void);
private:
typedef enum {
CommandTakeoff,
CommandSetHeading,
CommandDelay
} VehicleStateCommand_t;
typedef struct {
VehicleStateCommand_t command;
Fact* fact;
int targetValueWaitSecs;
double targetValue;
double targetVariance;
} VehicleState_t;
void _handleVHFCommandAck (const mavlink_debug_float_array_t& debug_float_array);
void _handleVHFPulse (const mavlink_debug_float_array_t& debug_float_array);
void _rotateVehicle (Vehicle* vehicle, double headingDegrees);
void _say (QString text);
bool _armVehicleAndValidate (Vehicle* vehicle);
bool _setRTLFlightModeAndValidate (Vehicle* vehicle);
void _sendCommandAndVerify (Vehicle* vehicle, MAV_CMD command, double param1 = 0.0, double param2 = 0.0, double param3 = 0.0, double param4 = 0.0, double param5 = 0.0, double param6 = 0.0, double param7 = 0.0);
void _takeoff (Vehicle* vehicle, double takeoffAltRel);
void _resetStateAndRTL (void);
int _rawPulseToPct (double rawPulse);
void _sendVHFCommand (Vehicle* vehicle, LinkInterface* link, uint32_t vhfCommandId, const mavlink_message_t& msg);
void _handleSimulatedTagCommand (const mavlink_debug_float_array_t& debug_float_array);
void _handleSimulatedStartDetection (const mavlink_debug_float_array_t& debug_float_array);
void _handleSimulatedStopDetection (const mavlink_debug_float_array_t& debug_float_array);
QString _vhfCommandIdToText (uint32_t vhfCommandId);
void _sendSimulatedVHFCommandAck (uint32_t vhfCommandId);
void _startFlight (void);
QVariantList _settingsPages;
QVariantList _instrumentPages;
int _vehicleStateIndex;
QList<VehicleState_t> _vehicleStates;
QList<double> _rgPulseValues;
QList<double> _rgAngleStrengths;
QVariantList _rgAngleRatios;
QStringList _rgStringAngleStrengths;
int _strongestAngle;
int _strongestPulsePct;
bool _flightMachineActive;
double _firstHeading;
int _firstSlice;
int _nextSlice;
int _cSlice;
qreal _beepStrength;
qreal _temp;
int _bpm;
QElapsedTimer _elapsedTimer;
QTimer _delayTimer;
QTimer _targetValueTimer;
bool _simulate;
QTimer _simPulseTimer;
QTimer _vhfCommandAckTimer;
uint32_t _vhfCommandAckExpected;
VHFTrackerQGCOptions* _vhfQGCOptions;
VHFTrackerSettings* _vhfSettings;
int _vehicleFrequency;
int _lastPulseSendIndex;
int _missedPulseCount;
// Simulator values
uint32_t _simulatorTagId = 0;
uint32_t _simulatorFrequency;
uint32_t _simulatorPulseDuration;
uint32_t _simulatorIntraPulse1;
uint32_t _simulatorIntraPulse2;
uint32_t _simulatorIntraPulseUncertainty;
uint32_t _simulatorIntraPulseJitter;
float _simulatorMaxPulse;
};
|
iFindTA/PBMultiPackage
|
Pods/PBKits/NHUtilSetsPro/Utils/UIImage+PBHelper.h
|
//
// UIImage+PBHelper.h
// NHUtilSetsPro
//
// Created by <NAME> on 16/4/14.
// Copyright © 2016年 <NAME>. All rights reserved.
//
#import <UIKit/UIKit.h>
NS_ASSUME_NONNULL_BEGIN
@interface UIImage (PBHelper)
/**
* @brief load image from content path that not cached in memory
*
* @param name the image's name
*
* @attention: it will not work if you set imageassets!!!
*
* @return the image
*/
+ (nullable UIImage *)pb_imagePathed:(NSString *)name;
/**
* @brief load image from content path that not cached in memory
*
* @param name the image's name
* @param ext jpg or png, default is png
*
* @attention: it will not work if you set imageassets!!!
*
* @return the image
*/
+ (nullable UIImage *)pb_imagePathed:(NSString *)name extention:(nullable NSString *)ext;
/**
* @brief Judging Method
*
* @param image other image
*
* @return whether only the two image is equal
*/
- (BOOL)pb_isEqualTo:(UIImage *)image;
/**
* @brief generate image
*
* @param color the image's color
*
* @return the image from color
*/
+ (UIImage *)pb_imageWithColor:(UIColor *)color;
/**
convert image to color from a CGPoint
@param pt point for destnation
@return color
*/
- (UIColor * _Nullable)pb_image2Color4Point:(CGPoint)pt;
/**
* @brief blur image
*
* @param blurAmount blur level, default is 0.5
*
* @return the blured image
*/
- (UIImage *)pb_blurredImage:(CGFloat)level;
/**
* @brief generate small image
*
* @param bounds the destnation image's frame
*
* @return the cropped image
*/
- (UIImage *)pb_croppedBounds:(CGRect)bounds;
/**
* @brief scale image
*
* @param dstSize the destnation size
*
* @return the scaled image
*/
- (UIImage *)pb_scaleToSize:(CGSize)dstSize DEPRECATED_MSG_ATTRIBUTE("use pb_scaleToSize: keepAspect: method instead");
/**
* @brief scale image
*
* @param dstSize the destnation size
* @param keep whether keep image's width/height scale info
*
* @return the scaled image
*/
- (UIImage *)pb_scaleToSize:(CGSize)dstSize keepAspect:(BOOL)keep;
/**
* @brief generate round image
*
* @return the round image
*/
- (UIImage *)pb_roundImage;
/**
* @brief generate round image
*
* @param bWidth the round image's border width
* @param color the round image's border color
*
* @return the round image
*/
- (UIImage *)pb_roundImageWithBorderWidth:(int)bWidth withColor:(UIColor *)color;
/**
* @brief generate round corner image
*
* @param radius the round corner radius
*
* @return the round corner image
*/
- (UIImage *)pb_roundCornerWithRadius:(int)radius;
/**
* @brief generate round corner image
*
* @param radius the round corner redius
* @param bWidth the border width
* @param bColor the border color default is white
*
* @return the round corner image
*/
- (UIImage *)pb_roundCornerWithRadius:(int)radius withBorderWidth:(int)bWidth withBorderColor:(UIColor *)bColor;
/**
* @brief generate dark image
*
* @param color dark color
* @param level dark level
*
* @return the dark image
*/
- (UIImage *)pb_darkColor:(UIColor *)color lightLevel:(CGFloat)level;
/**
* @brief generate image for iconfont
*
* To use this function you must add custom icon font into your plist file
* for the key 'Fonts provided by application : iconfont.ttf'
*
* @param fontName iconfont name default is named of 'iconfont'
* @param name icon name
* @param size the image's size
* @param color the image's color default is white color
*
* @return the icon image
*/
+ (UIImage *)pb_iconFont:(NSString * _Nullable)fontName withName:(NSString *)name withSize:(NSInteger)size withColor:(UIColor *)color;
/*!
* @brief generate round corner image
*
* @param radius the corner's size
* @param size the image's new size
*
* @return the round corner image
*/
- (UIImage *)pb_drawRoundCornerWithRadius:(CGFloat)radius toSize:(CGSize)size;
/**
* @brief generate qr code
*
* @param code info string
* @param size image size
*
* @return the info qr code image
*/
+ (UIImage *)pb_generateQRCode:(NSString *)code size:(CGSize)size;
/**
* @brief generate bar code
*
* @param code info string
* @param size image size
*
* @return the info bar code image
*/
+ (UIImage *)pb_generateBarCode:(NSString *)code size:(CGSize)size;
/**
* @brief merge image
*
* @param icon the small icon image to merge in center
* @param size meger size, should not more than origin image's 25%
*
* @return merged image
*/
- (UIImage *)pb_mergeImage:(UIImage *)icon size:(CGSize)size;
/**
assemble group chat avatar
@param avatars :group member's avatars
@param size :destnation avatar size
@param bgColor :avatar's bg color
@return group avatar
*/
+ (UIImage *)pb_assembleGroupAvatarWithUsrAvatars:(NSArray *)avatars forAvatarSize:(CGSize)size forBgColor:(UIColor *)bgColor;
NS_ASSUME_NONNULL_END
@end
|
microsoft/hibernation-setup-tool
|
hibernation-setup-tool.c
|
<gh_stars>1-10
// Hibernation Setup Tool
// Sets up a swap area suitable to hibernate a Linux system.
//
// Copyright (c) 2021 Microsoft Corp.
// Licensed under the terms of the MIT license.
#define _GNU_SOURCE
/* sys/mount.h has to be included before linux/fs.h
* https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=898743
*/
#include <sys/mount.h>
#include <ctype.h>
#include <dirent.h>
#include <errno.h>
#include <fcntl.h>
#include <ftw.h>
#include <linux/falloc.h>
#include <linux/fs.h>
#include <linux/ioctl.h>
#include <linux/magic.h>
#include <linux/suspend_ioctls.h>
#include <mntent.h>
#include <spawn.h>
#include <stdarg.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/auxv.h>
#include <sys/ioctl.h>
#include <sys/stat.h>
#include <sys/statfs.h>
#include <sys/swap.h>
#include <sys/types.h>
#include <sys/utsname.h>
#include <sys/vfs.h>
#include <sys/wait.h>
#include <syscall.h>
#include <syslog.h>
#include <unistd.h>
#define MEGA_BYTES (1ul << 20)
#define GIGA_BYTES (1ul << 30)
#ifndef SEEK_HOLE
#define SEEK_HOLE 4
#endif
#ifndef IOPRIO_WHO_PROCESS
#define IOPRIO_WHO_PROCESS 1
#endif
#ifndef IOPRIO_CLASS_IDLE
#define IOPRIO_CLASS_IDLE 3
#endif
#ifndef IOPRIO_PRIO_VALUE
#define IOPRIO_PRIO_VALUE(klass, data) (((klass) << 13) | (data))
#endif
#ifndef XFS_SUPER_MAGIC
#define XFS_SUPER_MAGIC ('X' << 24 | 'F' << 16 | 'S' << 8 | 'B')
#endif
static const char swap_file_name[] = "/hibfile.sys";
/* Prefix is needed when not running as a service. Output from this the tool is fed to the
* system log while systemd is processing the request to hibernate. This makes it easier to
* grep for hibernation-setup-tool there too in case of a failure. */
static bool log_needs_prefix = false;
/* We don't always want to spam syslog: spamming stdout is fine as this is supposed to be
* executed as a daemon in systemd and this output will be stored in the journal. However,
* this agent can run as a hook and we want to make sure that the messages there are logged
* somewhere. */
static bool log_needs_syslog = false;
/* This is a link pointing to a file in a tmpfs filesystem and is mostly used to detect
* if we got a cold boot or not. */
static const char hibernate_lock_file_name[] = "/etc/hibernation-setup-tool.last_hibernation";
enum host_vm_notification {
HOST_VM_NOTIFY_COLD_BOOT, /* Sent every time system cold boots */
HOST_VM_NOTIFY_HIBERNATING, /* Sent right before hibernation */
HOST_VM_NOTIFY_RESUMED_FROM_HIBERNATION, /* Sent right after hibernation */
HOST_VM_NOTIFY_PRE_HIBERNATION_FAILED, /* Sent on errors when hibernating or resuming */
};
struct swap_file {
size_t capacity;
char path[];
};
static int ioprio_set(int which, int who, int ioprio) { return (int)syscall(SYS_ioprio_set, which, who, ioprio); }
static void log_impl(int log_level, const char *fmt, va_list ap)
{
if (log_needs_syslog)
vsyslog(log_level, fmt, ap);
flockfile(stdout);
if (log_needs_prefix)
printf("hibernation-setup-tool: ");
if (log_level & LOG_INFO)
printf("INFO: ");
else if (log_level & LOG_ERR)
printf("ERROR: ");
vprintf(fmt, ap);
printf("\n");
funlockfile(stdout);
}
__attribute__((format(printf, 1, 2))) static void log_info(const char *fmt, ...)
{
va_list ap;
va_start(ap, fmt);
log_impl(LOG_INFO, fmt, ap);
va_end(ap);
}
__attribute__((format(printf, 1, 2))) __attribute__((noreturn)) static void log_fatal(const char *fmt, ...)
{
va_list ap;
va_start(ap, fmt);
log_impl(LOG_ERR, fmt, ap);
va_end(ap);
exit(1);
__builtin_unreachable();
}
static char *next_field(char *current)
{
if (!current)
return NULL;
if (*current == '\0')
return NULL;
while (!isspace(*current))
current++;
*current = '\0'; /* 0-terminate the previous call to next_field() */
current++; /* skip the NUL terminator */
while (isspace(*current))
current++;
return current;
}
static size_t parse_size_or_die(const char *ptr, const char expected_end, char **endptr)
{
size_t parsed;
errno = 0;
if (sizeof(size_t) == sizeof(unsigned long long)) {
parsed = strtoull(ptr, endptr, 10);
} else if (sizeof(size_t) == sizeof(unsigned long)) {
parsed = strtoul(ptr, endptr, 10);
} else {
log_fatal("Invalid size of size_t: %zu", sizeof(size_t));
}
if (errno || (endptr && **endptr != expected_end))
log_fatal("Could not parse size: %s", strerror(errno));
return parsed;
}
static const char *find_executable_in_path(const char *name, const char *path_env, char path_buf[static PATH_MAX])
{
if (!path_env)
path_env = "/bin:/sbin:/usr/bin:/usr/sbin";
while (*path_env) {
const char *p = strchr(path_env, ':');
int ret;
if (!p) {
/* Last segment of $PATH */
ret = snprintf(path_buf, PATH_MAX, "%s/%s", path_env, name);
path_env = "";
} else if (p - path_env) {
/* Middle segments */
ret = snprintf(path_buf, PATH_MAX, "%.*s/%s", (int)(p - path_env), path_env, name);
path_env = p + 1;
} else {
/* Empty segment or non-root directory? Skip. */
path_env = p + 1;
continue;
}
if (ret < 0 || ret >= PATH_MAX)
log_fatal("Building path to determine if %s exists would overflow buffer", name);
if (path_buf[0] != '/')
continue;
if (!access(path_buf, X_OK))
return path_buf;
}
return NULL;
}
static bool is_exec_in_path(const char *name)
{
char path_buf[PATH_MAX];
return find_executable_in_path(name, getenv("PATH"), path_buf) != NULL;
}
static struct swap_file *new_swap_file(const char *path, size_t capacity)
{
struct swap_file *out;
out = malloc(sizeof(*out) + strlen(path) + 1);
if (!out)
log_fatal("Could not allocate memory for swap file information");
out->capacity = capacity;
memcpy(out->path, path, strlen(path) + 1);
return out;
}
static struct swap_file *find_swap_file(size_t needed_size)
{
char buffer[1024];
FILE *swaps;
struct swap_file *out = NULL;
swaps = fopen("/proc/swaps", "re");
if (!swaps)
log_fatal("Could not open /proc/swaps: is /proc mounted?");
/* Skip first line (header) */
if (!fgets(buffer, sizeof(buffer), swaps))
log_fatal("Could not skip first line from /proc/swaps");
while (fgets(buffer, sizeof(buffer), swaps)) {
char *filename = buffer;
char *type = next_field(filename);
if (!type) {
log_info("Couldn't get the second field while parsing /proc/swaps");
break;
}
if (!strcmp(type, "file")) {
char *size = next_field(type);
if (!size)
log_fatal("Malformed line in /proc/swaps: can't find size column");
size_t size_as_int = parse_size_or_die(size, ' ', NULL);
if (size_as_int < needed_size)
continue;
out = new_swap_file(filename, size_as_int);
break;
}
}
fclose(swaps);
if (!out) {
struct stat st;
if (stat(swap_file_name, &st) < 0)
return NULL;
if (!S_ISREG(st.st_mode))
return NULL;
return new_swap_file(swap_file_name, st.st_size);
}
return out;
}
static size_t physical_memory(void)
{
FILE *meminfo;
char buffer[256];
size_t total = 0;
meminfo = fopen("/proc/meminfo", "re");
if (!meminfo)
log_fatal("Could not determine physical memory size. Is /proc mounted?");
while (fgets(buffer, sizeof(buffer), meminfo)) {
static const size_t mem_total_len = sizeof("MemTotal: ") - 1;
if (!strncmp(buffer, "MemTotal: ", mem_total_len)) {
char *endptr;
total = parse_size_or_die(buffer + mem_total_len, ' ', &endptr);
if (!strcmp(endptr, " kB\n"))
total *= 1024;
else if (!strcmp(endptr, " MB\n"))
total *= MEGA_BYTES;
else if (!strcmp(endptr, " GB\n"))
total *= 1024 * MEGA_BYTES;
else if (!strcmp(endptr, " TB\n"))
total *= (size_t)MEGA_BYTES * (size_t)MEGA_BYTES;
else
log_fatal("Could not determine unit for physical memory information");
break;
}
}
fclose(meminfo);
return total;
}
static size_t swap_needed_size(size_t phys_mem)
{
/* This is using the recommendation from the Fedora project documentation. */
if (phys_mem <= 2 * GIGA_BYTES)
return 3 * phys_mem;
if (phys_mem <= 8 * GIGA_BYTES)
return 2 * phys_mem;
if (phys_mem <= 64 * GIGA_BYTES)
return (3 * phys_mem) / 2;
/* Note: Fedora documentation doesn't recommend hibernation for machines over 64GB of RAM,
* but we're extending this for a bit. */
if (phys_mem <= 256 * GIGA_BYTES)
return (5 * phys_mem) / 4;
log_fatal("Hibernation not recommended for a machine with more than 256GB of RAM");
}
static char *get_uuid_for_dev_path(const char *path)
{
struct stat dev_st;
struct dirent *ent;
char *uuid = NULL;
DIR *uuid_dir;
if (stat(path, &dev_st) < 0) {
log_info("Could not stat(%s): %s", path, strerror(errno));
return NULL;
}
uuid_dir = opendir("/dev/disk/by-uuid/");
if (!uuid_dir) {
log_info("Could not open directory /dev/disk/by-uuid/: %s", strerror(errno));
return NULL;
}
while ((ent = readdir(uuid_dir))) {
struct stat ent_st;
if (fstatat(dirfd(uuid_dir), ent->d_name, &ent_st, 0) < 0)
continue;
/* Shouldn't happen, but just in case */
if ((ent_st.st_mode & S_IFMT) != S_IFBLK)
continue;
if (ent_st.st_rdev == dev_st.st_rdev) {
uuid = strdup(ent->d_name);
break;
}
}
closedir(uuid_dir);
if (uuid)
log_info("UUID for device %s is %s", path, uuid);
return uuid;
}
static char *get_disk_uuid_for_file_path(const char *path)
{
FILE *mounts = setmntent("/proc/mounts", "re");
struct mntent *ent;
struct stat st;
if (!mounts)
return NULL;
if (stat(path, &st) < 0)
log_fatal("Could not stat(%s): %s", path, strerror(errno));
while ((ent = getmntent(mounts))) {
struct stat ent_st;
if (stat(ent->mnt_dir, &ent_st) < 0)
continue;
if (ent_st.st_dev == st.st_dev)
break;
}
endmntent(mounts);
if (!ent) {
log_info("Could not determine device for file in path %s", path);
return NULL;
}
return get_uuid_for_dev_path(ent->mnt_fsname);
}
static long determine_block_size_for_root_fs(void)
{
FILE *mtab = setmntent("/proc/mounts", "re");
struct mntent *mntent;
long sector_size = 0;
if (!mtab)
log_fatal("Could not determine mounted partitions. Is /proc mounted?");
while ((mntent = getmntent(mtab))) {
if (!strcmp(mntent->mnt_dir, "/")) {
int fd = open(mntent->mnt_fsname, O_RDONLY | O_CLOEXEC);
if (fd < 0) {
log_fatal("Could not open %s to determine block size: %s", mntent->mnt_fsname, strerror(errno));
}
if (ioctl(fd, BLKSSZGET, §or_size) < 0)
sector_size = 0;
close(fd);
break;
}
}
endmntent(mtab);
if (sector_size) {
struct statfs sfs;
if (statfs("/", &sfs) < 0)
log_fatal("Could not determine optimal block size for root filesystem: %s", strerror(errno));
return sfs.f_bsize > sector_size ? sfs.f_bsize : sector_size;
}
log_fatal("Could not obtain sector size for root partition: %s", strerror(errno));
}
static char *read_first_line_from_file(const char *path, char buffer[static 1024])
{
FILE *f = fopen(path, "re");
if (!f)
return NULL;
bool did_read = fgets(buffer, 1024, f) != NULL;
fclose(f);
if (!did_read)
return NULL;
char *lf = strchr(buffer, '\n');
if (lf)
*lf = '\0';
return buffer;
}
static bool is_hyperv(void) { return !access("/sys/bus/vmbus", F_OK); }
static bool is_running_in_container(void)
{
FILE *cgroup;
char buffer[1024];
bool ret = false;
cgroup = fopen("/proc/1/cgroup", "re");
if (!cgroup)
log_fatal("Could not read /proc/1/cgroup to determine if we're running in a container");
while (fgets(buffer, sizeof(buffer), cgroup)) {
const char *first_colon = strchr(buffer, ':');
if (!first_colon)
continue;
/* When running in a container, PID 1 will have a line in
* /proc/1/cgroup with "0::/" as a content; whereas, when running in
* the host, it might have something like "0::/init.slice".
*
* Things might be different with anything other than systemd, but
* since we're supporting systemd-only distros at this point, it's
* safer to use this method rather than rely on things like the
* presence of /.dockerenv or something like that as the container
* runtime not be docker. */
if (!strcmp(first_colon, "::/\n")) {
ret = true;
break;
}
}
fclose(cgroup);
return ret;
}
static bool is_hibernation_enabled_for_vm(void)
{
char buffer[1024];
char *entry;
if (is_running_in_container()) {
log_info("We're running in a container; this isn't supported.");
return false;
}
if (access("/dev/snapshot", F_OK) != 0) {
log_info("Kernel does not support hibernation or /dev/snapshot has not been found.");
return false;
}
/* First, check if the kernel can hibernate. Don't even bother if the
* interface to hibernate it isn't available. */
entry = read_first_line_from_file("/sys/power/disk", buffer);
if (!entry) {
log_info("Kernel does not support hibernation (/sys/power/disk does not exist or can't be read).");
return false;
}
if (strstr(entry, "platform")) {
log_info("VM supports hibernation with platform-supported events.");
return true;
}
if (strstr(entry, "shutdown")) {
log_info("VM supports hibernation only with the shutdown method. This is not ideal.");
} else if (strstr(entry, "suspend")) {
log_info("VM supports hibernation only with the suspend method. This is not ideal.");
} else {
log_info("Unknown VM hibernation support mode found: %s", entry);
return false;
}
if (is_hyperv()) {
log_info("This is a Hyper-V VM, checking if hibernation is enabled through VMBus events.");
entry = read_first_line_from_file("/sys/bus/vmbus/hibernation", buffer);
if (entry) {
if (!strcmp(entry, "1")) {
log_info("Hibernation is enabled according to VMBus. This is ideal.");
return true;
}
log_info("Hibernation is disabled according to VMBus.");
}
}
log_info("Even though VM is capable of hibernation, it seems to be disabled.");
return false;
}
static uint32_t get_swap_file_offset(int fd)
{
uint32_t blksize;
if (ioctl(fd, FIGETBSZ, &blksize) < 0)
log_fatal("Could not get file block size: %s", strerror(errno));
uint32_t last = 0, first = 0, num_contiguous_blocks = 0;
uint32_t blocks_per_page = sysconf(_SC_PAGE_SIZE) / blksize;
uint32_t first_blknum = ~0;
for (uint32_t i = 0; i < blocks_per_page; i++) {
uint32_t blknum = i;
if (ioctl(fd, FIBMAP, &blknum) < 0)
log_fatal("Could not get filesystem block number for block #%d: %s", i, strerror(errno));
if (i == 0)
first_blknum = blknum;
if (last && blknum - last != 1) {
/* If we find a block that's not contiguous, bail out. We
* check below if we have enough contiguous blocks for hibernation
* to work. */
break;
}
if (!first)
first = blknum;
last = blknum;
num_contiguous_blocks++;
}
log_info("First %d blocks of %d bytes are contiguous", num_contiguous_blocks, blksize);
if (num_contiguous_blocks * blksize >= sysconf(_SC_PAGE_SIZE))
return first_blknum;
return ~0;
}
static bool try_zero_out_with_write(const char *path, off_t needed_size)
{
int fd = open(path, O_WRONLY | O_CLOEXEC);
int ret = true;
if (fd < 0) {
log_info("Could not open %s: %s", path, strerror(errno));
return false;
}
long block_size = determine_block_size_for_root_fs();
const uint32_t pattern = 'T' << 24 | 'F' << 16 | 'S' << 8 | 'M';
for (off_t offset = 0; offset < needed_size; offset += block_size) {
ssize_t written = pwrite(fd, &pattern, sizeof(pattern), offset);
if (written < 0) {
log_info("Could not write pattern to %s: %s", path, strerror(errno));
ret = false;
goto out;
}
}
fdatasync(fd);
out:
close(fd);
return ret;
}
static bool fs_set_flags(int fd, int flags_to_set, int flags_to_reset)
{
int current_flags;
if (ioctl(fd, FS_IOC_GETFLAGS, ¤t_flags) < 0)
return false;
current_flags |= flags_to_set;
current_flags &= ~flags_to_reset;
if (ioctl(fd, FS_IOC_SETFLAGS, ¤t_flags) < 0)
return false;
return true;
}
static bool is_file_on_fs(const char *path, __fsword_t magic)
{
struct statfs stfs;
if (!statfs(path, &stfs))
return stfs.f_type == magic;
return false;
}
static bool create_swap_file_with_size(const char *path, off_t size)
{
int fd = open(path, O_CLOEXEC | O_WRONLY | O_CREAT, 0600);
int rc;
if (fd < 0)
return false;
/* Disabling CoW is necessary on btrfs filesystems, but issue the
* ioctl regardless of the filesystem just in case.
* More information: https://wiki.archlinux.org/index.php/btrfs#Swap_file
*/
if (!fs_set_flags(fd, FS_NOCOW_FL, 0)) {
/* Some filesystems don't support CoW (EXT4 for instance), so don't bother
* giving an error message in those cases. */
if (errno != EOPNOTSUPP)
log_info("Could not disable CoW for %s: %s. Will try setting up swap anyway.", path, strerror(errno));
}
/* Disable compression, too. */
if (!fs_set_flags(fd, FS_NOCOMP_FL, FS_COMPR_FL)) {
/* Compression is optional, too, so don't bother giving an error message in
* case the filesystem doesn't support it. */
if (errno != EOPNOTSUPP)
log_info("Could not disable compression for %s: %s. Will try setting up swap anyway.", path, strerror(errno));
}
if (is_file_on_fs(path, XFS_SUPER_MAGIC)) {
rc = 0;
} else {
rc = ftruncate(fd, size);
if (rc < 0) {
if (errno == EPERM) {
log_info("Not enough disk space to create %s with %zu MB.", path, size / MEGA_BYTES);
} else {
log_info("Could not resize %s to %ld MB: %s", path, size / MEGA_BYTES, strerror(errno));
}
}
}
close(fd);
return rc == 0;
}
static bool try_zeroing_out_with_fallocate(const char *path, off_t size)
{
int fd = open(path, O_CLOEXEC | O_WRONLY);
if (fd < 0) {
log_info("Could not open %s for writing: %s", path, strerror(errno));
return false;
}
if (fallocate(fd, 0, 0, size) < 0) {
if (errno == ENOSPC) {
log_fatal("System ran out of disk space while allocating hibernation file. It needs %zd MiB", size / MEGA_BYTES);
} else {
log_fatal("Could not allocate %s: %s", path, strerror(errno));
}
}
close(fd);
return true;
}
static bool try_vspawn_and_wait(const char *program, int n_args, va_list ap)
{
pid_t pid;
int rc;
char **argv;
argv = calloc(n_args + 2, sizeof(char *));
if (!argv) {
log_info("Couldn't allocate memory for argument array");
return false;
}
argv[0] = (char *)program;
for (int i = 1; i <= n_args; i++)
argv[i] = va_arg(ap, char *);
rc = posix_spawnp(&pid, program, NULL, NULL, argv, NULL);
free(argv);
if (rc != 0) {
log_info("Could not spawn %s: %s", program, strerror(rc));
return false;
}
log_info("Waiting for %s (pid %d) to finish.", program, pid);
int wstatus;
if (waitpid(pid, &wstatus, 0) != pid) {
log_info("Couldn't wait for %s: %s", program, strerror(errno));
return false;
}
if (!WIFEXITED(wstatus)) {
log_info("%s ended abnormally: %s", program, strerror(errno));
return false;
}
if (WEXITSTATUS(wstatus) == 127) {
log_info("Failed to spawn %s", program);
return false;
}
if (WEXITSTATUS(wstatus) != 0) {
log_info("%s ended with unexpected exit code %d", program, WEXITSTATUS(wstatus));
return false;
}
log_info("%s finished successfully.", program);
return true;
}
static bool try_spawn_and_wait(const char *program, int n_args, ...)
{
va_list ap;
bool spawned;
va_start(ap, n_args);
spawned = try_vspawn_and_wait(program, n_args, ap);
va_end(ap);
return spawned;
}
static void spawn_and_wait(const char *program, int n_args, ...)
{
va_list ap;
bool spawned;
va_start(ap, n_args);
spawned = try_vspawn_and_wait(program, n_args, ap);
va_end(ap);
if (!spawned)
log_fatal("Aborting program due to error condition when spawning %s", program);
}
static void perform_fs_specific_checks(const char *path)
{
if (is_file_on_fs(path, EXT4_SUPER_MAGIC) && is_exec_in_path("e4defrag")) {
try_spawn_and_wait("e4defrag", 1, path);
return;
}
if (is_file_on_fs(path, BTRFS_SUPER_MAGIC)) {
struct utsname utsbuf;
if (uname(&utsbuf) < 0)
log_fatal("Could not determine Linux kernel version: %s", strerror(errno));
if (utsbuf.release[1] != '.')
log_fatal("Could not parse Linux kernel version");
if (utsbuf.release[0] < '5')
log_fatal("Swap files are not supported on Btrfs running on kernel %s", utsbuf.release);
if (is_exec_in_path("btrfs"))
try_spawn_and_wait("btrfs", 3, "filesystem", "defragment", path);
return;
}
if (is_file_on_fs(path, XFS_SUPER_MAGIC) && is_exec_in_path("xfs_fsr")) {
try_spawn_and_wait("xfs_fsr", 2, "-v", path);
return;
}
}
static struct swap_file *create_swap_file(size_t needed_size)
{
log_info("Creating hibernation file at %s with %zu MB.", swap_file_name, needed_size / MEGA_BYTES);
if (!create_swap_file_with_size(swap_file_name, needed_size))
log_fatal("Could not create swap file, aborting.");
/* Allocate the swap file with the lowest I/O priority possible to not thrash workload */
ioprio_set(IOPRIO_WHO_PROCESS, 0, IOPRIO_PRIO_VALUE(IOPRIO_CLASS_IDLE, 7));
log_info("Ensuring %s has no holes in it.", swap_file_name);
bool swap_on_xfs = is_file_on_fs(swap_file_name, XFS_SUPER_MAGIC);
if (swap_on_xfs || !try_zeroing_out_with_fallocate(swap_file_name, needed_size)) {
if (swap_on_xfs)
log_info("Root partition is in a XFS filesystem; need to use slower method to allocate swap file");
else
log_info("Fast method failed; trying a slower method.");
if (!try_zero_out_with_write(swap_file_name, needed_size))
log_fatal("Could not create swap file.");
}
perform_fs_specific_checks(swap_file_name);
spawn_and_wait("mkswap", 1, swap_file_name);
struct swap_file *ret = malloc(sizeof(*ret) + sizeof(swap_file_name));
if (!ret)
log_fatal("Could not allocate memory to represent a swap file: %s", strerror(errno));
ret->capacity = needed_size;
memcpy(ret->path, swap_file_name, sizeof(swap_file_name));
return ret;
}
static bool is_kernel_cmdline_correct(const char *dev_uuid, off_t resume_offset)
{
char buffer[1024];
char *line = read_first_line_from_file("/proc/cmdline", buffer);
if (!line) {
log_info("Could not read /proc/cmdline; is /proc mounted? Assuming information is incorrect.");
return false;
}
char *resume_field = NULL;
char *resume_offset_field = NULL;
char *no_console_suspend_field = NULL;
for (char *field = line; field; field = next_field(field)) {
if (!strncmp(field, "resume=", sizeof("resume=") - 1))
resume_field = field + sizeof("resume=") - 1;
else if (!strncmp(field, "resume_offset=", sizeof("resume_offset=") - 1))
resume_offset_field = field + sizeof("resume_offset=") - 1;
else if (!strncmp(field, "no_console_suspend=", sizeof("no_console_suspend=") - 1))
no_console_suspend_field = field + sizeof("no_console_suspend=") - 1;
}
if (!resume_field)
return false;
if (!resume_offset_field)
return false;
if (!no_console_suspend_field)
return false;
char full_dev_path[PATH_MAX];
int r = snprintf(full_dev_path, PATH_MAX, "/dev/disk/by-uuid/%s", dev_uuid);
if (r < 0 || r >= PATH_MAX)
return false;
if (strcmp(resume_field, full_dev_path) != 0)
return false;
char offset_buf[3 * sizeof(size_t)];
snprintf(offset_buf, sizeof(offset_buf), "%zd", resume_offset);
if (strcmp(offset_buf, resume_offset_field) != 0)
return false;
if (strcmp(no_console_suspend_field, "1") != 0)
return false;
return true;
}
static struct resume_swap_area get_swap_area(const struct swap_file *swap)
{
int fd = open(swap->path, O_RDONLY | O_CLOEXEC);
struct stat st;
if (fd < 0)
log_fatal("Could not open %s: %s", swap->path, strerror(errno));
if (fstat(fd, &st) < 0)
log_fatal("Could not stat %s: %s", swap->path, strerror(errno));
if (!S_ISREG(st.st_mode))
log_fatal("Swap file %s is not a regular file", swap->path);
uint32_t offset = get_swap_file_offset(fd);
if (offset == ~0u)
log_fatal("Could not determine file system block number for %s, or file isn't contiguous", swap->path);
close(fd);
log_info("Swap file %s is at device %ld, offset %d", swap->path, st.st_dev, offset);
return (struct resume_swap_area){
.offset = offset,
.dev = st.st_dev,
};
}
static const char *find_grub_cfg_path(void)
{
static const char *possible_paths[] = {"/boot/grub2/grub.cfg", "/boot/grub/grub.cfg", NULL};
for (int i = 0; possible_paths[i]; i++) {
if (!access(possible_paths[i], F_OK))
return possible_paths[i];
}
log_info("Could not find GRUB configuration file. Is /boot mounted?");
return NULL;
}
static bool is_directory_empty(const char *path)
{
DIR *dir = opendir(path);
struct dirent *ent;
bool has_file = false;
if (!dir)
return true;
while ((ent = readdir(dir))) {
if (!strcmp(ent->d_name, "."))
continue;
if (!strcmp(ent->d_name, ".."))
continue;
has_file = true;
break;
}
closedir(dir);
return !has_file;
}
static bool update_kernel_cmdline_params_for_grub(
const char *dev_uuid, const struct resume_swap_area swap_area, bool has_grubby, bool has_update_grub2, bool has_grub2_mkconfig)
{
bool ret_value = true;
/* Doc:
* https://docs.fedoraproject.org/en-US/fedora/rawhide/system-administrators-guide/kernel-module-driver-configuration/Working_with_the_GRUB_2_Boot_Loader/#sec-Making_Persistent_Changes_to_a_GRUB_2_Menu_Using_the_grubby_Tool
*/
log_info("Kernel command line is missing parameters to resume from hibernation. Trying to patch grub configuration file.");
char *args;
if (asprintf(&args, "resume=/dev/disk/by-uuid/%s resume_offset=%lld no_console_suspend=1", dev_uuid, swap_area.offset) < 0) {
log_info("Could not allocate memory for kernel argument");
return false;
}
if (is_exec_in_path("update-initramfs")) {
log_info("Updating initramfs to include resume stuff");
FILE *conf = fopen("/etc/initramfs-tools/conf.d/resume", "we");
if (!conf)
log_fatal("Could not open initramfs-tools configuration file: %s", strerror(errno));
fprintf(conf, "# Updated automatically by hibernation-setup-tool. Do not modify.\n");
fprintf(conf, "RESUME=UUID=%s\n", dev_uuid);
fclose(conf);
spawn_and_wait("update-initramfs", 1, "-u");
}
if (has_grubby) {
log_info("Using grubby to patch GRUB configuration");
spawn_and_wait("grubby", 3, "--update-kernel=ALL", "--args", args);
} else if (has_update_grub2 || has_grub2_mkconfig) {
FILE *resume_cfg;
char *old_contents = NULL;
const char *grub_cfg_path;
size_t old_contents_len = 0;
char buffer[1024];
if (!is_directory_empty("/etc/default/grub.d")) {
/* If we find this directory, it might be possible that some of the configuration
* files there will override GRUB_CMDLINE_LINUX_DEFAULT. This seems to be the case
* in some Azure Marketplace images, with files such as "50-cloudimg-settings.cfg".
* If we find the directory, assume we can create our own with higher priority
* instead of modifying the global configuration file. */
grub_cfg_path = "/etc/default/grub.d/99-hibernate-settings.cfg";
} else if (!access("/etc/default/grub", F_OK)) {
grub_cfg_path = "/etc/default/grub";
} else {
log_fatal("Could not determine where the Grub configuration file is");
}
resume_cfg = fopen(grub_cfg_path, "re");
if (resume_cfg) {
bool in_az_hibernate_agent_block = false;
while (fgets(buffer, sizeof(buffer), resume_cfg)) {
if (in_az_hibernate_agent_block) {
if (strstr(buffer, "# hibernation-setup-tool:end"))
in_az_hibernate_agent_block = false;
continue;
}
if (strstr(buffer, "# hibernation-setup-tool:start")) {
in_az_hibernate_agent_block = true;
continue;
}
size_t buflen = strlen(buffer);
char *tmp = realloc(old_contents, old_contents_len + buflen + 1);
if (!tmp)
log_fatal("Could not allocate memory: %s", strerror(errno));
memcpy(tmp + old_contents_len, buffer, buflen + 1);
old_contents_len += buflen;
old_contents = tmp;
}
fclose(resume_cfg);
}
resume_cfg = fopen(grub_cfg_path, "we");
if (!resume_cfg)
log_fatal("Could not open %s for writing: %s", grub_cfg_path, strerror(errno));
if (old_contents) {
fwrite(old_contents, old_contents_len, 1, resume_cfg);
free(old_contents);
}
fprintf(resume_cfg, "\n# hibernation-setup-tool:start\n");
fprintf(resume_cfg, "GRUB_CMDLINE_LINUX_DEFAULT=\"$GRUB_CMDLINE_LINUX_DEFAULT %s\"\n", args);
fprintf(resume_cfg, "unset GRUB_FORCE_PARTUUID\n");
fprintf(resume_cfg, "# hibernation-setup-tool:end\n");
fclose(resume_cfg);
if (has_update_grub2) {
log_info("Using update-grub2 to patch GRUB configuration in %s", grub_cfg_path);
spawn_and_wait("update-grub2", 0);
} else if (has_grub2_mkconfig) {
const char *grub_cfg_path = find_grub_cfg_path();
if (!grub_cfg_path) {
ret_value = false;
} else {
log_info("Using grub2-mkconfig to patch GRUB configuration in %s", grub_cfg_path);
spawn_and_wait("grub2-mkconfig", 2, "-o", grub_cfg_path);
}
}
}
free(args);
return ret_value;
}
static bool update_swap_offset(const struct swap_file *swap)
{
bool ret = true;
log_info("Updating swap offset");
int fd = open("/dev/snapshot", O_RDONLY | O_CLOEXEC);
if (fd < 0) {
log_info("Could not open /dev/snapshot: %s", strerror(errno));
return false;
}
struct resume_swap_area swap_area = get_swap_area(swap);
if (ioctl(fd, SNAPSHOT_SET_SWAP_AREA, &swap_area) < 0) {
log_info("Could not set resume_swap_area parameters in /dev/snapshot: %s", strerror(errno));
close(fd);
return false;
}
close(fd);
char *dev_uuid = get_disk_uuid_for_file_path(swap->path);
if (!dev_uuid)
log_fatal("Could not determine device UUID for swap file %s", swap->path);
log_info("Swap file %s is in device UUID %s", swap->path, dev_uuid);
if (!is_kernel_cmdline_correct(dev_uuid, swap_area.offset)) {
log_info("Kernel command-line parameters need updating.");
bool has_grubby = is_exec_in_path("grubby");
bool has_update_grub2 = is_exec_in_path("update-grub2");
bool has_grub2_mkconfig = is_exec_in_path("grub2-mkconfig");
if (has_grubby || has_update_grub2 || has_grub2_mkconfig) {
ret = update_kernel_cmdline_params_for_grub(dev_uuid, swap_area, has_grubby, has_update_grub2, has_grub2_mkconfig);
} else {
log_info(
"Could not determine how system was booted to update kernel parameters for next boot. System won't be able to resume until you fix this.");
ret = false;
}
}
free(dev_uuid);
return ret;
}
static void ensure_swap_is_enabled(const struct swap_file *swap, bool created)
{
FILE *fstab;
char *old_contents = NULL;
size_t old_contents_len = 0;
char buffer[1024];
log_info("Ensuring swap file %s is enabled", swap->path);
if (chmod(swap->path, 0600) < 0)
log_fatal("Couldn't set correct permissions on %s: %s", swap->path, strerror(errno));
if (swapon(swap->path, 0) < 0) {
if (errno == EINVAL && !created)
log_fatal("%s exists but kernel isn't accepting it as a swap file. Try removing it and re-running the agent.", swap->path);
if (errno != EBUSY)
log_fatal("Could not enable swap file: %s", strerror(errno));
}
log_info("Updating /etc/fstab");
fstab = fopen("/etc/fstab", "re");
if (!fstab)
log_fatal("Could not open fstab: %s", strerror(errno));
while (fgets(buffer, sizeof(buffer), fstab)) {
if (strstr(buffer, swap->path))
continue;
size_t buflen = strlen(buffer);
char *tmp = realloc(old_contents, old_contents_len + buflen + 1);
if (!tmp)
log_fatal("Couldn't allocate memory");
memcpy(tmp + old_contents_len, buffer, buflen + 1);
old_contents_len += buflen;
old_contents = tmp;
}
fclose(fstab);
fstab = fopen("/etc/fstab", "we");
if (!fstab)
log_fatal("Could not open fstab for writing: %s", strerror(errno));
if (old_contents) {
fwrite(old_contents, old_contents_len, 1, fstab);
free(old_contents);
}
fprintf(fstab, "\n%s\tnone\tswap\tswap\t0\t0\n", swap->path);
fclose(fstab);
}
static void ensure_udev_rules_are_installed(void)
{
char systemctl_path_buf[PATH_MAX];
const char *udev_rule_path;
const char *systemctl_path;
systemctl_path = find_executable_in_path("systemctl", NULL, systemctl_path_buf);
if (!systemctl_path) {
log_info("systemctl not found or not executable, udev rule won't work");
return;
}
if (!is_exec_in_path("udevadm")) {
log_info("udevadm has not been found in $PATH; maybe system doesn't use systemd?");
return;
}
if (!access("/usr/lib/udev/rules.d", F_OK)) {
udev_rule_path = "/usr/lib/udev/rules.d/99-vm-hibernation.rules";
} else if (!access("/etc/udev/rules.d", F_OK)) {
udev_rule_path = "/etc/udev/rules.d/99-vm-hibernation.rules";
} else if (!access("/lib/udev/rules.d", F_OK)) {
udev_rule_path = "/lib/udev/rules.d/99-vm-hibernation.rules";
} else {
log_info("Couldn't find where udev stores the rules. VM may not hibernate.");
return;
}
FILE *rule_file = fopen(udev_rule_path, "we");
if (!rule_file)
log_fatal("Could not open '%s' for writing: %s", udev_rule_path, strerror(errno));
fprintf(rule_file,
"SUBSYSTEM==\"vmbus\", ACTION==\"change\", "
"DRIVER==\"hv_utils\", ENV{EVENT}==\"hibernate\", "
"RUN+=\"%s hibernate\"\n",
systemctl_path);
fclose(rule_file);
log_info("udev rule to hibernate with systemd set up in %s. Telling udev about it.", udev_rule_path);
/* This isn't strictly necessary, but do it anyway just in case. */
spawn_and_wait("udevadm", 2, "control", "--reload-rules");
spawn_and_wait("udevadm", 1, "trigger");
}
static const char *readlink0(const char *path, char buf[static PATH_MAX])
{
ssize_t len = readlink(path, buf, PATH_MAX - 1);
if (len < 0)
return NULL;
buf[len] = '\0';
return buf;
}
static bool is_cold_boot(void)
{
/* We detect cold boot by creating a file in a tmpfs filesystem right
* before asking system to hibernate. If this file is not there during
* agent startup, then it's a cold boot and resuming failed; if it's
* still there, then we successfully resumed. */
char lock_file_path_buf[PATH_MAX];
const char *lock_file_path;
lock_file_path = readlink0(hibernate_lock_file_name, lock_file_path_buf);
if (lock_file_path) {
unlink(hibernate_lock_file_name);
if (access(lock_file_path, F_OK) < 0)
return true;
unlink(lock_file_path);
}
return false;
}
static void notify_vm_host(enum host_vm_notification notification)
{
static const char *types[] = {
[HOST_VM_NOTIFY_COLD_BOOT] = "cold-boot",
[HOST_VM_NOTIFY_HIBERNATING] = "hibernating",
[HOST_VM_NOTIFY_RESUMED_FROM_HIBERNATION] = "resumed-from-hibernation",
[HOST_VM_NOTIFY_PRE_HIBERNATION_FAILED] = "pre-hibernation-failed",
};
log_info("Changed hibernation state to: %s", types[notification]);
}
static int recursive_rmdir_cb(const char *fpath, const struct stat *st, int typeflag, struct FTW *ftwbuf)
{
(void)st;
(void)ftwbuf;
switch (typeflag) {
case FTW_SLN: /* symbolic link pointing to a non-existing file */
case FTW_F: /* regular file */
return unlink(fpath) == 0 ? FTW_CONTINUE : FTW_STOP;
case FTW_D: /* directory */
return rmdir(fpath) == 0 ? FTW_CONTINUE : FTW_STOP;
case FTW_SL:
/* We refuse to follow symbolic links as it might lead us to some directory outside
* the one we're trying to remove. The only symlinks we care about are those that
* point to a path that does not exist, but we delete those before doing anything
* anyway. */
log_info("%s is a symbolic link. Refusing to follow.", fpath);
return FTW_STOP;
case FTW_DNR:
log_info("Can't read directory %s", fpath);
return FTW_STOP;
case FTW_NS:
log_info("stat() failed on %s", fpath);
return FTW_STOP;
default:
log_info("nftw callback called with unknown typeflag %d, stopping", typeflag);
return FTW_STOP;
}
}
static bool recursive_rmdir(const char *path) { return nftw(path, recursive_rmdir_cb, 16, FTW_DEPTH | FTW_PHYS | FTW_ACTIONRETVAL) != FTW_STOP; }
static int handle_pre_systemd_suspend_notification(const char *action)
{
if (!strcmp(action, "hibernate")) {
log_info("Running pre-hibernate hooks");
/* Creating this directory with the right permissions is racy as
* we're writing to tmp which is world-writable. So do our best
* here to ensure that if this for loop terminates normally, the
* directory is empty and readable/writable only by us. In normal
* scenarios (i.e. nobody else tried creating a directory with that
* name), this will succeed the first try. This directory will be
* removed when we resume. */
for (int try = 0;; try++) {
if (try > 10) {
notify_vm_host(HOST_VM_NOTIFY_PRE_HIBERNATION_FAILED);
log_fatal("Tried too many times to create /tmp/hibernation-setup-tool and failed. Giving up");
}
if (!mkdir("/tmp/hibernation-setup-tool", 0700))
break;
if (errno != EEXIST) {
notify_vm_host(HOST_VM_NOTIFY_PRE_HIBERNATION_FAILED);
log_fatal("Couldn't create location to store hibernation agent state: %s", strerror(errno));
}
struct stat st;
if (!stat("/tmp/hibernation-setup-tool", &st)) {
if (S_ISDIR(st.st_mode)) {
log_info("/tmp/hibernation-setup-tool exists, removing it");
if (umount2("/tmp/hibernation-setup-tool", UMOUNT_NOFOLLOW | MNT_DETACH) < 0) {
/* See comment related to the umount2() call in handle_post_systemd_suspend_notification(). */
if (errno != EINVAL)
log_fatal("Error while unmounting /tmp/hibernation-setup-tool: %s", strerror(errno));
}
if (recursive_rmdir("/tmp/hibernation-setup-tool"))
continue;
notify_vm_host(HOST_VM_NOTIFY_PRE_HIBERNATION_FAILED);
log_fatal("Couldn't remove /tmp/hibernation-setup-tool directory before proceeding");
}
log_info("/tmp/hibernation-setup-tool exists and isn't a directory! Removing it and trying again (try %d)", try);
if (!unlink("/tmp/hibernation-setup-tool"))
continue;
notify_vm_host(HOST_VM_NOTIFY_PRE_HIBERNATION_FAILED);
log_fatal("Couldn't remove the file: %s, giving up", strerror(errno));
}
log_info("/tmp/hibernation-setup-tool couldn't be found but mkdir() told us it exists, trying again (try %d)", try);
continue;
}
if (!is_file_on_fs("/tmp/hibernation-setup-tool", TMPFS_MAGIC)) {
log_info("/tmp isn't a tmpfs filesystem; trying to mount /tmp/hibernation-setup-tool as such");
if (mount("tmpfs", "/tmp/hibernation-setup-tool", "tmpfs", 0, NULL) < 0) {
notify_vm_host(HOST_VM_NOTIFY_PRE_HIBERNATION_FAILED);
log_fatal("Couldn't mount temporary filesystem: %s. We need this to detect cold boots!", strerror(errno));
}
}
char pattern[] = "/tmp/hibernation-setup-tool/hibernatedXXXXXX";
int fd = mkostemp(pattern, O_CLOEXEC);
if (fd < 0) {
notify_vm_host(HOST_VM_NOTIFY_PRE_HIBERNATION_FAILED);
log_fatal("Couldn't create a temporary file: %s", strerror(errno));
}
close(fd);
if (unlink(hibernate_lock_file_name) < 0) {
if (errno != EEXIST) {
notify_vm_host(HOST_VM_NOTIFY_PRE_HIBERNATION_FAILED);
log_fatal("Couldn't remove %s: %s", hibernate_lock_file_name, strerror(errno));
}
}
if (link(pattern, hibernate_lock_file_name) < 0) {
notify_vm_host(HOST_VM_NOTIFY_PRE_HIBERNATION_FAILED);
log_fatal("Couldn't link %s to %s: %s", pattern, hibernate_lock_file_name, strerror(errno));
}
notify_vm_host(HOST_VM_NOTIFY_HIBERNATING);
log_info("Pre-hibernation hooks executed successfully");
return 0;
}
log_fatal("Can't handle `pre %s' notifications", action);
return 1;
}
static int handle_post_systemd_suspend_notification(const char *action)
{
if (!strcmp(action, "hibernate")) {
char real_path_buf[PATH_MAX];
const char *real_path;
log_info("Running post-hibernate hooks");
real_path = readlink0(hibernate_lock_file_name, real_path_buf);
if (!real_path) {
/* No need to notify host VM here: if link wasn't there, it's most likely that the
* pre-hibernation hooks failed to create it in the first place. Log for debugging
* but keep going. */
log_info("This is probably fine, but couldn't readlink(%s): %s", hibernate_lock_file_name, strerror(errno));
} else if (unlink(real_path) < 0) {
log_info("This is fine, but couldn't remove %s: %s", real_path, strerror(errno));
}
if (unlink(hibernate_lock_file_name) < 0)
log_info("This is fine, but couldn't remove %s: %s", hibernate_lock_file_name, strerror(errno));
if (umount2("/tmp/hibernation-setup-tool", UMOUNT_NOFOLLOW | MNT_DETACH) < 0) {
/* EINVAL is returned if this isn't a mount point. This is normal if /tmp was already
* a tmpfs and we didn't create and mounted this directory in the pre-hibernate hook.
* Calling umount2() is cheaper than checking if this directory is indeed mounted as
* a tmpfs directory. */
if (errno != EINVAL)
log_info("While unmounting /tmp/hibernation-setup-tool: %s", strerror(errno));
}
if (!recursive_rmdir("/tmp/hibernation-setup-tool"))
log_info("While removing /tmp/hibernation-setup-tool: %s", strerror(errno));
notify_vm_host(HOST_VM_NOTIFY_RESUMED_FROM_HIBERNATION);
log_info("Post-hibernation hooks executed successfully");
return 0;
}
log_fatal("Can't handle `post %s' notifications", action);
return 1;
}
static int handle_systemd_suspend_notification(const char *argv0, const char *when, const char *action)
{
if (!getenv("SYSTEMD_SLEEP_ACTION")) {
log_fatal("These arguments can only be used when called from systemd");
return 1;
}
log_needs_prefix = true;
log_needs_syslog = true;
if (!strcmp(when, "pre"))
return handle_pre_systemd_suspend_notification(action);
if (!strcmp(when, "post"))
return handle_post_systemd_suspend_notification(action);
log_fatal("Invalid usage: %s %s %s", argv0, when, action);
return 1;
}
static void link_hook(const char *src, const char *dest)
{
if (link(src, dest) < 0) {
if (errno != EEXIST)
return log_fatal("Couldn't link %s to %s: %s", src, dest, strerror(errno));
}
log_info("Notifying systemd of new hooks");
spawn_and_wait("systemctl", 1, "daemon-reload");
}
static void ensure_systemd_hooks_are_set_up(void)
{
/* Although the systemd manual cautions against dropping executables or scripts in
* this directory, the proposed D-Bus interface (Inhibitor) is not sufficient for
* our use case here: we're not trying to inhibit hibernation/suspend, we're just
* trying to know when this happened.
*
* More info: https://www.freedesktop.org/software/systemd/man/systemd-suspend.service.html
*/
const char *execfn = (const char *)getauxval(AT_EXECFN);
const char *location_to_link = "/usr/lib/systemd/systemd-sleep";
struct stat st;
int r;
r = stat(location_to_link, &st);
if (r < 0 && errno == ENOENT) {
log_info("Attempting to create hibernate/resume hook directory: %s", location_to_link);
if (mkdir(location_to_link, 0755) < 0) {
log_info("Couldn't create %s: %s. VM host won't receive suspend/resume notifications.", location_to_link, strerror(errno));
return;
}
} else if (r < 0) {
log_info("Couldn't stat(%s): %s. We need to drop a file there to allow "
"the VM host to be notified of hibernation/resumes.",
location_to_link, strerror(errno));
return;
} else if (!S_ISDIR(st.st_mode)) {
log_info("%s isn't a directory, can't drop a link to the agent there to "
" notify host of hibernation/resume",
location_to_link);
return;
}
if (execfn)
return link_hook(execfn, location_to_link);
char self_path_buf[PATH_MAX];
const char *self_path = readlink0("/proc/self/exe", self_path_buf);
if (self_path)
return link_hook(self_path, location_to_link);
return log_fatal("Both getauxval() and readlink(/proc/self/exe) failed. "
"Couldn't determine location of this executable to install "
"systemd hooks");
}
int main(int argc, char *argv[])
{
if (geteuid() != 0) {
log_fatal("This program has to be executed with superuser privileges.");
return 1;
}
if (!is_hibernation_enabled_for_vm()) {
log_info("Hibernation not enabled for this VM.");
return 0;
}
if (is_hyperv()) {
/* We only handle these things here on Hyper-V VMs because it's the only
* hypervisor we know that might need these kinds of notifications. */
if (argc == 3)
return handle_systemd_suspend_notification(argv[0], argv[1], argv[2]);
if (is_cold_boot())
notify_vm_host(HOST_VM_NOTIFY_COLD_BOOT);
}
size_t total_ram = physical_memory();
if (!total_ram)
log_fatal("Could not obtain memory total from this computer");
size_t needed_swap = swap_needed_size(total_ram);
log_info("System has %zu MB of RAM; needs a swap area of %zu MB", total_ram / MEGA_BYTES, needed_swap / MEGA_BYTES);
struct swap_file *swap = find_swap_file(needed_swap);
if (swap) {
log_info("Swap file found with size %zu MB at %s", swap->capacity / MEGA_BYTES, swap->path);
} else {
log_info("Swap file not found");
}
if (swap && swap->capacity < needed_swap) {
log_info("Swap file %s has capacity of %zu MB but needs %zu MB. Recreating. "
"System will run without a swap file while this is being set up.",
swap->path, swap->capacity / MEGA_BYTES, needed_swap / MEGA_BYTES);
if (swapoff(swap->path) < 0) {
if (errno == EINVAL) {
log_info("%s is not currently being used as a swap partition. That's OK.", swap->path);
} else {
log_fatal("Could not disable swap file %s: %s", swap->path, strerror(errno));
}
}
if (unlink(swap->path) < 0) {
/* If we're trying to remove the file but it's not there anymore,
* that's fine... no need to error out. */
if (!access(swap->path, F_OK))
log_fatal("Could not remove swap file %s: %s", swap->path, strerror(errno));
}
free(swap);
swap = NULL;
}
bool created = false;
if (!swap) {
log_info("Creating swap file with %zu MB", needed_swap / MEGA_BYTES);
swap = create_swap_file(needed_swap);
if (!swap)
log_fatal("Could not create swap file");
created = true;
}
ensure_swap_is_enabled(swap, created);
if (!update_swap_offset(swap))
log_fatal("Could not update swap offset.");
if (is_hyperv()) {
ensure_udev_rules_are_installed();
ensure_systemd_hooks_are_set_up();
}
log_info("Swap file for VM hibernation set up successfully");
free(swap);
return 0;
}
|
wkoutre/react-native-yunpeng-alipay
|
ios/AlipayModule/AlipayModule.h
|
//
// AlipayModule.h
// AlipayModule
//
// Created by <NAME> on 16/5/10.
// Copyright © 2016年 <NAME>. All rights reserved.
//
#import <Foundation/Foundation.h>
#import "React/RCTBridgeModule.h"
@interface AlipayModule : NSObject<RCTBridgeModule>
+(void) handleCallback:(NSURL *)url;
@end
|
Sxlly/SimonSays
|
commands_ll.h
|
#ifndef COMMANDS_LL_H
#define COMMANDS_LL_H
void insert_first(int key, int data);
bool is_empty();
#endif
|
Sxlly/SimonSays
|
file_input.c
|
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include "user_input.h"
int file_reader(char filename[]) {
int status = 0;
FILE *fptr;
if ((fptr = fopen(filename, "r")) == NULL) {
fclose(fptr);
status = 1;
return status;
}
else {
fclose(fptr);
return status;
}
}
|
Sxlly/SimonSays
|
main.c
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <stdbool.h>
#include <time.h>
#include "main.h"
#include "user_input.h"
#include "data_parser.h"
#include "singleyll.h"
#include "simon.h"
/* onboard main method to create a command which is then added to command list */
/* using struct from singleyll (linked list) header file */
com_t make_command() {
/* using node struct from singleyll (linked list) to hold new command */
com_t new_com;
/* print statements to show user options to choose from */
printf("\t\tChoose a command to add from the following options\n");
printf("\t\t---------------------------------------------------\n");
usleep(100000);
printf("\t\t\tType 1 For Simon Says Right Arm Up\n");
usleep(100000);
printf("\t\t\tType 2 For Simon Says Left Arm Up\n");
usleep(100000);
printf("\t\t\tType 3 For Simon Says Hands On Head\n");
usleep(100000);
printf("\t\t\tType 4 For Simon Says Dance\n");
usleep(100000);
printf("\t\t\tType 5 For Simon Didn't Say Right Arm Up\n");
usleep(100000);
printf("\t\t\tType 6 For Simon Didn't Say Left Arm Up\n");
usleep(100000);
printf("\t\t\tType 7 For Simon Didn't Say Hands On Head\n");
usleep(100000);
printf("\t\t\tType 8 For Simon Didn't Say Dance\n");
/* using input scan to obtain selection value from user -> then stored in the new commands selection value */
printf("\t\t\tYour Choice: ");
scanf("%1d", &new_com.selection);
/* print statements to confirm new commands addition to the linked list */
usleep(250000);
printf("Command Successfully Added!\n");
usleep(250000);
/* return new command node */
return new_com;
}
/* method to emulate css type design via centering main menu */
void terminal_spacer() {
int ii;
for (ii = 0; ii < 6; ii++) {
printf("\n");
}
}
/* method to add all commands from text file to command list */
void add_file_commands(comlist_t* list, char filename[256]) {
/* declaring a new object of node structure to act as new command */
com_t new_com;
/* declaring valid command strings */
char simon_s_ra[100] = "simon said right arm up\n";
char simon_s_la[100] = "simon said left arm up\n";
char simon_s_hoh[100] = "simon said hands on head\n";
char simon_s_dan[100] = "simon said dance\n";
char simon_ds_ra[100] = "simon didn't say right arm up\n";
char simon_ds_la[100] = "simon didn't say left arm up\n";
char simon_ds_hoh[100] = "simon didn't say hands on head\n";
char simon_ds_dan[100] = "simon didn't say dance\n";
FILE* fptr = fopen(filename, "r");
char file_line[100];
while (fgets(file_line, sizeof(file_line), fptr)) {
if (strcmp(file_line, simon_s_ra) == 0) {
new_com.selection = 1;
add_command(list, new_com);
}
else if (strcmp(file_line, simon_s_la) == 0) {
new_com.selection = 2;
add_command(list, new_com);
}
else if (strcmp(file_line, simon_s_hoh) == 0) {
new_com.selection = 3;
add_command(list, new_com);
}
else if (strcmp(file_line, simon_s_dan) == 0) {
new_com.selection = 4;
add_command(list, new_com);
}
else if (strcmp(file_line, simon_ds_ra) == 0) {
new_com.selection = 5;
add_command(list, new_com);
}
else if (strcmp(file_line, simon_ds_la) == 0) {
new_com.selection = 6;
add_command(list, new_com);
}
else if (strcmp(file_line, simon_ds_hoh) == 0) {
new_com.selection = 7;
add_command(list, new_com);
}
else if (strcmp(file_line, simon_ds_dan) == 0) {
new_com.selection = 8;
add_command(list, new_com);
}
else {
printf("invalid command!\n");
}
}
fclose(fptr);
}
/* default main method */
/* with static variables to support command line input */
int main(int argc, char* argv[]) {
int cla;
int mode;
/* if there is no additional command line argument -> set cla to one (False) */
if (argc == 1) {
cla = 1;
printf("Choose a Mode\n");
printf("Type 1 For Normal Mode\n");
printf("Type 2 For Everything Mode\n");
printf("Your Choice: ");
scanf("%1d", &mode);
}
/* if there is one additional command line argument -> set cla to zero (True) */
else if (argc == 2) {
/* declaring status variable to act as boolean */
int status;
cla = 0;
printf("Choose a Mode\n");
printf("Type 1 For Normal Mode\n");
printf("Type 2 For Everything Mode\n");
printf("Your Choice: ");
scanf("%1d", &mode);
/* parse filename into file reader method to verify its existence */
status = file_reader(argv[1]);
/* if status is equal to zero (True) keep cla as zero (True) */
if (status == 0) {
cla = 0;
data_parse(argv[1]);
usleep(500000);
}
/* else -> kill switch runtime via return zero */
else {
free(argv);
return 0;
}
}
/* else -> kill switch runtime via return zero */
/* firstly printing instructions on how to use program */
else {
system("clear");
terminal_spacer();
terminal_spacer();
printf("\t\t\tGot Stuck? \n");
usleep(100000);
printf("\t\t\tUser Instructions\n");
usleep(100000);
printf("\t\t\tRun Via Typing ./SimonSays into command line\n");
usleep(100000);
printf("\t\t\tRun With a Initial File Via Typing ./SimonSays filename.type\n");
usleep(100000);
printf("\t\t\tAny Additional commandline arguments given after a filename will result in a runtime error!\n");
usleep(100000);
return 0;
}
/* creating linked list */
comlist_t* list = create_comlist();
/* adding commandline argument file commands to list */
/* if commandline file was given and verified */
if (cla == 0) {
add_file_commands(list, argv[1]);
}
/* main menu infinite while loop -> while not break -> where break is exit(zero) */
while (1) {
/* functionality variables declared */
char filename[256];
int status;
int choice;
int node_index;
/* terminal formatted menu */
/* clearing current system terminal content */
system("clear");
/* using terminal spacer funtion */
terminal_spacer();
/* print statements for main menu */
/* using usleep to sleep the processing for aesthetics */
printf(" ==========================\n");
usleep(50000);
printf(" Options: \n");
usleep(50000);
printf(" 1. Import File Of Commands\n");
usleep(50000);
printf(" 2. Give Command\n");
usleep(50000);
printf(" 3. Delete Command By Index\n");
usleep(50000);
printf(" 4. Delete Commands By Amount\n");
usleep(50000);
printf(" 5. Play Simon Says\n");
usleep(50000);
printf(" 6. Display Command List\n");
usleep(50000);
printf(" 7. Exit\n");
usleep(50000);
printf(" ===========================\n");
/* obtaining choice as an integer from the user via terminal input scan */
printf(" Your Choice: ");
scanf("%1d", &choice);
/* switch structure which is parsed int choice */
switch(choice) {
/* if case->choice is equal to one */
case 1:
system("clear");
terminal_spacer();
printf("\t\t\tEnter File Name: ");
scanf("%256s", filename);
/* passing given file to file reader function which verifies it's existence within home search path (working directory) */
status = file_reader(filename);
if (status == 0) {
terminal_spacer();
printf("\t\t\tFile Exists!\n");
/* display to user what the file contains via printing to terminal */
data_parse(filename);
/* add all of these commands to the current command list */
add_file_commands(list, filename);
break;
}
else {
terminal_spacer();
printf("\t\t\tFile Does Not Exist!\n");
break;
}
/* if case->choice is equal to two */
case 2:
system("clear");
terminal_spacer();
add_command(list, make_command());
break;
/* if case->choice is equal to three */
case 3:
system("clear");
terminal_spacer();
printf("\t\t\t Please Enter the Index of the Command you want to Delete: ");
scanf("%1d", &node_index);
delete_command(list, node_index-1);
usleep(250000);
printf("\t\t\t Command Successfully Deleted!\n");
usleep(250000);
break;
case 4:
system("clear");
terminal_spacer();
printf("\t\t\t Please Enter the Amount of Commands You Want To Delete: ");
scanf("%1d", &node_index);
mass_delete_commands(list, node_index);
usleep(250000);
printf("\t\t\t Commands Sucessfully Deleted!\n");
break;
/* if case->choice is equal to four */
case 5:
commands_to_simon(list);
break;
/* if case->choice is equal to five */
case 6:
system("clear");
terminal_spacer();
printf("\t\t\tYour Current Command List: \n");
print_comlist(list);
usleep(250000);
break;
/* if case->choice is equal to six (also exit->contains while loop break->exit(zero)) */
case 7:
system("clear");
terminal_spacer();
terminal_spacer();
usleep(500000);
printf("\t\t\t\t Thankyou For Playing!\n");
usleep(500000);
system("clear");
terminal_spacer();
printf("\t\t\t\t Quiting Game\n");
usleep(500000);
system("clear");
terminal_spacer();
printf("\t\t\t\t Quiting Game.\n");
usleep(500000);
system("clear");
terminal_spacer();
printf("\t\t\t\t Quiting Game..\n");
usleep(500000);
system("clear");
terminal_spacer();
printf("\t\t\t\t Quiting Game...\n");
exit(0);
break;
/* if case->choice is equal to none of above (default) */
default:
printf("\t\t\tInvalid Selection!\n");
break;
}
}
/*freeing allocated memory for command list */
free_comlist(list);
/* main method standard exit return */
return 0;
}
|
Sxlly/SimonSays
|
singleyll.h
|
#ifndef SINGLEYLL_H
#define SINGLEYLL_H
/* structure for creating a command */
typedef struct command {
int selection;
} com_t;
/* node structure */
typedef struct comlist_node {
com_t value;
struct comlist_node* next;
}comlist_node_t;
/* linked list structure */
typedef struct comlist {
comlist_node_t* head;
comlist_node_t* tail;
int size;
}comlist_t;
comlist_t* create_comlist();
void print_comlist(comlist_t* list);
void add_command(comlist_t* list, com_t com);
void free_comlist(comlist_t* list);
void delete_command(comlist_t* list, int node_index);
void mass_delete_commands(comlist_t* list, int amount);
#endif /* SINGLEYLL_H */
|
Sxlly/SimonSays
|
data_parser.h
|
#ifndef DATA_PARSER_H
#define DATA_PARSER_H
void data_parse(char filename[256]);
#endif
|
Sxlly/SimonSays
|
commands_ll.c
|
<gh_stars>0
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <stdbool.h>
#include "commands_ll.h"
struct command {
int data;
int key;
struct command *next;
};
struct command *head = NULL;
struct command *current = NULL;
void insert_first(int key, int data) {
struct command *link = (struct command*) malloc(sizeof(struct command));
link -> key = key;
link -> data = data;
link -> next = head;
head = link;
}
struct command* del_first() {
struct command *temp_link = head;
head = head -> next;
return temp_link;
}
bool is_empty() {
return head == NULL;
}
int list_size() {
int size = 0;
struct command *current;
for (current = head; current != NULL; current -> next) {
size++;
}
return size;
}
struct command* find_com(int key) {
struct command* current = head;
if (head == NULL) {
return NULL;
}
while (current -> key != key) {
if (current -> next == NULL) {
return NULL;
}
else {
current = current -> next;
}
}
return current;
}
struct command* del_com(int key) {
struct command* current = head;
struct command* previous = NULL;
if (head == NULL) {
return NULL;
}
while (current -> key != key) {
if(current -> next == NULL) {
return NULL;
}
else {
previous = current;
current = current -> next;
}
}
if (current == head) {
head = head -> next;
}
else {
previous -> next = current -> next;
}
return current;
}
void reverse_list(struct command** head_reference) {
struct command* prev = NULL;
struct command* current = *head_reference;
struct command* next;
while (current != NULL) {
next = current -> next;
current -> next = prev;
prev = current;
current = next;
}
*head_reference = prev;
}
|
Sxlly/SimonSays
|
singleyll.c
|
#include "singleyll.h"
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include "simon.h"
/* command list creation method */
comlist_t * create_comlist() {
/* using calloc for memory allocation */
/* setting all list nodes to hold NULL value */
comlist_t* new_comlist = (comlist_t*)calloc(1, sizeof(comlist_t));
return new_comlist;
}
/* print to terminal method via iteration (trickle down traversal) */
void print_comlist(comlist_t* list) {
comlist_node_t* current;
/* begin at head node */
/* cont while not at tail index */
/* tracks current index within linked list */
int index_counter = 0;
for (current = list->head; current != NULL; current = current->next) {
/* increase index count by ++ every iteration */
index_counter++;
/* if current nodes value holds a integer one value stored within selection */
if (current->value.selection == 1) {
printf("\t\t\tCommand No %1d = Simon Says Right Arm Up\n", index_counter);
}
/* if current node value holds a integer two value stored within seleciton */
else if (current->value.selection == 2) {
printf("\t\t\tCommand No %1d = Simon Says Left Arm Up\n", index_counter);
}
/* if current node value holds a integer three value stored within selection */
else if (current->value.selection == 3) {
printf("\t\t\tCommand No %1d = Simon Says Hands On Head\n", index_counter);
}
/* if current node value holds a integer four value stored within selection */
else if (current->value.selection == 4) {
printf("\t\t\tCommand No %1d = Simon Says Dance\n", index_counter);
}
/* if current node value holds a integer five value stored within selection */
else if (current->value.selection == 5) {
printf("\t\t\tCommand No %1d = Simon Didn't Say Right Arm Up\n", index_counter);
}
/* if current node value holds a integer six value stored within selection */
else if (current->value.selection == 6) {
printf("\t\t\tCommand No %1d = Simon Didn't Say Left Arm Up\n", index_counter);
}
/* if current node value holds a integer seven value stored within selection */
else if (current->value.selection == 7) {
printf("\t\t\tCommand No %1d = Simon Didn't Say Hands On Head\n", index_counter);
}
/* if current node value holds a integer eight value stored within selection */
else if (current->value.selection == 8) {
printf("\t\t\tCommand No %1d = Simon Didn't Say Dance\n", index_counter);
}
/* else -> command is invalid */
else {
printf("\t\t\tCommand No %1d Holds an invalid command\n", index_counter);
}
}
}
void add_command(comlist_t* list, com_t com) {
comlist_node_t* new_node = malloc(1*sizeof(comlist_node_t));
new_node->value = com;
new_node->next = list->head;
list->head = new_node;
/* if command list is empty the newly added node is both head and tail */
if (list->size == 0) {
list->tail = new_node;
}
list->size++;
}
void delete_command(comlist_t* list, int node_index) {
if (list->size == 0) {
printf("Commands List is Empty!\n");
}
/* create node structure to store current node */
comlist_node_t* current;
/* create ndoe structure to store previous node */
comlist_node_t* prev;
/* begin at head node */
/* cont while not found given node */
/* tracks current index within linked list */
int index_counter = 0;
/* store head node in current node */
current = list->head;
/* iterate through list to search for node to be deleted */
while (current != NULL && index_counter != node_index + 1) {
index_counter++;
/* store the current node as the previous node */
prev = current;
/* store the next current node as the current node */
current = current->next;
}
if (current == NULL) return;
/* unlinking the found node from the list */
prev->next = current->next;
/* decrease list size by one */
list->size--;
/* deleting node (via freeing allocated memory for node) */
free(current);
/*set current value to null */
current = NULL;
}
/* function to delete a large amount of commands from the list at once */
void mass_delete_commands(comlist_t* list, int amount) {
/* if list is empty dont continue */
if (list->size == 0) {
printf("Commands List is Empty!\n");
}
/* declaring variable to keep count of current index */
int index_counter = 0;
/* looping through incrementing by one until index is of equal value to amount */
for (index_counter = 0; index_counter < amount; index_counter++) {
/* every iteration deleting the head node from the command list */
/* utilizing pre defined function delete command */
delete_command(list, 1);
}
}
void free_comlist(comlist_t* list) {
comlist_node_t* current, *next;
while (current != NULL) {
next = current->next;
free(current);
current = next;
}
free(list);
}
|
Sxlly/SimonSays
|
main.h
|
#ifndef MAIN_H
#define MAIN_H
void terminal_spacer();
int main(int argc, char* argv[]);
#endif
|
Sxlly/SimonSays
|
data_parser.c
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include "data_parser.h"
#include "singleyll.h"
void data_parse(char filename[256]) {
FILE* fptr = fopen(filename, "r");
char file_line[256];
system("clear");
printf("\t\t\tThe File You Have Choosen Contains The Following: \n");
while (fgets(file_line, sizeof(file_line), fptr)) {
printf("%256s", file_line);
usleep(100000);
}
fclose(fptr);
}
|
Sxlly/SimonSays
|
user_input.h
|
#ifndef USER_INPUT_H
#define USER_INPUT_H
int file_reader(char filename[]);
#endif
|
Sxlly/SimonSays
|
simon.c
|
<reponame>Sxlly/SimonSays<filename>simon.c
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <time.h>
#include "simon.h"
#include "singleyll.h"
#include "main.h"
void simon_rightarm_gen() {
FILE *fptr;
char str[1000];
fptr = fopen("sframebase.txt", "r");
terminal_spacer();
while (fgets(str, 1000, fptr) != NULL) {
printf("\t\t\t%s", str);
}
fclose(fptr);
fptr = fopen("sframe3.txt", "r");
usleep(500000);
system("clear");
terminal_spacer();
while (fgets(str, 1000, fptr) != NULL) {
printf("\t\t\t%s", str);
}
fclose(fptr);
fptr = fopen("sframe2.txt", "r");
usleep(500000);
system("clear");
terminal_spacer();
while (fgets(str, 1000, fptr) != NULL) {
printf("\t\t\t%s", str);
}
fclose(fptr);
fptr = fopen("sframe1.txt", "r");
usleep(500000);
system("clear");
terminal_spacer();
while (fgets(str, 1000, fptr) != NULL) {
printf("\t\t\t%s", str);
}
fclose(fptr);
fptr = fopen("sframe2.txt", "r");
usleep(500000);
system("clear");
terminal_spacer();
while (fgets(str, 1000, fptr) != NULL) {
printf("\t\t\t%s", str);
}
fclose(fptr);
fptr = fopen("sframe3.txt", "r");
usleep(500000);
system("clear");
terminal_spacer();
while (fgets(str, 1000, fptr) != NULL) {
printf("\t\t\t%s", str);
}
fclose(fptr);
fptr = fopen("sframebase.txt", "r");
usleep(500000);
system("clear");
terminal_spacer();
while (fgets(str, 1000, fptr) != NULL) {
printf("\t\t\t%s", str);
}
fclose(fptr);
}
void simon_leftarm_gen() {
FILE *fptr;
char str[1000];
fptr = fopen("sframebase.txt", "r");
terminal_spacer();
while (fgets(str, 1000, fptr) != NULL) {
printf("\t\t\t%s", str);
}
fclose(fptr);
fptr = fopen("sframe1-1.txt", "r");
usleep(500000);
system("clear");
terminal_spacer();
while (fgets(str, 1000, fptr) != NULL) {
printf("\t\t\t%s", str);
}
fclose(fptr);
fptr = fopen("sframe1-2.txt", "r");
usleep(500000);
system("clear");
terminal_spacer();
while (fgets(str, 1000, fptr) != NULL) {
printf("\t\t\t%s", str);
}
fclose(fptr);
fptr = fopen("sframe1-3.txt", "r");
usleep(500000);
system("clear");
terminal_spacer();
while (fgets(str, 1000, fptr) != NULL) {
printf("\t\t\t%s", str);
}
fclose(fptr);
fptr = fopen("sframe1-2.txt", "r");
usleep(500000);
system("clear");
terminal_spacer();
while (fgets(str, 1000, fptr) != NULL) {
printf("\t\t\t%s", str);
}
fclose(fptr);
fptr = fopen("sframe1-1.txt", "r");
usleep(500000);
system("clear");
terminal_spacer();
while (fgets(str, 1000, fptr) != NULL) {
printf("\t\t\t%s", str);
}
fclose(fptr);
fptr = fopen("sframebase.txt", "r");
usleep(500000);
system("clear");
terminal_spacer();
while (fgets(str, 1000, fptr) != NULL) {
printf("\t\t\t%s", str);
}
fclose(fptr);
}
void simon_handonhead_gen() {
FILE *fptr;
char str[1000];
fptr = fopen("sframebase.txt", "r");
terminal_spacer();
while (fgets(str, 1000, fptr) != NULL) {
printf("\t\t\t%s", str);
}
fclose(fptr);
fptr = fopen("sframe2-1.txt", "r");
usleep(500000);
system("clear");
terminal_spacer();
while (fgets(str, 1000, fptr) != NULL) {
printf("\t\t\t%s", str);
}
fclose(fptr);
fptr = fopen("sframe2-2.txt", "r");
usleep(500000);
system("clear");
terminal_spacer();
while (fgets(str, 1000, fptr) != NULL) {
printf("\t\t\t%s", str);
}
fclose(fptr);
fptr = fopen("sframe2-3.txt", "r");
usleep(500000);
system("clear");
terminal_spacer();
while (fgets(str, 1000, fptr) != NULL) {
printf("\t\t\t%s", str);
}
fclose(fptr);
fptr = fopen("sframe2-2.txt", "r");
usleep(500000);
system("clear");
terminal_spacer();
while (fgets(str, 1000, fptr) != NULL) {
printf("\t\t\t%s", str);
}
fclose(fptr);
fptr = fopen("sframe2-1.txt", "r");
usleep(500000);
system("clear");
terminal_spacer();
while (fgets(str, 1000, fptr) != NULL) {
printf("\t\t\t%s", str);
}
fclose(fptr);
fptr = fopen("sframebase.txt", "r");
usleep(500000);
system("clear");
terminal_spacer();
while (fgets(str, 1000, fptr) != NULL) {
printf("\t\t\t%s", str);
}
fclose(fptr);
}
void simon_dance_gen() {
FILE *fptr;
char str[1000];
fptr = fopen("sframebase.txt", "r");
terminal_spacer();
while (fgets(str, 1000, fptr) != NULL) {
printf("\t\t\t%s", str);
}
fclose(fptr);
fptr = fopen("sframe3-1.txt", "r");
usleep(500000);
system("clear");
terminal_spacer();
while (fgets(str, 1000, fptr) != NULL) {
printf("\t\t\t%s", str);
}
fclose(fptr);
fptr = fopen("sframe3-2.txt", "r");
usleep(500000);
system("clear");
terminal_spacer();
while (fgets(str, 1000, fptr) != NULL) {
printf("\t\t\t%s", str);
}
fclose(fptr);
fptr = fopen("sframe3-3.txt", "r");
usleep(500000);
system("clear");
terminal_spacer();
while (fgets(str, 1000, fptr) != NULL) {
printf("\t\t\t%s", str);
}
fclose(fptr);
fptr = fopen("sframe3-4.txt", "r");
usleep(500000);
system("clear");
terminal_spacer();
while (fgets(str, 1000, fptr) != NULL) {
printf("\t\t\t%s", str);
}
fclose(fptr);
fptr = fopen("sframe3-5.txt", "r");
usleep(500000);
system("clear");
terminal_spacer();
while (fgets(str, 1000, fptr) != NULL) {
printf("\t\t\t%s", str);
}
fclose(fptr);
fptr = fopen("sframe3-6.txt", "r");
usleep(500000);
system("clear");
terminal_spacer();
while (fgets(str, 1000, fptr) != NULL) {
printf("\t\t\t%s", str);
}
fclose(fptr);
fptr = fopen("sframe3-5.txt", "r");
usleep(500000);
system("clear");
terminal_spacer();
while (fgets(str, 1000, fptr) != NULL) {
printf("\t\t\t%s", str);
}
fclose(fptr);
fptr = fopen("sframe3-4.txt", "r");
usleep(500000);
system("clear");
terminal_spacer();
while (fgets(str, 1000, fptr) != NULL) {
printf("\t\t\t%s", str);
}
fclose(fptr);
fptr = fopen("sframe3-3.txt", "r");
usleep(500000);
system("clear");
terminal_spacer();
while (fgets(str, 1000, fptr) != NULL) {
printf("\t\t\t%s", str);
}
fclose(fptr);
fptr = fopen("sframe3-2.txt", "r");
usleep(500000);
system("clear");
terminal_spacer();
while (fgets(str, 1000, fptr) != NULL) {
printf("\t\t\t%s", str);
}
fclose(fptr);
fptr = fopen("sframe3-1.txt", "r");
usleep(500000);
system("clear");
terminal_spacer();
while (fgets(str, 1000, fptr) != NULL) {
printf("\t\t\t%s", str);
}
fclose(fptr);
fptr = fopen("sframebase.txt", "r");
usleep(500000);
system("clear");
terminal_spacer();
while (fgets(str, 1000, fptr) != NULL) {
printf("\t\t\t%s", str);
}
fclose(fptr);
}
void simon_ds_gen() {
FILE *fptr;
char str[1000];
fptr = fopen("sframebase.txt", "r");
terminal_spacer();
while (fgets(str, 1000, fptr) != NULL) {
printf("\t\t\t%s", str);
}
fclose(fptr);
fptr = fopen("sdsframe1.txt", "r");
usleep(500000);
system("clear");
terminal_spacer();
while (fgets(str, 1000, fptr) != NULL) {
printf("\t\t\t%s", str);
}
fclose(fptr);
fptr = fopen("sdsframe2.txt", "r");
usleep(500000);
system("clear");
terminal_spacer();
while (fgets(str, 1000, fptr) != NULL) {
printf("\t\t\t%s", str);
}
fclose(fptr);
fptr = fopen("sdsframe3.txt", "r");
usleep(500000);
system("clear");
terminal_spacer();
while (fgets(str, 1000, fptr) != NULL) {
printf("\t\t\t%s", str);
}
fclose(fptr);
fptr = fopen("sdsframe2.txt", "r");
usleep(500000);
system("clear");
terminal_spacer();
while (fgets(str, 1000, fptr) != NULL) {
printf("\t\t\t%s", str);
}
fclose(fptr);
fptr = fopen("sdsframe1.txt", "r");
usleep(500000);
system("clear");
terminal_spacer();
while (fgets(str, 1000, fptr) != NULL) {
printf("\t\t\t%s", str);
}
fclose(fptr);
fptr = fopen("sframebase.txt", "r");
usleep(500000);
system("clear");
terminal_spacer();
while (fgets(str, 1000, fptr) != NULL) {
printf("\t\t\t%s", str);
}
fclose(fptr);
}
/* function to parse commands from commands linked list to simon animation methods */
void commands_to_simon(comlist_t* list) {
/* declaring variable to count current index value */
int index_counter = 0;
comlist_node_t* current;
for (current = list->head; current != NULL; current = current->next) {
index_counter++;
if (current->value.selection == 1) {
system("clear");
simon_rightarm_gen();
usleep(500000);
}
else if (current->value.selection == 2) {
system("clear");
simon_leftarm_gen();
usleep(500000);
}
else if (current->value.selection == 3) {
system("clear");
simon_handonhead_gen();
usleep(500000);
}
else if (current->value.selection == 4) {
system("clear");
simon_dance_gen();
usleep(500000);
}
else {
system("clear");
simon_ds_gen();
usleep(500000);
}
}
}
|
Sxlly/SimonSays
|
simon.h
|
#ifndef SIMON_H
#define SIMON_H
#include "singleyll.h"
void simon_rightarm_gen();
void simon_leftarm_gen();
void simon_handonhead_gen();
void simon_dance_gen();
void simon_ds_gen();
void commands_to_simon(comlist_t *list);
#endif
|
Gazareth/clippy
|
jni/com.esotericsoftware.clippy.tobii.EyeX.h
|
<reponame>Gazareth/clippy<gh_stars>100-1000
#include <jni.h>
#ifdef __cplusplus
extern "C" {
#endif
JNIEXPORT jlong JNICALL Java_com_esotericsoftware_clippy_tobii_EyeX__1connect (JNIEnv*, jobject, jstring);
JNIEXPORT jboolean JNICALL Java_com_esotericsoftware_clippy_tobii_EyeX__1disconnect (JNIEnv*, jobject, jlong);
#ifdef __cplusplus
}
#endif
|
Gazareth/clippy
|
jni/com.esotericsoftware.clippy.tobii.EyeX.c
|
#include <com.esotericsoftware.clippy.tobii.EyeX.h>
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
#include <assert.h>
#include "eyex/EyeX.h"
static JavaVM* jvm = NULL;
static __declspec(thread) JNIEnv* threadEnv = NULL;
typedef struct EyeX {
jobject object;
jmethodID eventMethod;
jmethodID gazeEventMethod;
jmethodID eyeEventMethod;
TX_CONTEXTHANDLE context;
TX_HANDLE interactorSnapshot;
} EyeX;
typedef enum {
connectTrying, connected, connectFailed, serverTooHigh, serverTooLow, commitSnapshotFailed, disconnected, eventError
} Event;
/* Initializes the snapshot with an interactor that has the Gaze Point behavior. */
BOOL initializeInteractorSnapshot (EyeX* eyex, const char* interactorID) {
TX_HANDLE interactor = TX_EMPTY_HANDLE;
TX_GAZEPOINTDATAPARAMS params = { TX_GAZEPOINTDATAMODE_LIGHTLYFILTERED };
TX_HANDLE behavior = TX_EMPTY_HANDLE;
BOOL success;
success = txCreateGlobalInteractorSnapshot(
eyex->context,
interactorID,
&eyex->interactorSnapshot,
&interactor
) == TX_RESULT_OK;
success &= txCreateGazePointDataBehavior(interactor, ¶ms) == TX_RESULT_OK;
success &= txCreateInteractorBehavior(interactor, &behavior, TX_BEHAVIORTYPE_EYEPOSITIONDATA) == TX_RESULT_OK;
txReleaseObject(&behavior);
txReleaseObject(&interactor);
return success;
}
void notify (EyeX* eyex, Event event) {
if (!threadEnv) (*jvm)->AttachCurrentThread(jvm, (void**)&threadEnv, NULL);
(*threadEnv)->CallVoidMethod(threadEnv, eyex->object, eyex->eventMethod, event);
}
void notifyGaze (EyeX* eyex, TX_GAZEPOINTDATAEVENTPARAMS params) {
if (!threadEnv) (*jvm)->AttachCurrentThread(jvm, (void**)&threadEnv, NULL);
(*threadEnv)->CallVoidMethod(threadEnv, eyex->object, eyex->gazeEventMethod,
params.Timestamp,
params.X,
params.Y
);
}
void notifyEye (EyeX* eyex, TX_EYEPOSITIONDATAEVENTPARAMS params) {
if (!threadEnv) (*jvm)->AttachCurrentThread(jvm, (void**)&threadEnv, NULL);
(*threadEnv)->CallVoidMethod(threadEnv, eyex->object, eyex->eyeEventMethod,
params.Timestamp,
params.HasLeftEyePosition,
params.HasRightEyePosition,
params.LeftEyeX,
params.LeftEyeY,
params.LeftEyeZ,
params.LeftEyeXNormalized,
params.LeftEyeYNormalized,
params.LeftEyeZNormalized,
params.RightEyeX,
params.RightEyeY,
params.RightEyeZ,
params.RightEyeXNormalized,
params.RightEyeYNormalized,
params.RightEyeZNormalized
);
}
/* Callback invoked when a snapshot has been committed. */
void TX_CALLCONVENTION OnSnapshotCommitted (TX_CONSTHANDLE asyncData, TX_USERPARAM userParam) {
// Check the result code to catch validation errors and runtime errors in debug builds.
TX_RESULT result = TX_RESULT_UNKNOWN;
txGetAsyncDataResultCode(asyncData, &result);
assert(result == TX_RESULT_OK || result == TX_RESULT_CANCELLED);
}
/* Callback invoked when the status of the connection to the EyeX Engine has changed. */
void TX_CALLCONVENTION OnEngineConnectionStateChanged (TX_CONNECTIONSTATE connectionState, TX_USERPARAM userParam) {
EyeX* eyex = (EyeX*)userParam;
switch (connectionState) {
case TX_CONNECTIONSTATE_CONNECTED: {
notify(eyex, connected);
// Commit the interactor snapshot as soon as the connection to the engine is established.
// This cannot be done earlier because committing means "send to the engine".
if (txCommitSnapshotAsync(eyex->interactorSnapshot, OnSnapshotCommitted, NULL) != TX_RESULT_OK)
notify(eyex, commitSnapshotFailed);
break;
}
case TX_CONNECTIONSTATE_DISCONNECTED:
notify(eyex, disconnected);
break;
case TX_CONNECTIONSTATE_TRYINGTOCONNECT:
notify(eyex, connectTrying);
break;
case TX_CONNECTIONSTATE_SERVERVERSIONTOOLOW:
notify(eyex, serverTooLow);
break;
case TX_CONNECTIONSTATE_SERVERVERSIONTOOHIGH:
notify(eyex, serverTooHigh);
break;
}
}
/* Callback invoked when an event has been received from the EyeX Engine. */
void TX_CALLCONVENTION HandleEvent (TX_CONSTHANDLE hAsyncData, TX_USERPARAM userParam) {
EyeX* eyex = (EyeX*)userParam;
TX_HANDLE event = TX_EMPTY_HANDLE;
txGetAsyncDataContent(hAsyncData, &event);
TX_HANDLE behavior = TX_EMPTY_HANDLE;
if (txGetEventBehavior(event, &behavior, TX_BEHAVIORTYPE_GAZEPOINTDATA) == TX_RESULT_OK) {
TX_GAZEPOINTDATAEVENTPARAMS params;
if (txGetGazePointDataEventParams(behavior, ¶ms) == TX_RESULT_OK)
notifyGaze(eyex, params);
else
notify(eyex, eventError);
txReleaseObject(&behavior);
}
behavior = TX_EMPTY_HANDLE;
if (txGetEventBehavior(event, &behavior, TX_BEHAVIORTYPE_EYEPOSITIONDATA) == TX_RESULT_OK) {
TX_EYEPOSITIONDATAEVENTPARAMS params;
if (txGetEyePositionDataEventParams(behavior, ¶ms) == TX_RESULT_OK)
notifyEye(eyex, params);
else
notify(eyex, eventError);
txReleaseObject(&behavior);
}
txReleaseObject(&event);
}
JNIEXPORT jlong JNICALL Java_com_esotericsoftware_clippy_tobii_EyeX__1connect (JNIEnv* env, jobject object, jstring j_interactorID) {
if (!jvm) (*env)->GetJavaVM(env, &jvm);
threadEnv = env;
const char* interactorID = (*env)->GetStringUTFChars(env, j_interactorID, 0);
EyeX* eyex = malloc(sizeof(EyeX));
eyex->object = (*env)->NewGlobalRef(env, object);
eyex->eventMethod = (*env)->GetMethodID(env, (*env)->GetObjectClass(env, eyex->object), "event", "(I)V");
eyex->gazeEventMethod = (*env)->GetMethodID(env, (*env)->GetObjectClass(env, eyex->object), "gazeEvent", "(DDD)V");
eyex->eyeEventMethod = (*env)->GetMethodID(env, (*env)->GetObjectClass(env, eyex->object), "eyeEvent", "(DZZDDDDDDDDDDDD)V");
eyex->context = TX_EMPTY_HANDLE;
eyex->interactorSnapshot = TX_EMPTY_HANDLE;
BOOL success = txInitializeEyeX(TX_EYEXCOMPONENTOVERRIDEFLAG_NONE, NULL, NULL, NULL, NULL) == TX_RESULT_OK;
success &= txCreateContext(&eyex->context, TX_FALSE) == TX_RESULT_OK;
success &= initializeInteractorSnapshot(eyex, interactorID);
TX_TICKET connectionStateChangedTicket = TX_INVALID_TICKET;
success &= txRegisterConnectionStateChangedHandler(eyex->context, &connectionStateChangedTicket, OnEngineConnectionStateChanged, eyex) == TX_RESULT_OK;
TX_TICKET eventHandlerTicket = TX_INVALID_TICKET;
success &= txRegisterEventHandler(eyex->context, &eventHandlerTicket, HandleEvent, eyex) == TX_RESULT_OK;
success &= txEnableConnection(eyex->context) == TX_RESULT_OK;
(*env)->ReleaseStringUTFChars(env, j_interactorID, interactorID);
return success ? (jlong)eyex : 0;
}
JNIEXPORT jboolean JNICALL Java_com_esotericsoftware_clippy_tobii_EyeX__1disconnect (JNIEnv* env, jobject object, jlong address) {
EyeX* eyex = (EyeX*)address;
txDisableConnection(eyex->context);
txReleaseObject(&eyex->interactorSnapshot);
BOOL success = txShutdownContext(eyex->context, TX_CLEANUPTIMEOUT_DEFAULT, TX_FALSE) == TX_RESULT_OK;
success &= txReleaseContext(&eyex->context) == TX_RESULT_OK;
success &= txUninitializeEyeX() == TX_RESULT_OK;
(*env)->DeleteGlobalRef(env, object);
return success;
}
|
UzxMx/xf_sdk
|
ext/xf_sdk/qisr.h
|
<gh_stars>100-1000
/**
* @file qisr.h
* @brief iFLY Speech Recognizer Header File
*
* This file contains the quick application programming interface (API) declarations
* of ISR. Developer can include this file in your project to build applications.
* For more information, please read the developer guide.
* Use of this software is subject to certain restrictions and limitations set
* forth in a license agreement entered into between iFLYTEK, Co,LTD.
* and the licensee of this software. Please refer to the license
* agreement for license use rights and restrictions.
*
* Copyright (C) 1999 - 2007 by ANHUI USTC iFLYTEK, Co,LTD.
* All rights reserved.
*
* @author Speech Dept. iFLYTEK.
* @version 1.0
* @date 2008/12/12
*
* @see
*
* History:
* index version date author notes
* 0 1.0 2008/12/12 Speech Create this file
*/
#ifndef __QISR_H__
#define __QISR_H__
#ifdef __cplusplus
extern "C" {
#endif /* C++ */
#include "msp_types.h"
/**
* @fn QISRSessionBegin
* @brief Begin a Recognizer Session
*
* Create a recognizer session to recognize audio data
*
* @return return sessionID of current session, NULL is failed.
* @param const char* grammarList - [in] grammars list, inline grammar support only one.
* @param const char* params - [in] parameters when the session created.
* @param int *errorCode - [out] return 0 on success, otherwise return error code.
* @see
*/
const char* MSPAPI QISRSessionBegin(const char* grammarList, const char* params, int* errorCode);
typedef const char* (MSPAPI *Proc_QISRSessionBegin)(const char* grammarList, const char* params, int *result);
#ifdef MSP_WCHAR_SUPPORT
const wchar_t* MSPAPI QISRSessionBeginW(const wchar_t* grammarList, const wchar_t* params, int *result);
typedef const wchar_t* (MSPAPI *Proc_QISRSessionBeginW)(const wchar_t* grammarList, const wchar_t* params, int *result);
#endif
/**
* @fn QISRAudioWrite
* @brief Write Audio Data to Recognizer Session
*
* Writing binary audio data to recognizer.
*
* @return int MSPAPI - Return 0 in success, otherwise return error code.
* @param const char* sessionID - [in] The session id returned by recog_begin
* @param const void* waveData - [in] Binary data of waveform
* @param unsigned int waveLen - [in] Waveform data size in bytes
* @param int audioStatus - [in] Audio status, can be
* @param int *epStatus - [out] ISRepState
* @param int *recogStatus - [out] ISRrecRecognizerStatus, see isr_rec.h
* @see
*/
int MSPAPI QISRAudioWrite(const char* sessionID, const void* waveData, unsigned int waveLen, int audioStatus, int *epStatus, int *recogStatus);
typedef int (MSPAPI *Proc_QISRAudioWrite)(const char* sessionID, const void* waveData, unsigned int waveLen, int audioStatus, int *epStatus, int *recogStatus);
#ifdef MSP_WCHAR_SUPPORT
int MSPAPI QISRAudioWriteW(const wchar_t* sessionID, const void* waveData, unsigned int waveLen, int audioStatus, int *epStatus, int *recogStatus);
typedef int (MSPAPI *Proc_QISRAudioWriteW)(const wchar_t* sessionID, const void* waveData, unsigned int waveLen, int audioStatus, int *epStatus, int *recogStatus);
#endif
/**
* @fn QISRGetResult
* @brief Get Recognize Result in Specified Format
*
* Get recognize result in Specified format.
*
* @return int MSPAPI - Return 0 in success, otherwise return error code.
* @param const char* sessionID - [in] session id returned by session begin
* @param int* rsltStatus - [out] status of recognition result, 0: success, 1: no match, 2: incomplete, 5:speech complete
* @param int *errorCode - [out] return 0 on success, otherwise return error code.
* @see
*/
const char * MSPAPI QISRGetResult(const char* sessionID, int* rsltStatus, int waitTime, int *errorCode);
typedef const char * (MSPAPI *Proc_QISRGetResult)(const char* sessionID, int* rsltStatus, int waitTime, int *errorCode);
#ifdef MSP_WCHAR_SUPPORT
const wchar_t* MSPAPI QISRGetResultW(const wchar_t* sessionID, int* rsltStatus, int waitTime, int *errorCode);
typedef const wchar_t* (MSPAPI *Proc_QISRGetResultW)(const wchar_t* sessionID, int* rsltStatus, int waitTime, int *errorCode);
#endif
/**
* @fn QISRGetBinaryResult
* @brief Get Recognize Result in Specified Format
*
* Get recognize result in Specified format.
*
* @return int MSPAPI - Return 0 in success, otherwise return error code.
* @param const char* sessionID - [in] session id returned by session begin
* @param int* rsltStatus - [out] status of recognition result, 0: success, 1: no match, 2: incomplete, 5:speech complete
* @param int *errorCode - [out] return 0 on success, otherwise return error code.
* @see
*/
const char * MSPAPI QISRGetBinaryResult(const char* sessionID, unsigned int* rsltLen,int* rsltStatus, int waitTime, int *errorCode);
typedef const char * (MSPAPI *Proc_QISRGetBinaryResult)(const char* sessionID, unsigned int* rsltLen, int* rsltStatus, int waitTime, int *errorCode);
#ifdef MSP_WCHAR_SUPPORT
const wchar_t* MSPAPI QISRGetBinaryResultW(const wchar_t* sessionID, unsigned int* rsltLen, int* rsltStatus, int waitTime, int *errorCode);
typedef const wchar_t* (MSPAPI *Proc_QISRGetBinaryResultW)(const wchar_t* sessionID, unsigned int* rsltLen, int* rsltStatus, int waitTime, int *errorCode);
#endif
/**
* @fn QISRSessionEnd
* @brief End a Recognizer Session
*
* End the recognizer session, release all resource.
*
* @return int MSPAPI - Return 0 in success, otherwise return error code.
* @param const char* sessionID - [in] session id string to end
* @param const char* hints - [in] user hints to end session, hints will be logged to CallLog
* @see
*/
int MSPAPI QISRSessionEnd(const char* sessionID, const char* hints);
typedef int (MSPAPI *Proc_QISRSessionEnd)(const char* sessionID, const char* hints);
#ifdef MSP_WCHAR_SUPPORT
int MSPAPI QISRSessionEndW(const wchar_t* sessionID, const wchar_t* hints);
typedef int (MSPAPI *Proc_QISRSessionEndW)(const wchar_t* sessionID, const wchar_t* hints);
#endif
/**
* @fn QISRGetParam
* @brief get params related with msc
*
* the params could be local or server param, we only support netflow params "upflow" & "downflow" now
*
* @return int - Return 0 if success, otherwise return errcode.
* @param const char* sessionID - [in] session id of related param, set NULL to got global param
* @param const char* paramName - [in] param name,could pass more than one param split by ','';'or'\n'
* @param const char* paramValue - [in] param value buffer, malloced by user
* @param int *valueLen - [in, out] pass in length of value buffer, and return length of value string
* @see
*/
int MSPAPI QISRGetParam(const char* sessionID, const char* paramName, char* paramValue, unsigned int* valueLen);
typedef int (MSPAPI *Proc_QISRGetParam)(const char* sessionID, const char* paramName, char* paramValue, unsigned int* valueLen);
#ifdef MSP_WCHAR_SUPPORT
int MSPAPI QISRGetParamW(const wchar_t* sessionID, const wchar_t* paramName, wchar_t* paramValue, unsigned int* valueLen);
typedef int (MSPAPI *Proc_QISRGetParamW)(const wchar_t* sessionID, const wchar_t* paramName, wchar_t* paramValue, unsigned int* valueLen);
#endif
/**
* @fn QISRSetParam
* @brief get params related with msc
*
* the params could be local or server param, we only support netflow params "upflow" & "downflow" now
*
* @return int - Return 0 if success, otherwise return errcode.
* @param const char* sessionID - [in] session id of related param, set NULL to got global param
* @param const char* paramName - [in] param name,could pass more than one param split by ','';'or'\n'
* @param const char* paramValue - [in] param value buffer, malloced by user
* @param int *valueLen - [in, out] pass in length of value buffer, and return length of value string
* @see
*/
int MSPAPI QISRSetParam(const char* sessionID, const char* paramName, const char* paramValue);
typedef int (MSPAPI *Proc_QISRSetParam)(const char* sessionID, const char* paramName, const char* paramValue);
#ifdef MSP_WCHAR_SUPPORT
int MSPAPI QISRSetParamW(const wchar_t* sessionID, const wchar_t* paramName, const wchar_t* paramValue);
typedef int (MSPAPI *Proc_QISRSetParamW)(const wchar_t* sessionID, const wchar_t* paramName, const wchar_t* paramValue);
#endif
typedef void ( *recog_result_ntf_handler)( const char *sessionID, const char *result, int resultLen, int resultStatus, void *userData );
typedef void ( *recog_status_ntf_handler)( const char *sessionID, int type, int status, int param1, const void *param2, void *userData);
typedef void ( *recog_error_ntf_handler)(const char *sessionID, int errorCode, const char *detail, void *userData);
int MSPAPI QISRRegisterNotify(const char *sessionID, recog_result_ntf_handler rsltCb, recog_status_ntf_handler statusCb, recog_error_ntf_handler errCb, void *userData);
typedef int ( *UserCallBack)( int, const char*, void*);
typedef int ( *GrammarCallBack)( int, const char*, void*);
typedef int ( *LexiconCallBack)( int, const char*, void*);
int MSPAPI QISRBuildGrammar(const char *grammarType, const char *grammarContent, unsigned int grammarLength, const char *params, GrammarCallBack callback, void *userData);
typedef int (MSPAPI *Proc_QISRBuildGrammar)(const char *grammarType, const char *grammarContent, unsigned int grammarLength, const char *params, GrammarCallBack callback, void *userData);
#ifdef MSP_WCHAR_SUPPORT
int MSPAPI QISRBuildGrammarW(const wchar_t *grmmarType, const wchar_t *grammarContent, unsigned int grammarLength, const wchar_t *params, GrammarCallBack callback, void *userData);
typedef int (MSPAPI *Proc_QISRBuildGrammarW)(const wchar_t *grmmarType, const wchar_t *grammarContent, unsigned int grammarLength, const wchar_t *params, GrammarCallBack callback, void *userData);
#endif
int MSPAPI QISRUpdateLexicon(const char *lexiconName, const char *lexiconContent, unsigned int lexiconLength, const char *params, LexiconCallBack callback, void *userData);
typedef int (MSPAPI *Proc_QISRUpdataLexicon)(const char *lexiconName, const char *lexiconContent, unsigned int lexiconLength, const char *params, LexiconCallBack callback, void *userData);
#ifdef MSP_WCHAR_SUPPORT
int MSPAPI QISRUpdateLexiconW(const wchar_t *lexiconName, const wchar_t *lexiconContent, unsigned int lexiconLength, const wchar_t *params, LexiconCallBack callback, void *userData);
typedef int (MSPAPI Proc_QISRUpdateLexiconW)(const wchar_t *lexiconName, const wchar_t *lexiconContent, unsigned int lexiconLength, const wchar_t *params, LexiconCallBack callback, void *userData);
#endif
#ifdef __cplusplus
} /* extern "C" */
#endif /* C++ */
#endif /* __QISR_H__ */
|
UzxMx/xf_sdk
|
ext/xf_sdk/xf_sdk.c
|
<reponame>UzxMx/xf_sdk
#include "xf_sdk.h"
#include "msp_errors.h"
VALUE rb_mXfSdk;
void
Init_xf_sdk(void)
{
rb_mXfSdk = rb_define_module("XfSdk");
VALUE mod = rb_define_module_under(rb_mXfSdk, "Internal");
rb_define_singleton_method(mod, "tts", tts, 3);
rb_define_singleton_method(mod, "success?", is_success, 1);
}
VALUE is_success(VALUE mod, VALUE code) {
return NUM2INT(code) == MSP_SUCCESS ? Qtrue : Qfalse;
}
|
UzxMx/xf_sdk
|
ext/xf_sdk/xf_sdk.h
|
<gh_stars>0
#ifndef XF_SDK_H
#define XF_SDK_H 1
#include "ruby.h"
VALUE tts(VALUE mod, VALUE text, VALUE dest_path, VALUE params);
VALUE is_success(VALUE mod, VALUE code);
#endif /* XF_SDK_H */
|
xq-120/JKPresentationController
|
JKPresentationControllerDemo/JKPresentationControllerDemo/JKInterActiveGroupVipUserModel.h
|
//
// ZAEInterActiveGroupVipUserModel.h
// JKPresentationControllerDemo
//
// Created by xuequan on 2020/10/14.
// Copyright © 2020 xuequan. All rights reserved.
//
#import <Foundation/Foundation.h>
NS_ASSUME_NONNULL_BEGIN
@interface JKInterActiveGroupVipUserModel : NSObject
@property (nonatomic, assign) NSInteger userID; ///< 用户ID
@property (nonatomic, copy) NSString *nickname; ///< 昵称
@property (nonatomic, copy) NSString *avatar; ///< 头像
@end
NS_ASSUME_NONNULL_END
|
xq-120/JKPresentationController
|
JKPresentationController/JKBaseAlertViewController.h
|
//
// JKBaseAlertViewController.h
// JKPresentationController
//
// Created by xuequan on 2020/9/13.
//
#import <UIKit/UIKit.h>
NS_ASSUME_NONNULL_BEGIN
@interface JKBaseAlertViewController : UIViewController
@property (nonatomic, strong) UIColor *backViewBgColor;
/** 默认NO。 */
@property (nonatomic, assign) BOOL shouldDismissOnTouchBackView;
@property (nonatomic, assign) NSInteger tag;
@property (nonatomic, readonly, strong) UIView *contentView;
/** shouldDismissOnTouchBackView为YES时，点击蒙层消失回调。 */
@property (nonatomic, copy) void (^dismissOnTouchBackViewBlk)(void);
- (instancetype)init;
@end
NS_ASSUME_NONNULL_END
|
resetius/graphtoys
|
models/particles.c
|
<reponame>resetius/graphtoys<filename>models/particles.c
#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#include <render/render.h>
#include <render/pipeline.h>
#include <lib/linmath.h>
#include <models/particles.vert.h>
#include <models/particles.frag.h>
#include <models/particles.comp.h>
#include <models/particles.vert.spv.h>
#include <models/particles.frag.spv.h>
#include <models/particles.comp.spv.h>
#include "particles.h"
#include "particles_data.h"
struct Particles {
struct Object base;
struct Pipeline* comp;
struct Pipeline* pl;
struct BufferManager* b;
int particles;
int uniform;
int pos;
int new_pos;
int accel;
int vel;
int pos_vao;
int new_pos_vao;
int model;
float z;
quat q;
double ax, ay, az;
};
static int max(int a, int b) {
return a>b?a:b;
}
// TODO: copy-paste
static void transform(struct Particles* t) {
vec3 ox = {1,0,0};
vec3 oy = {0,1,0};
vec3 oz = {0,0,1};
quat ox1 = {1,0,0,0};
quat oy1 = {0,1,0,0};
quat oz1 = {0,0,1,0};
quat qx, qy, qz, q;
quat_conj(q, t->q);
quat_mul(ox1, ox1, t->q);
quat_mul(ox1, q, ox1);
memcpy(ox, ox1, sizeof(vec3));
quat_mul(oy1, oy1, t->q);
quat_mul(oy1, q, oy1);
memcpy(oy, oy1, sizeof(vec3));
quat_mul(oz1, oz1, t->q);
quat_mul(oz1, q, oz1);
memcpy(oz, oz1, sizeof(vec3));
quat_rotate(qx, t->ax, ox);
quat_rotate(qy, t->ay, oy);
quat_rotate(qz, t->az, oz);
quat_mul(t->q, t->q, qx);
quat_mul(t->q, t->q, qy);
quat_mul(t->q, t->q, qz);
t->ax = t->ay = t->az = 0;
}
static void move_left(struct Object* obj, int mods) {
struct Particles* t = (struct Particles*)obj;
t->az += -5*M_PI/360;
transform(t);
}
static void move_right(struct Object* obj, int mods) {
struct Particles* t = (struct Particles*)obj;
t->az += 5*M_PI/360;
transform(t);
}
static void move_up(struct Object* obj, int mods) {
struct Particles* t = (struct Particles*)obj;
t->ax += -5*M_PI/360;
transform(t);
}
static void move_down(struct Object* obj, int mods) {
struct Particles* t = (struct Particles*)obj;
t->ax += 5*M_PI/360;
transform(t);
}
static void zoom_in(struct Object* obj, int mods) {
struct Particles* t = (struct Particles*)obj;
if (mods & 1) {
t->z /= 2;
printf("%f\n", t->z);
} else {
t->ay -= 5*M_PI/360;
transform(t);
}
}
static void zoom_out(struct Object* obj, int mods) {
struct Particles* t = (struct Particles*)obj;
if (mods & 1) {
t->z *= 2;
printf("%f\n", t->z);
} else {
t->ay += 5*M_PI/360;
transform(t);
}
}
static void draw_(struct Object* obj, struct DrawContext* ctx) {
struct Particles* t = (struct Particles*)obj;
mat4x4 m, p, v, mv, mvp;
mat4x4_identity(m);
mat4x4_from_quat(m, t->q);
//mat4x4_scale(m, m, 10000);
//mat4x4_rotate_X(m, m, ctx->time);
//mat4x4_rotate_Y(m, m, ctx->time);
//mat4x4_rotate_Z(m, m, ctx->time);
/*for (int i = 0; i < 4; i++) {
for (int j = 0; j < 4; j++) {
printf("%f ", m[i][j]);
}
printf("\n");
}
printf("\n");*/
//mat4x4_ortho(p, -ctx->ratio, ctx->ratio, -1.f, 1.f, 1.f, -1.f);
//mat4x4_mul(mvp, p, m);
//vec3 eye = {.0f, .0f, 10.f};
vec3 eye = {.0f, .0f, t->z};
vec3 center = {.0f, .0f, .0f};
//vec3 up = {.0f, 1.f, .0f};
vec3 up = {.0f, 1.f, .0f};
mat4x4_look_at(v, eye, center, up);
mat4x4_mul(mv, v, m);
mat4x4_perspective(p, 70./2./M_PI, ctx->ratio, 0.3f, 1000.f);
mat4x4_mul(mvp, p, mv);
//printf("particles %d\n", t->particles);
t->comp->start_compute(t->comp, max(1, t->particles/100), 1, 1);
//t->pl->buffer_copy(t->pl, t->pos, t->new_pos);
t->pl->start(t->pl);
buffer_update(t->b, t->uniform, &mvp[0][0], 0, sizeof(mat4x4));
//t->pl->draw(t->pl, t->new_pos_vao);
t->pl->draw(t->pl, t->pos_vao);
int tt = t->pos_vao; t->pos_vao = t->new_pos_vao; t->new_pos_vao = tt;
t->comp->storage_swap(t->comp, 0, 3);
}
static void free_(struct Object* obj) {
struct Particles* t = (struct Particles*)obj;
t->pl->free(t->pl);
t->comp->free(t->comp);
t->b->free(t->b);
free(obj);
}
struct Object* CreateParticles(struct Render* r, struct Config* cfg) {
struct Particles* t = calloc(1, sizeof(struct Particles));
struct Object base = {
.move_left = move_left,
.move_right = move_right,
.move_up = move_up,
.move_down = move_down,
.zoom_in = zoom_in,
.zoom_out = zoom_out,
.draw = draw_,
.free = free_
};
t->base = base;
struct PipelineBuilder* pl = r->pipeline(r);
struct ShaderCode vertex_shader = {
.glsl = models_particles_vert,
.spir_v = models_particles_vert_spv,
.size = models_particles_vert_spv_size,
};
struct ShaderCode fragment_shader = {
.glsl = models_particles_frag,
.spir_v = models_particles_frag_spv,
.size = models_particles_frag_spv_size,
};
struct ShaderCode compute_shader = {
.glsl = models_particles_comp,
.spir_v = models_particles_comp_spv,
.size = models_particles_comp_spv_size,
};
t->b = r->buffer_manager(r);
t->comp = pl
->set_bmgr(pl, t->b)
->begin_program(pl)
->add_cs(pl, compute_shader)
->end_program(pl)
->storage_add(pl, 0, "Pos")
->storage_add(pl, 1, "Vel")
->storage_add(pl, 2, "Tmp")
->storage_add(pl, 3, "NewPos")
->build(pl);
pl = r->pipeline(r);
t->pl = pl
->set_bmgr(pl, t->b)
->begin_program(pl)
->add_vs(pl, vertex_shader)
->add_fs(pl, fragment_shader)
->end_program(pl)
->uniform_add(pl, 0, "MatrixBlock")
->begin_buffer(pl, 4*sizeof(float))
->buffer_attribute(pl, 1, 4, DATA_FLOAT, 0)
->end_buffer(pl)
->geometry(pl, GEOM_POINTS)
->build(pl);
quat_identity(t->q);
struct ParticlesData data;
particles_data_init(&data, cfg);
t->z = 1.0f;
t->particles = data.n_particles;
int size = t->particles*4*sizeof(float);
t->uniform = t->b->create(t->b, BUFFER_UNIFORM, MEMORY_DYNAMIC, NULL, sizeof(mat4x4));
t->pos = t->b->create(t->b, BUFFER_SHADER_STORAGE, MEMORY_DYNAMIC, data.coords, size);
t->vel = t->b->create(t->b, BUFFER_SHADER_STORAGE, MEMORY_DYNAMIC_COPY, data.vels, size);
t->accel = t->b->create(t->b, BUFFER_SHADER_STORAGE, MEMORY_DYNAMIC_COPY, data.accel, size);
t->new_pos = t->b->create(t->b, BUFFER_SHADER_STORAGE, MEMORY_DYNAMIC, data.coords, size);
t->pos_vao = t->pl->buffer_assign(t->pl, 0, t->pos);
t->new_pos_vao = t->pl->buffer_assign(t->pl, 0, t->new_pos);
t->pl->uniform_assign(t->pl, 0, t->uniform);
t->comp->storage_assign(t->comp, 0, t->pos);
t->comp->storage_assign(t->comp, 1, t->vel);
t->comp->storage_assign(t->comp, 2, t->accel);
t->comp->storage_assign(t->comp, 3, t->new_pos);
return (struct Object*)t;
}
|
resetius/graphtoys
|
vulkan/tools.h
|
#pragma once
#include "vk.h"
void create_buffer(
VkPhysicalDeviceMemoryProperties props,
VkDevice logicalDevice,
VkDeviceSize size,
VkBufferUsageFlags usage,
VkMemoryPropertyFlags properties,
VkBuffer* buffer,
VkDeviceMemory* bufferMemory);
void copy_buffer(
int graphics_family,
VkQueue g_queue,
VkDevice logicalDevice,
VkBuffer srcBuffer,
VkBuffer dstBuffer,
VkDeviceSize size);
void create_image(
VkPhysicalDeviceMemoryProperties props,
VkDevice device,
uint32_t width,
uint32_t height,
VkFormat format,
VkImageTiling tiling,
VkImageUsageFlags usage,
VkMemoryPropertyFlags properties,
VkImage* image,
VkDeviceMemory* imageMemory);
VkImageView create_image_view(
VkDevice logDev, VkImage image, VkFormat format, VkImageAspectFlags aspectFlags);
void transition_image_layout(
int graphics_family,
VkQueue g_queue,
VkDevice logicalDevice,
VkImage image, VkFormat format, VkImageLayout oldLayout, VkImageLayout newLayout);
void copy_buffer_to_image(
int graphics_family,
VkQueue g_queue,
VkDevice logicalDevice,
VkBuffer buffer, VkImage image, uint32_t width, uint32_t height);
|
resetius/graphtoys
|
models/torus.h
|
<reponame>resetius/graphtoys
#pragma once
#include <render/render.h>
#include <lib/object.h>
struct Config;
struct Object* CreateTorus(struct Render* r, struct Config* cfg);
|
resetius/graphtoys
|
models/particles_data.c
|
<reponame>resetius/graphtoys
#include <stdlib.h>
#include <math.h>
#include <string.h>
#include <time.h>
#include <lib/config.h>
#include "particles_data.h"
struct body
{
double x[3];
double v[3];
double mass;
int fixed;
char name[100];
};
void particles_data_init(struct ParticlesData* data, struct Config* cfg) {
int n_x = cfg_geti_def(cfg, "nx", 23);
int n_y = cfg_geti_def(cfg, "ny", 23);
int n_z = cfg_geti_def(cfg, "nz", 23);
int n_particles = n_x*n_y*n_z;
int size = n_particles*4*sizeof(float);
float* coords = malloc(size);
int* indices = malloc(n_particles*sizeof(int));
float* vels = calloc(1, size);
float* accel = calloc(1, size);
int i,j,k,n=0;
//float side = 4.0f;
float side = cfg_getf_def(cfg, "side", 7.5f);
float dx = side/(n_x-1);
float dy = side/(n_y-1);
float dz = side/(n_z-1);
srand(time(NULL));
const double G = 2.92e-6;
const char* name = cfg_gets_def(cfg, "name", "solar");
if (!strcmp(name, "sunearth")) {
struct body body[] = {
{{0, 0, 0}, {0, 0, 0}, 10000, 1, "Sun"},
{{0, 1, 0}, {-1, 0, 0}, 1, 0, "Earth"},
};
const int nbodies = 2;
for (i = 0; i < nbodies; i++) {
coords[n] = body[i].x[0];
coords[n+1] = body[i].x[1];
coords[n+2] = body[i].x[2];
coords[n+3] = G * body[i].mass;
vels[n] = body[i].v[0];
vels[n+1] = body[i].v[1];
vels[n+2] = body[i].v[2];
vels[n+3] = 0;
n += 4;
}
} else if (!strcmp(name, "solar")) {
struct body body[] = {
{{0, 0, 0}, {0, 0, 0}, 333333, 1, "Sun"},
{{0, 0.39, 0}, {1.58, 0, 0}, 0.038, 0, "Mercury"},
{{0, 0.72, 0}, {1.17, 0, 0}, 0.82, 0, "Venus"},
{{0, 1, 0}, {1, 0, 0}, 1, 0, "Earth"},
{{0, 1.00256, 0}, {1.03, 0, 0}, 0.012, 0, "Moon"},
{{0, 1.51, 0}, {0.8, 0, 0}, 0.1, 0, "Mars"},
{{0, 5.2, 0}, {0.43, 0, 0}, 317, 0, "Jupiter"},
{{0, 9.3, 0}, {0.32, 0, 0}, 95, 0, "Saturn"},
{{0, 19.3, 0}, {0.23, 0, 0}, 14.5, 0, "Uranus"},
{{0, 30, 0}, {0.18, 0, 0}, 16.7, 0, "Neptune"}};
const int nbodies = 10;
for (i = 0; i < nbodies; i++) {
coords[n] = body[i].x[0];
coords[n+1] = body[i].x[1];
coords[n+2] = body[i].x[2];
coords[n+3] = G * body[i].mass;
vels[n] = body[i].v[0];
vels[n+1] = body[i].v[1];
vels[n+2] = body[i].v[2];
vels[n+3] = 0;
n += 4;
}
} else if (!strcmp(name, "cube")) {
for (i = 0; i < n_x; i++) {
for (j = 0; j < n_y; j++) {
for (k = 0; k < n_z; k++) {
coords[n] = dx * i - side/2 + (0.5 * (double)rand() / (double)RAND_MAX - 0.25);
coords[n+1] = dy * j - side/2 + (0.5 * (double)rand() / (double)RAND_MAX - 0.25);
coords[n+2] = dz * k - side/2 + (0.5 * (double)rand() / (double)RAND_MAX - 0.25);
coords[n+3] = 0.2 + 1.5*(double)rand() / (double)RAND_MAX;
double R =
coords[n]*coords[n]+
coords[n+1]*coords[n+1]+
coords[n+2]*coords[n+2];
R = sqrt(R);
double V = sqrt(1000)/sqrt(R); // sqrt(100/R);
vels[n] = V*coords[n+1];
vels[n+1] = -V*coords[n];
vels[n+2] = 0;
//vels[n] = rand() / (double) RAND_MAX;
//vels[n+1] = rand() / (double) RAND_MAX;
//vels[n+2] = rand() / (double) RAND_MAX;
vels[n+3] = 0;
n += 4;
}
}
}
} else { // sphere
while (n < 4*n_x*n_y*n_z) {
double x = 2*side*(double)rand() / RAND_MAX - side;
double y = 2*side*(double)rand() / RAND_MAX - side;
double z = 2*side*(double)rand() / RAND_MAX - side;
if (x*x+y*y+z*z<side*side) {
coords[n] = x;
coords[n+1] = y;
coords[n+2] = z;
coords[n+3] = 0.2 + 1.5*(double)rand() / (double)RAND_MAX;
double R =
coords[n]*coords[n]+
coords[n+1]*coords[n+1]+
coords[n+2]*coords[n+2];
R = sqrt(R);
double V = sqrt(200)/sqrt(R); // sqrt(100/R);
vels[n] = V*coords[n+1];
vels[n+1] = -V*coords[n];
vels[n+2] = 0;
vels[n+3] = 0;
n += 4;
}
}
}
data->n_particles = n/4;
for (i = 0; i < data->n_particles; i++) {
indices[i] = i;
}
data->vels = vels;
data->coords = coords;
data->accel = accel;
data->indices = indices;
}
void particles_data_destroy(struct ParticlesData* data) {
free(data->coords);
free(data->vels);
free(data->accel);
}
|
resetius/graphtoys
|
vulkan/renderpass.c
|
#include <stdio.h>
#include <stdlib.h>
#include "renderpass.h"
void rp_init(struct RenderPass* r, VkDevice logDev, VkFormat swapChainImageFormat, VkFormat depthFormat) {
VkAttachmentDescription colorAttachment = {
.format = swapChainImageFormat,
.samples = VK_SAMPLE_COUNT_1_BIT,
.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR,
.storeOp = VK_ATTACHMENT_STORE_OP_STORE,
.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE,
.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE,
.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED,
.finalLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR
};
VkAttachmentDescription depthAttachment = {
.format = depthFormat,
.samples = VK_SAMPLE_COUNT_1_BIT,
.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR,
.storeOp = VK_ATTACHMENT_STORE_OP_DONT_CARE,
.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE,
.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE,
.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED,
.finalLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL
};
VkAttachmentReference colorAttachRef = {
.attachment = 0,
.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL
};
VkAttachmentReference depthAttachmentRef = {
.attachment = 1,
.layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL
};
VkSubpassDescription subpass = {
.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS,
.colorAttachmentCount = 1,
.pColorAttachments = &colorAttachRef,
.pDepthStencilAttachment = &depthAttachmentRef
};
VkAttachmentDescription attachments[] = { colorAttachment, depthAttachment };
uint32_t n_attachments = 2;
VkRenderPassCreateInfo rpCreateInfo = {
.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO,
.attachmentCount = n_attachments,
.pAttachments = attachments,
.subpassCount = 1,
.pSubpasses = &subpass
};
if (vkCreateRenderPass(logDev, &rpCreateInfo, NULL, &r->rp) != VK_SUCCESS)
{
fprintf(stderr, "Failed to create renderpass\n");
exit(-1);
}
r->dev = logDev;
}
void rp_begin(
struct RenderPass* r, VkClearValue* values, int n_values, VkCommandBuffer commands,
VkFramebuffer framebuffer, VkExtent2D extent)
{
VkRenderPassBeginInfo rpBeginInfo = {
.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,
.renderPass = r->rp,
.framebuffer = framebuffer,
.renderArea.offset = { 0,0 },
.renderArea.extent = extent,
.pClearValues = values,
.clearValueCount = n_values
};
vkCmdBeginRenderPass(commands, &rpBeginInfo, VK_SUBPASS_CONTENTS_INLINE);
}
void rp_end(struct RenderPass* r, VkCommandBuffer commands) {
vkCmdEndRenderPass(commands);
}
void rp_destroy(struct RenderPass* r) {
vkDestroyRenderPass(r->dev, r->rp, NULL);
}
|
resetius/graphtoys
|
lib/formats/stl.c
|
<reponame>resetius/graphtoys<gh_stars>0
#include <stdio.h>
#include <stdlib.h>
#include <lib/verify.h>
#include "stl.h"
struct StlVertex* stl_load(const char* fname, int* nvertices) {
FILE* f = fopen(fname, "rb");
char header[100];
int n_triangles;
int i,j,k;
struct StlVertex* res;
float min_x, max_x;
float min_y, max_y;
float min_z, max_z;
if (!f) {
*nvertices = 0;
return NULL;
}
min_x = min_y = min_z = 1e10;
max_x = max_y = max_z = -1e10;
verify(fread(header, 1, 80, f) == 80);
header[80] = 0;
printf("header: '%s'\n", header);
verify(fread(&n_triangles, 4, 1, f) == 1);
*nvertices = n_triangles*3;
printf("ntriangles: %d\n", n_triangles);
res = calloc(*nvertices, sizeof(struct StlVertex));
k = 0;
for (i = 0; i < n_triangles; i++) {
float nx, ny, nz;
int attrs = 0;
verify(fread(&nx, 4, 1, f) == 1);
verify(fread(&ny, 4, 1, f) == 1);
verify(fread(&nz, 4, 1, f) == 1);
for (j = 0; j < 3; j++) {
float x, y, z;
verify(fread(&x, 4, 1, f) == 1);
verify(fread(&y, 4, 1, f) == 1);
verify(fread(&z, 4, 1, f) == 1);
struct StlVertex v = {
{1.0, 1.0, 0.0},
{nx, ny, nz},
{x, y, z},
};
res[k++] = v;
min_x = fmin(min_x, x);
min_y = fmin(min_y, y);
min_z = fmin(min_z, z);
max_x = fmax(max_x, x);
max_y = fmax(max_y, y);
max_z = fmax(max_z, z);
}
verify(fread(&attrs, 2, 1, f) == 1);
//int r = attrs & 0x1f;
//int g = (attrs>>5) & 0x1f;
//int b = (attrs>>10) & 0x1f;
//float scale = 1./((1<<5)-1);
//vec3 col = {(float)r*scale, (float)g*scale, (float)b*scale};
//printf("%f %f %f\n", col[0], col[1], col[2]);
//memcpy(res[k-1].col, col, sizeof(col));
attrs = 0;
fseek(f, attrs, SEEK_CUR);
}
float scale = 8./(fmax(max_x,fmax(max_y,max_z))-fmin(min_x,fmin(min_y,min_z)));
for (i = 0; i < k; i++) {
res[i].pos[0] -= 0.5*(max_x+min_x);
res[i].pos[1] -= 0.5*(max_y+min_y);
res[i].pos[2] -= 0.5*(max_z+min_z);
vec3_scale(res[i].pos, res[i].pos, scale);
}
fclose(f);
*nvertices = k;
return res;
}
|
resetius/graphtoys
|
lib/event.h
|
<gh_stars>0
#pragma once
struct InputEvent {
int key;
int scancode;
int action;
int mods;
double x;
double y;
double dx;
double dy;
unsigned char* mask;
};
struct EventConsumer {
void (*key_event)(struct EventConsumer*, struct InputEvent* ev);
void (*mouse_move_event)(struct EventConsumer*, struct InputEvent* ev);
};
struct EventProducer {
void (*subscribe)(struct EventProducer*, struct EventConsumer*);
};
|
resetius/graphtoys
|
vulkan/swapchain.h
|
<gh_stars>0
#pragma once
#include "vk.h"
struct RenderImpl;
struct SwapChain {
struct RenderImpl* r;
VkSwapchainKHR swapchain;
VkFormat im_format;
VkExtent2D extent;
VkImage* images;
int n_images;
VkImage depth_image;
VkDeviceMemory depth_image_memory;
VkFormat depth_format;
};
void sc_init(struct SwapChain* sc, struct RenderImpl* r);
void sc_destroy(struct SwapChain* sc);
|
resetius/graphtoys
|
glad/gl.h
|
/**
* Loader generated by glad 2.0.0-beta on Sun Dec 26 19:47:01 2021
*
* Generator: C/C++
* Specification: gl
* Extensions: 3
*
* APIs:
* - gl:compatibility=4.6
*
* Options:
* - ALIAS = False
* - DEBUG = False
* - HEADER_ONLY = True
* - LOADER = False
* - MX = False
* - MX_GLOBAL = False
* - ON_DEMAND = False
*
* Commandline:
* --api='gl:compatibility=4.6' --extensions='GL_ARB_multisample,GL_ARB_robustness,GL_KHR_debug' c --header-only
*
* Online:
* http://glad.sh/#api=gl%3Acompatibility%3D4.6&extensions=GL_ARB_multisample%2CGL_ARB_robustness%2CGL_KHR_debug&generator=c&options=HEADER_ONLY
*
*/
#ifndef GLAD_GL_H_
#define GLAD_GL_H_
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wreserved-id-macro"
#endif
#ifdef __gl_h_
#error OpenGL (gl.h) header already included (API: gl), remove previous include!
#endif
#define __gl_h_ 1
#ifdef __gl3_h_
#error OpenGL (gl3.h) header already included (API: gl), remove previous include!
#endif
#define __gl3_h_ 1
#ifdef __glext_h_
#error OpenGL (glext.h) header already included (API: gl), remove previous include!
#endif
#define __glext_h_ 1
#ifdef __gl3ext_h_
#error OpenGL (gl3ext.h) header already included (API: gl), remove previous include!
#endif
#define __gl3ext_h_ 1
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#define GLAD_GL
#define GLAD_OPTION_GL_HEADER_ONLY
#ifdef __cplusplus
extern "C" {
#endif
#ifndef GLAD_PLATFORM_H_
#define GLAD_PLATFORM_H_
#ifndef GLAD_PLATFORM_WIN32
#if defined(_WIN32) || defined(__WIN32__) || defined(WIN32) || defined(__MINGW32__)
#define GLAD_PLATFORM_WIN32 1
#else
#define GLAD_PLATFORM_WIN32 0
#endif
#endif
#ifndef GLAD_PLATFORM_APPLE
#ifdef __APPLE__
#define GLAD_PLATFORM_APPLE 1
#else
#define GLAD_PLATFORM_APPLE 0
#endif
#endif
#ifndef GLAD_PLATFORM_EMSCRIPTEN
#ifdef __EMSCRIPTEN__
#define GLAD_PLATFORM_EMSCRIPTEN 1
#else
#define GLAD_PLATFORM_EMSCRIPTEN 0
#endif
#endif
#ifndef GLAD_PLATFORM_UWP
#if defined(_MSC_VER) && !defined(GLAD_INTERNAL_HAVE_WINAPIFAMILY)
#ifdef __has_include
#if __has_include(<winapifamily.h>)
#define GLAD_INTERNAL_HAVE_WINAPIFAMILY 1
#endif
#elif _MSC_VER >= 1700 && !_USING_V110_SDK71_
#define GLAD_INTERNAL_HAVE_WINAPIFAMILY 1
#endif
#endif
#ifdef GLAD_INTERNAL_HAVE_WINAPIFAMILY
#include <winapifamily.h>
#if !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) && WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP)
#define GLAD_PLATFORM_UWP 1
#endif
#endif
#ifndef GLAD_PLATFORM_UWP
#define GLAD_PLATFORM_UWP 0
#endif
#endif
#ifdef __GNUC__
#define GLAD_GNUC_EXTENSION __extension__
#else
#define GLAD_GNUC_EXTENSION
#endif
#ifndef GLAD_API_CALL
#if defined(GLAD_API_CALL_EXPORT)
#if GLAD_PLATFORM_WIN32 || defined(__CYGWIN__)
#if defined(GLAD_API_CALL_EXPORT_BUILD)
#if defined(__GNUC__)
#define GLAD_API_CALL __attribute__ ((dllexport)) extern
#else
#define GLAD_API_CALL __declspec(dllexport) extern
#endif
#else
#if defined(__GNUC__)
#define GLAD_API_CALL __attribute__ ((dllimport)) extern
#else
#define GLAD_API_CALL __declspec(dllimport) extern
#endif
#endif
#elif defined(__GNUC__) && defined(GLAD_API_CALL_EXPORT_BUILD)
#define GLAD_API_CALL __attribute__ ((visibility ("default"))) extern
#else
#define GLAD_API_CALL extern
#endif
#else
#define GLAD_API_CALL extern
#endif
#endif
#ifdef APIENTRY
#define GLAD_API_PTR APIENTRY
#elif GLAD_PLATFORM_WIN32
#define GLAD_API_PTR __stdcall
#else
#define GLAD_API_PTR
#endif
#ifndef GLAPI
#define GLAPI GLAD_API_CALL
#endif
#ifndef GLAPIENTRY
#define GLAPIENTRY GLAD_API_PTR
#endif
#define GLAD_MAKE_VERSION(major, minor) (major * 10000 + minor)
#define GLAD_VERSION_MAJOR(version) (version / 10000)
#define GLAD_VERSION_MINOR(version) (version % 10000)
#define GLAD_GENERATOR_VERSION "2.0.0-beta"
typedef void (*GLADapiproc)(void);
typedef GLADapiproc (*GLADloadfunc)(const char *name);
typedef GLADapiproc (*GLADuserptrloadfunc)(void *userptr, const char *name);
typedef void (*GLADprecallback)(const char *name, GLADapiproc apiproc, int len_args, ...);
typedef void (*GLADpostcallback)(void *ret, const char *name, GLADapiproc apiproc, int len_args, ...);
#endif /* GLAD_PLATFORM_H_ */
#define GL_2D 0x0600
#define GL_2_BYTES 0x1407
#define GL_3D 0x0601
#define GL_3D_COLOR 0x0602
#define GL_3D_COLOR_TEXTURE 0x0603
#define GL_3_BYTES 0x1408
#define GL_4D_COLOR_TEXTURE 0x0604
#define GL_4_BYTES 0x1409
#define GL_ACCUM 0x0100
#define GL_ACCUM_ALPHA_BITS 0x0D5B
#define GL_ACCUM_BLUE_BITS 0x0D5A
#define GL_ACCUM_BUFFER_BIT 0x00000200
#define GL_ACCUM_CLEAR_VALUE 0x0B80
#define GL_ACCUM_GREEN_BITS 0x0D59
#define GL_ACCUM_RED_BITS 0x0D58
#define GL_ACTIVE_ATOMIC_COUNTER_BUFFERS 0x92D9
#define GL_ACTIVE_ATTRIBUTES 0x8B89
#define GL_ACTIVE_ATTRIBUTE_MAX_LENGTH 0x8B8A
#define GL_ACTIVE_PROGRAM 0x8259
#define GL_ACTIVE_RESOURCES 0x92F5
#define GL_ACTIVE_SUBROUTINES 0x8DE5
#define GL_ACTIVE_SUBROUTINE_MAX_LENGTH 0x8E48
#define GL_ACTIVE_SUBROUTINE_UNIFORMS 0x8DE6
#define GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS 0x8E47
#define GL_ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH 0x8E49
#define GL_ACTIVE_TEXTURE 0x84E0
#define GL_ACTIVE_UNIFORMS 0x8B86
#define GL_ACTIVE_UNIFORM_BLOCKS 0x8A36
#define GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH 0x8A35
#define GL_ACTIVE_UNIFORM_MAX_LENGTH 0x8B87
#define GL_ACTIVE_VARIABLES 0x9305
#define GL_ADD 0x0104
#define GL_ADD_SIGNED 0x8574
#define GL_ALIASED_LINE_WIDTH_RANGE 0x846E
#define GL_ALIASED_POINT_SIZE_RANGE 0x846D
#define GL_ALL_ATTRIB_BITS 0xFFFFFFFF
#define GL_ALL_BARRIER_BITS 0xFFFFFFFF
#define GL_ALL_SHADER_BITS 0xFFFFFFFF
#define GL_ALPHA 0x1906
#define GL_ALPHA12 0x803D
#define GL_ALPHA16 0x803E
#define GL_ALPHA4 0x803B
#define GL_ALPHA8 0x803C
#define GL_ALPHA_BIAS 0x0D1D
#define GL_ALPHA_BITS 0x0D55
#define GL_ALPHA_INTEGER 0x8D97
#define GL_ALPHA_SCALE 0x0D1C
#define GL_ALPHA_TEST 0x0BC0
#define GL_ALPHA_TEST_FUNC 0x0BC1
#define GL_ALPHA_TEST_REF 0x0BC2
#define GL_ALREADY_SIGNALED 0x911A
#define GL_ALWAYS 0x0207
#define GL_AMBIENT 0x1200
#define GL_AMBIENT_AND_DIFFUSE 0x1602
#define GL_AND 0x1501
#define GL_AND_INVERTED 0x1504
#define GL_AND_REVERSE 0x1502
#define GL_ANY_SAMPLES_PASSED 0x8C2F
#define GL_ANY_SAMPLES_PASSED_CONSERVATIVE 0x8D6A
#define GL_ARRAY_BUFFER 0x8892
#define GL_ARRAY_BUFFER_BINDING 0x8894
#define GL_ARRAY_SIZE 0x92FB
#define GL_ARRAY_STRIDE 0x92FE
#define GL_ATOMIC_COUNTER_BARRIER_BIT 0x00001000
#define GL_ATOMIC_COUNTER_BUFFER 0x92C0
#define GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS 0x92C5
#define GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTER_INDICES 0x92C6
#define GL_ATOMIC_COUNTER_BUFFER_BINDING 0x92C1
#define GL_ATOMIC_COUNTER_BUFFER_DATA_SIZE 0x92C4
#define GL_ATOMIC_COUNTER_BUFFER_INDEX 0x9301
#define GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_COMPUTE_SHADER 0x90ED
#define GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_FRAGMENT_SHADER 0x92CB
#define GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_GEOMETRY_SHADER 0x92CA
#define GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_CONTROL_SHADER 0x92C8
#define GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_EVALUATION_SHADER 0x92C9
#define GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_VERTEX_SHADER 0x92C7
#define GL_ATOMIC_COUNTER_BUFFER_SIZE 0x92C3
#define GL_ATOMIC_COUNTER_BUFFER_START 0x92C2
#define GL_ATTACHED_SHADERS 0x8B85
#define GL_ATTRIB_STACK_DEPTH 0x0BB0
#define GL_AUTO_GENERATE_MIPMAP 0x8295
#define GL_AUTO_NORMAL 0x0D80
#define GL_AUX0 0x0409
#define GL_AUX1 0x040A
#define GL_AUX2 0x040B
#define GL_AUX3 0x040C
#define GL_AUX_BUFFERS 0x0C00
#define GL_BACK 0x0405
#define GL_BACK_LEFT 0x0402
#define GL_BACK_RIGHT 0x0403
#define GL_BGR 0x80E0
#define GL_BGRA 0x80E1
#define GL_BGRA_INTEGER 0x8D9B
#define GL_BGR_INTEGER 0x8D9A
#define GL_BITMAP 0x1A00
#define GL_BITMAP_TOKEN 0x0704
#define GL_BLEND 0x0BE2
#define GL_BLEND_COLOR 0x8005
#define GL_BLEND_DST 0x0BE0
#define GL_BLEND_DST_ALPHA 0x80CA
#define GL_BLEND_DST_RGB 0x80C8
#define GL_BLEND_EQUATION 0x8009
#define GL_BLEND_EQUATION_ALPHA 0x883D
#define GL_BLEND_EQUATION_RGB 0x8009
#define GL_BLEND_SRC 0x0BE1
#define GL_BLEND_SRC_ALPHA 0x80CB
#define GL_BLEND_SRC_RGB 0x80C9
#define GL_BLOCK_INDEX 0x92FD
#define GL_BLUE 0x1905
#define GL_BLUE_BIAS 0x0D1B
#define GL_BLUE_BITS 0x0D54
#define GL_BLUE_INTEGER 0x8D96
#define GL_BLUE_SCALE 0x0D1A
#define GL_BOOL 0x8B56
#define GL_BOOL_VEC2 0x8B57
#define GL_BOOL_VEC3 0x8B58
#define GL_BOOL_VEC4 0x8B59
#define GL_BUFFER 0x82E0
#define GL_BUFFER_ACCESS 0x88BB
#define GL_BUFFER_ACCESS_FLAGS 0x911F
#define GL_BUFFER_BINDING 0x9302
#define GL_BUFFER_DATA_SIZE 0x9303
#define GL_BUFFER_IMMUTABLE_STORAGE 0x821F
#define GL_BUFFER_MAPPED 0x88BC
#define GL_BUFFER_MAP_LENGTH 0x9120
#define GL_BUFFER_MAP_OFFSET 0x9121
#define GL_BUFFER_MAP_POINTER 0x88BD
#define GL_BUFFER_SIZE 0x8764
#define GL_BUFFER_STORAGE_FLAGS 0x8220
#define GL_BUFFER_UPDATE_BARRIER_BIT 0x00000200
#define GL_BUFFER_USAGE 0x8765
#define GL_BUFFER_VARIABLE 0x92E5
#define GL_BYTE 0x1400
#define GL_C3F_V3F 0x2A24
#define GL_C4F_N3F_V3F 0x2A26
#define GL_C4UB_V2F 0x2A22
#define GL_C4UB_V3F 0x2A23
#define GL_CAVEAT_SUPPORT 0x82B8
#define GL_CCW 0x0901
#define GL_CLAMP 0x2900
#define GL_CLAMP_FRAGMENT_COLOR 0x891B
#define GL_CLAMP_READ_COLOR 0x891C
#define GL_CLAMP_TO_BORDER 0x812D
#define GL_CLAMP_TO_EDGE 0x812F
#define GL_CLAMP_VERTEX_COLOR 0x891A
#define GL_CLEAR 0x1500
#define GL_CLEAR_BUFFER 0x82B4
#define GL_CLEAR_TEXTURE 0x9365
#define GL_CLIENT_ACTIVE_TEXTURE 0x84E1
#define GL_CLIENT_ALL_ATTRIB_BITS 0xFFFFFFFF
#define GL_CLIENT_ATTRIB_STACK_DEPTH 0x0BB1
#define GL_CLIENT_MAPPED_BUFFER_BARRIER_BIT 0x00004000
#define GL_CLIENT_PIXEL_STORE_BIT 0x00000001
#define GL_CLIENT_STORAGE_BIT 0x0200
#define GL_CLIENT_VERTEX_ARRAY_BIT 0x00000002
#define GL_CLIPPING_INPUT_PRIMITIVES 0x82F6
#define GL_CLIPPING_OUTPUT_PRIMITIVES 0x82F7
#define GL_CLIP_DEPTH_MODE 0x935D
#define GL_CLIP_DISTANCE0 0x3000
#define GL_CLIP_DISTANCE1 0x3001
#define GL_CLIP_DISTANCE2 0x3002
#define GL_CLIP_DISTANCE3 0x3003
#define GL_CLIP_DISTANCE4 0x3004
#define GL_CLIP_DISTANCE5 0x3005
#define GL_CLIP_DISTANCE6 0x3006
#define GL_CLIP_DISTANCE7 0x3007
#define GL_CLIP_ORIGIN 0x935C
#define GL_CLIP_PLANE0 0x3000
#define GL_CLIP_PLANE1 0x3001
#define GL_CLIP_PLANE2 0x3002
#define GL_CLIP_PLANE3 0x3003
#define GL_CLIP_PLANE4 0x3004
#define GL_CLIP_PLANE5 0x3005
#define GL_COEFF 0x0A00
#define GL_COLOR 0x1800
#define GL_COLOR_ARRAY 0x8076
#define GL_COLOR_ARRAY_BUFFER_BINDING 0x8898
#define GL_COLOR_ARRAY_POINTER 0x8090
#define GL_COLOR_ARRAY_SIZE 0x8081
#define GL_COLOR_ARRAY_STRIDE 0x8083
#define GL_COLOR_ARRAY_TYPE 0x8082
#define GL_COLOR_ATTACHMENT0 0x8CE0
#define GL_COLOR_ATTACHMENT1 0x8CE1
#define GL_COLOR_ATTACHMENT10 0x8CEA
#define GL_COLOR_ATTACHMENT11 0x8CEB
#define GL_COLOR_ATTACHMENT12 0x8CEC
#define GL_COLOR_ATTACHMENT13 0x8CED
#define GL_COLOR_ATTACHMENT14 0x8CEE
#define GL_COLOR_ATTACHMENT15 0x8CEF
#define GL_COLOR_ATTACHMENT16 0x8CF0
#define GL_COLOR_ATTACHMENT17 0x8CF1
#define GL_COLOR_ATTACHMENT18 0x8CF2
#define GL_COLOR_ATTACHMENT19 0x8CF3
#define GL_COLOR_ATTACHMENT2 0x8CE2
#define GL_COLOR_ATTACHMENT20 0x8CF4
#define GL_COLOR_ATTACHMENT21 0x8CF5
#define GL_COLOR_ATTACHMENT22 0x8CF6
#define GL_COLOR_ATTACHMENT23 0x8CF7
#define GL_COLOR_ATTACHMENT24 0x8CF8
#define GL_COLOR_ATTACHMENT25 0x8CF9
#define GL_COLOR_ATTACHMENT26 0x8CFA
#define GL_COLOR_ATTACHMENT27 0x8CFB
#define GL_COLOR_ATTACHMENT28 0x8CFC
#define GL_COLOR_ATTACHMENT29 0x8CFD
#define GL_COLOR_ATTACHMENT3 0x8CE3
#define GL_COLOR_ATTACHMENT30 0x8CFE
#define GL_COLOR_ATTACHMENT31 0x8CFF
#define GL_COLOR_ATTACHMENT4 0x8CE4
#define GL_COLOR_ATTACHMENT5 0x8CE5
#define GL_COLOR_ATTACHMENT6 0x8CE6
#define GL_COLOR_ATTACHMENT7 0x8CE7
#define GL_COLOR_ATTACHMENT8 0x8CE8
#define GL_COLOR_ATTACHMENT9 0x8CE9
#define GL_COLOR_BUFFER_BIT 0x00004000
#define GL_COLOR_CLEAR_VALUE 0x0C22
#define GL_COLOR_COMPONENTS 0x8283
#define GL_COLOR_ENCODING 0x8296
#define GL_COLOR_INDEX 0x1900
#define GL_COLOR_INDEXES 0x1603
#define GL_COLOR_LOGIC_OP 0x0BF2
#define GL_COLOR_MATERIAL 0x0B57
#define GL_COLOR_MATERIAL_FACE 0x0B55
#define GL_COLOR_MATERIAL_PARAMETER 0x0B56
#define GL_COLOR_RENDERABLE 0x8286
#define GL_COLOR_SUM 0x8458
#define GL_COLOR_TABLE 0x80D0
#define GL_COLOR_WRITEMASK 0x0C23
#define GL_COMBINE 0x8570
#define GL_COMBINE_ALPHA 0x8572
#define GL_COMBINE_RGB 0x8571
#define GL_COMMAND_BARRIER_BIT 0x00000040
#define GL_COMPARE_REF_TO_TEXTURE 0x884E
#define GL_COMPARE_R_TO_TEXTURE 0x884E
#define GL_COMPATIBLE_SUBROUTINES 0x8E4B
#define GL_COMPILE 0x1300
#define GL_COMPILE_AND_EXECUTE 0x1301
#define GL_COMPILE_STATUS 0x8B81
#define GL_COMPRESSED_ALPHA 0x84E9
#define GL_COMPRESSED_INTENSITY 0x84EC
#define GL_COMPRESSED_LUMINANCE 0x84EA
#define GL_COMPRESSED_LUMINANCE_ALPHA 0x84EB
#define GL_COMPRESSED_R11_EAC 0x9270
#define GL_COMPRESSED_RED 0x8225
#define GL_COMPRESSED_RED_RGTC1 0x8DBB
#define GL_COMPRESSED_RG 0x8226
#define GL_COMPRESSED_RG11_EAC 0x9272
#define GL_COMPRESSED_RGB 0x84ED
#define GL_COMPRESSED_RGB8_ETC2 0x9274
#define GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 0x9276
#define GL_COMPRESSED_RGBA 0x84EE
#define GL_COMPRESSED_RGBA8_ETC2_EAC 0x9278
#define GL_COMPRESSED_RGBA_BPTC_UNORM 0x8E8C
#define GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT 0x8E8E
#define GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT 0x8E8F
#define GL_COMPRESSED_RG_RGTC2 0x8DBD
#define GL_COMPRESSED_SIGNED_R11_EAC 0x9271
#define GL_COMPRESSED_SIGNED_RED_RGTC1 0x8DBC
#define GL_COMPRESSED_SIGNED_RG11_EAC 0x9273
#define GL_COMPRESSED_SIGNED_RG_RGTC2 0x8DBE
#define GL_COMPRESSED_SLUMINANCE 0x8C4A
#define GL_COMPRESSED_SLUMINANCE_ALPHA 0x8C4B
#define GL_COMPRESSED_SRGB 0x8C48
#define GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC 0x9279
#define GL_COMPRESSED_SRGB8_ETC2 0x9275
#define GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 0x9277
#define GL_COMPRESSED_SRGB_ALPHA 0x8C49
#define GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM 0x8E8D
#define GL_COMPRESSED_TEXTURE_FORMATS 0x86A3
#define GL_COMPUTE_SHADER 0x91B9
#define GL_COMPUTE_SHADER_BIT 0x00000020
#define GL_COMPUTE_SHADER_INVOCATIONS 0x82F5
#define GL_COMPUTE_SUBROUTINE 0x92ED
#define GL_COMPUTE_SUBROUTINE_UNIFORM 0x92F3
#define GL_COMPUTE_TEXTURE 0x82A0
#define GL_COMPUTE_WORK_GROUP_SIZE 0x8267
#define GL_CONDITION_SATISFIED 0x911C
#define GL_CONSTANT 0x8576
#define GL_CONSTANT_ALPHA 0x8003
#define GL_CONSTANT_ATTENUATION 0x1207
#define GL_CONSTANT_COLOR 0x8001
#define GL_CONTEXT_COMPATIBILITY_PROFILE_BIT 0x00000002
#define GL_CONTEXT_CORE_PROFILE_BIT 0x00000001
#define GL_CONTEXT_FLAGS 0x821E
#define GL_CONTEXT_FLAG_DEBUG_BIT 0x00000002
#define GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT 0x00000001
#define GL_CONTEXT_FLAG_NO_ERROR_BIT 0x00000008
#define GL_CONTEXT_FLAG_ROBUST_ACCESS_BIT 0x00000004
#define GL_CONTEXT_FLAG_ROBUST_ACCESS_BIT_ARB 0x00000004
#define GL_CONTEXT_LOST 0x0507
#define GL_CONTEXT_PROFILE_MASK 0x9126
#define GL_CONTEXT_RELEASE_BEHAVIOR 0x82FB
#define GL_CONTEXT_RELEASE_BEHAVIOR_FLUSH 0x82FC
#define GL_CONVOLUTION_1D 0x8010
#define GL_CONVOLUTION_2D 0x8011
#define GL_COORD_REPLACE 0x8862
#define GL_COPY 0x1503
#define GL_COPY_INVERTED 0x150C
#define GL_COPY_PIXEL_TOKEN 0x0706
#define GL_COPY_READ_BUFFER 0x8F36
#define GL_COPY_READ_BUFFER_BINDING 0x8F36
#define GL_COPY_WRITE_BUFFER 0x8F37
#define GL_COPY_WRITE_BUFFER_BINDING 0x8F37
#define GL_CULL_FACE 0x0B44
#define GL_CULL_FACE_MODE 0x0B45
#define GL_CURRENT_BIT 0x00000001
#define GL_CURRENT_COLOR 0x0B00
#define GL_CURRENT_FOG_COORD 0x8453
#define GL_CURRENT_FOG_COORDINATE 0x8453
#define GL_CURRENT_INDEX 0x0B01
#define GL_CURRENT_NORMAL 0x0B02
#define GL_CURRENT_PROGRAM 0x8B8D
#define GL_CURRENT_QUERY 0x8865
#define GL_CURRENT_RASTER_COLOR 0x0B04
#define GL_CURRENT_RASTER_DISTANCE 0x0B09
#define GL_CURRENT_RASTER_INDEX 0x0B05
#define GL_CURRENT_RASTER_POSITION 0x0B07
#define GL_CURRENT_RASTER_POSITION_VALID 0x0B08
#define GL_CURRENT_RASTER_SECONDARY_COLOR 0x845F
#define GL_CURRENT_RASTER_TEXTURE_COORDS 0x0B06
#define GL_CURRENT_SECONDARY_COLOR 0x8459
#define GL_CURRENT_TEXTURE_COORDS 0x0B03
#define GL_CURRENT_VERTEX_ATTRIB 0x8626
#define GL_CW 0x0900
#define GL_DEBUG_CALLBACK_FUNCTION 0x8244
#define GL_DEBUG_CALLBACK_USER_PARAM 0x8245
#define GL_DEBUG_GROUP_STACK_DEPTH 0x826D
#define GL_DEBUG_LOGGED_MESSAGES 0x9145
#define GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH 0x8243
#define GL_DEBUG_OUTPUT 0x92E0
#define GL_DEBUG_OUTPUT_SYNCHRONOUS 0x8242
#define GL_DEBUG_SEVERITY_HIGH 0x9146
#define GL_DEBUG_SEVERITY_LOW 0x9148
#define GL_DEBUG_SEVERITY_MEDIUM 0x9147
#define GL_DEBUG_SEVERITY_NOTIFICATION 0x826B
#define GL_DEBUG_SOURCE_API 0x8246
#define GL_DEBUG_SOURCE_APPLICATION 0x824A
#define GL_DEBUG_SOURCE_OTHER 0x824B
#define GL_DEBUG_SOURCE_SHADER_COMPILER 0x8248
#define GL_DEBUG_SOURCE_THIRD_PARTY 0x8249
#define GL_DEBUG_SOURCE_WINDOW_SYSTEM 0x8247
#define GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR 0x824D
#define GL_DEBUG_TYPE_ERROR 0x824C
#define GL_DEBUG_TYPE_MARKER 0x8268
#define GL_DEBUG_TYPE_OTHER 0x8251
#define GL_DEBUG_TYPE_PERFORMANCE 0x8250
#define GL_DEBUG_TYPE_POP_GROUP 0x826A
#define GL_DEBUG_TYPE_PORTABILITY 0x824F
#define GL_DEBUG_TYPE_PUSH_GROUP 0x8269
#define GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR 0x824E
#define GL_DECAL 0x2101
#define GL_DECR 0x1E03
#define GL_DECR_WRAP 0x8508
#define GL_DELETE_STATUS 0x8B80
#define GL_DEPTH 0x1801
#define GL_DEPTH24_STENCIL8 0x88F0
#define GL_DEPTH32F_STENCIL8 0x8CAD
#define GL_DEPTH_ATTACHMENT 0x8D00
#define GL_DEPTH_BIAS 0x0D1F
#define GL_DEPTH_BITS 0x0D56
#define GL_DEPTH_BUFFER_BIT 0x00000100
#define GL_DEPTH_CLAMP 0x864F
#define GL_DEPTH_CLEAR_VALUE 0x0B73
#define GL_DEPTH_COMPONENT 0x1902
#define GL_DEPTH_COMPONENT16 0x81A5
#define GL_DEPTH_COMPONENT24 0x81A6
#define GL_DEPTH_COMPONENT32 0x81A7
#define GL_DEPTH_COMPONENT32F 0x8CAC
#define GL_DEPTH_COMPONENTS 0x8284
#define GL_DEPTH_FUNC 0x0B74
#define GL_DEPTH_RANGE 0x0B70
#define GL_DEPTH_RENDERABLE 0x8287
#define GL_DEPTH_SCALE 0x0D1E
#define GL_DEPTH_STENCIL 0x84F9
#define GL_DEPTH_STENCIL_ATTACHMENT 0x821A
#define GL_DEPTH_STENCIL_TEXTURE_MODE 0x90EA
#define GL_DEPTH_TEST 0x0B71
#define GL_DEPTH_TEXTURE_MODE 0x884B
#define GL_DEPTH_WRITEMASK 0x0B72
#define GL_DIFFUSE 0x1201
#define GL_DISPATCH_INDIRECT_BUFFER 0x90EE
#define GL_DISPATCH_INDIRECT_BUFFER_BINDING 0x90EF
#define GL_DISPLAY_LIST 0x82E7
#define GL_DITHER 0x0BD0
#define GL_DOMAIN 0x0A02
#define GL_DONT_CARE 0x1100
#define GL_DOT3_RGB 0x86AE
#define GL_DOT3_RGBA 0x86AF
#define GL_DOUBLE 0x140A
#define GL_DOUBLEBUFFER 0x0C32
#define GL_DOUBLE_MAT2 0x8F46
#define GL_DOUBLE_MAT2x3 0x8F49
#define GL_DOUBLE_MAT2x4 0x8F4A
#define GL_DOUBLE_MAT3 0x8F47
#define GL_DOUBLE_MAT3x2 0x8F4B
#define GL_DOUBLE_MAT3x4 0x8F4C
#define GL_DOUBLE_MAT4 0x8F48
#define GL_DOUBLE_MAT4x2 0x8F4D
#define GL_DOUBLE_MAT4x3 0x8F4E
#define GL_DOUBLE_VEC2 0x8FFC
#define GL_DOUBLE_VEC3 0x8FFD
#define GL_DOUBLE_VEC4 0x8FFE
#define GL_DRAW_BUFFER 0x0C01
#define GL_DRAW_BUFFER0 0x8825
#define GL_DRAW_BUFFER1 0x8826
#define GL_DRAW_BUFFER10 0x882F
#define GL_DRAW_BUFFER11 0x8830
#define GL_DRAW_BUFFER12 0x8831
#define GL_DRAW_BUFFER13 0x8832
#define GL_DRAW_BUFFER14 0x8833
#define GL_DRAW_BUFFER15 0x8834
#define GL_DRAW_BUFFER2 0x8827
#define GL_DRAW_BUFFER3 0x8828
#define GL_DRAW_BUFFER4 0x8829
#define GL_DRAW_BUFFER5 0x882A
#define GL_DRAW_BUFFER6 0x882B
#define GL_DRAW_BUFFER7 0x882C
#define GL_DRAW_BUFFER8 0x882D
#define GL_DRAW_BUFFER9 0x882E
#define GL_DRAW_FRAMEBUFFER 0x8CA9
#define GL_DRAW_FRAMEBUFFER_BINDING 0x8CA6
#define GL_DRAW_INDIRECT_BUFFER 0x8F3F
#define GL_DRAW_INDIRECT_BUFFER_BINDING 0x8F43
#define GL_DRAW_PIXEL_TOKEN 0x0705
#define GL_DST_ALPHA 0x0304
#define GL_DST_COLOR 0x0306
#define GL_DYNAMIC_COPY 0x88EA
#define GL_DYNAMIC_DRAW 0x88E8
#define GL_DYNAMIC_READ 0x88E9
#define GL_DYNAMIC_STORAGE_BIT 0x0100
#define GL_EDGE_FLAG 0x0B43
#define GL_EDGE_FLAG_ARRAY 0x8079
#define GL_EDGE_FLAG_ARRAY_BUFFER_BINDING 0x889B
#define GL_EDGE_FLAG_ARRAY_POINTER 0x8093
#define GL_EDGE_FLAG_ARRAY_STRIDE 0x808C
#define GL_ELEMENT_ARRAY_BARRIER_BIT 0x00000002
#define GL_ELEMENT_ARRAY_BUFFER 0x8893
#define GL_ELEMENT_ARRAY_BUFFER_BINDING 0x8895
#define GL_EMISSION 0x1600
#define GL_ENABLE_BIT 0x00002000
#define GL_EQUAL 0x0202
#define GL_EQUIV 0x1509
#define GL_EVAL_BIT 0x00010000
#define GL_EXP 0x0800
#define GL_EXP2 0x0801
#define GL_EXTENSIONS 0x1F03
#define GL_EYE_LINEAR 0x2400
#define GL_EYE_PLANE 0x2502
#define GL_FALSE 0
#define GL_FASTEST 0x1101
#define GL_FEEDBACK 0x1C01
#define GL_FEEDBACK_BUFFER_POINTER 0x0DF0
#define GL_FEEDBACK_BUFFER_SIZE 0x0DF1
#define GL_FEEDBACK_BUFFER_TYPE 0x0DF2
#define GL_FILL 0x1B02
#define GL_FILTER 0x829A
#define GL_FIRST_VERTEX_CONVENTION 0x8E4D
#define GL_FIXED 0x140C
#define GL_FIXED_ONLY 0x891D
#define GL_FLAT 0x1D00
#define GL_FLOAT 0x1406
#define GL_FLOAT_32_UNSIGNED_INT_24_8_REV 0x8DAD
#define GL_FLOAT_MAT2 0x8B5A
#define GL_FLOAT_MAT2x3 0x8B65
#define GL_FLOAT_MAT2x4 0x8B66
#define GL_FLOAT_MAT3 0x8B5B
#define GL_FLOAT_MAT3x2 0x8B67
#define GL_FLOAT_MAT3x4 0x8B68
#define GL_FLOAT_MAT4 0x8B5C
#define GL_FLOAT_MAT4x2 0x8B69
#define GL_FLOAT_MAT4x3 0x8B6A
#define GL_FLOAT_VEC2 0x8B50
#define GL_FLOAT_VEC3 0x8B51
#define GL_FLOAT_VEC4 0x8B52
#define GL_FOG 0x0B60
#define GL_FOG_BIT 0x00000080
#define GL_FOG_COLOR 0x0B66
#define GL_FOG_COORD 0x8451
#define GL_FOG_COORDINATE 0x8451
#define GL_FOG_COORDINATE_ARRAY 0x8457
#define GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING 0x889D
#define GL_FOG_COORDINATE_ARRAY_POINTER 0x8456
#define GL_FOG_COORDINATE_ARRAY_STRIDE 0x8455
#define GL_FOG_COORDINATE_ARRAY_TYPE 0x8454
#define GL_FOG_COORDINATE_SOURCE 0x8450
#define GL_FOG_COORD_ARRAY 0x8457
#define GL_FOG_COORD_ARRAY_BUFFER_BINDING 0x889D
#define GL_FOG_COORD_ARRAY_POINTER 0x8456
#define GL_FOG_COORD_ARRAY_STRIDE 0x8455
#define GL_FOG_COORD_ARRAY_TYPE 0x8454
#define GL_FOG_COORD_SRC 0x8450
#define GL_FOG_DENSITY 0x0B62
#define GL_FOG_END 0x0B64
#define GL_FOG_HINT 0x0C54
#define GL_FOG_INDEX 0x0B61
#define GL_FOG_MODE 0x0B65
#define GL_FOG_START 0x0B63
#define GL_FRACTIONAL_EVEN 0x8E7C
#define GL_FRACTIONAL_ODD 0x8E7B
#define GL_FRAGMENT_DEPTH 0x8452
#define GL_FRAGMENT_INTERPOLATION_OFFSET_BITS 0x8E5D
#define GL_FRAGMENT_SHADER 0x8B30
#define GL_FRAGMENT_SHADER_BIT 0x00000002
#define GL_FRAGMENT_SHADER_DERIVATIVE_HINT 0x8B8B
#define GL_FRAGMENT_SHADER_INVOCATIONS 0x82F4
#define GL_FRAGMENT_SUBROUTINE 0x92EC
#define GL_FRAGMENT_SUBROUTINE_UNIFORM 0x92F2
#define GL_FRAGMENT_TEXTURE 0x829F
#define GL_FRAMEBUFFER 0x8D40
#define GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE 0x8215
#define GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE 0x8214
#define GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING 0x8210
#define GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE 0x8211
#define GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE 0x8216
#define GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE 0x8213
#define GL_FRAMEBUFFER_ATTACHMENT_LAYERED 0x8DA7
#define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME 0x8CD1
#define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE 0x8CD0
#define GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE 0x8212
#define GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE 0x8217
#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE 0x8CD3
#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER 0x8CD4
#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL 0x8CD2
#define GL_FRAMEBUFFER_BARRIER_BIT 0x00000400
#define GL_FRAMEBUFFER_BINDING 0x8CA6
#define GL_FRAMEBUFFER_BLEND 0x828B
#define GL_FRAMEBUFFER_COMPLETE 0x8CD5
#define GL_FRAMEBUFFER_DEFAULT 0x8218
#define GL_FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS 0x9314
#define GL_FRAMEBUFFER_DEFAULT_HEIGHT 0x9311
#define GL_FRAMEBUFFER_DEFAULT_LAYERS 0x9312
#define GL_FRAMEBUFFER_DEFAULT_SAMPLES 0x9313
#define GL_FRAMEBUFFER_DEFAULT_WIDTH 0x9310
#define GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT 0x8CD6
#define GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER 0x8CDB
#define GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS 0x8DA8
#define GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT 0x8CD7
#define GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE 0x8D56
#define GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER 0x8CDC
#define GL_FRAMEBUFFER_RENDERABLE 0x8289
#define GL_FRAMEBUFFER_RENDERABLE_LAYERED 0x828A
#define GL_FRAMEBUFFER_SRGB 0x8DB9
#define GL_FRAMEBUFFER_UNDEFINED 0x8219
#define GL_FRAMEBUFFER_UNSUPPORTED 0x8CDD
#define GL_FRONT 0x0404
#define GL_FRONT_AND_BACK 0x0408
#define GL_FRONT_FACE 0x0B46
#define GL_FRONT_LEFT 0x0400
#define GL_FRONT_RIGHT 0x0401
#define GL_FULL_SUPPORT 0x82B7
#define GL_FUNC_ADD 0x8006
#define GL_FUNC_REVERSE_SUBTRACT 0x800B
#define GL_FUNC_SUBTRACT 0x800A
#define GL_GENERATE_MIPMAP 0x8191
#define GL_GENERATE_MIPMAP_HINT 0x8192
#define GL_GEOMETRY_INPUT_TYPE 0x8917
#define GL_GEOMETRY_OUTPUT_TYPE 0x8918
#define GL_GEOMETRY_SHADER 0x8DD9
#define GL_GEOMETRY_SHADER_BIT 0x00000004
#define GL_GEOMETRY_SHADER_INVOCATIONS 0x887F
#define GL_GEOMETRY_SHADER_PRIMITIVES_EMITTED 0x82F3
#define GL_GEOMETRY_SUBROUTINE 0x92EB
#define GL_GEOMETRY_SUBROUTINE_UNIFORM 0x92F1
#define GL_GEOMETRY_TEXTURE 0x829E
#define GL_GEOMETRY_VERTICES_OUT 0x8916
#define GL_GEQUAL 0x0206
#define GL_GET_TEXTURE_IMAGE_FORMAT 0x8291
#define GL_GET_TEXTURE_IMAGE_TYPE 0x8292
#define GL_GREATER 0x0204
#define GL_GREEN 0x1904
#define GL_GREEN_BIAS 0x0D19
#define GL_GREEN_BITS 0x0D53
#define GL_GREEN_INTEGER 0x8D95
#define GL_GREEN_SCALE 0x0D18
#define GL_GUILTY_CONTEXT_RESET 0x8253
#define GL_GUILTY_CONTEXT_RESET_ARB 0x8253
#define GL_HALF_FLOAT 0x140B
#define GL_HIGH_FLOAT 0x8DF2
#define GL_HIGH_INT 0x8DF5
#define GL_HINT_BIT 0x00008000
#define GL_HISTOGRAM 0x8024
#define GL_IMAGE_1D 0x904C
#define GL_IMAGE_1D_ARRAY 0x9052
#define GL_IMAGE_2D 0x904D
#define GL_IMAGE_2D_ARRAY 0x9053
#define GL_IMAGE_2D_MULTISAMPLE 0x9055
#define GL_IMAGE_2D_MULTISAMPLE_ARRAY 0x9056
#define GL_IMAGE_2D_RECT 0x904F
#define GL_IMAGE_3D 0x904E
#define GL_IMAGE_BINDING_ACCESS 0x8F3E
#define GL_IMAGE_BINDING_FORMAT 0x906E
#define GL_IMAGE_BINDING_LAYER 0x8F3D
#define GL_IMAGE_BINDING_LAYERED 0x8F3C
#define GL_IMAGE_BINDING_LEVEL 0x8F3B
#define GL_IMAGE_BINDING_NAME 0x8F3A
#define GL_IMAGE_BUFFER 0x9051
#define GL_IMAGE_CLASS_10_10_10_2 0x82C3
#define GL_IMAGE_CLASS_11_11_10 0x82C2
#define GL_IMAGE_CLASS_1_X_16 0x82BE
#define GL_IMAGE_CLASS_1_X_32 0x82BB
#define GL_IMAGE_CLASS_1_X_8 0x82C1
#define GL_IMAGE_CLASS_2_X_16 0x82BD
#define GL_IMAGE_CLASS_2_X_32 0x82BA
#define GL_IMAGE_CLASS_2_X_8 0x82C0
#define GL_IMAGE_CLASS_4_X_16 0x82BC
#define GL_IMAGE_CLASS_4_X_32 0x82B9
#define GL_IMAGE_CLASS_4_X_8 0x82BF
#define GL_IMAGE_COMPATIBILITY_CLASS 0x82A8
#define GL_IMAGE_CUBE 0x9050
#define GL_IMAGE_CUBE_MAP_ARRAY 0x9054
#define GL_IMAGE_FORMAT_COMPATIBILITY_BY_CLASS 0x90C9
#define GL_IMAGE_FORMAT_COMPATIBILITY_BY_SIZE 0x90C8
#define GL_IMAGE_FORMAT_COMPATIBILITY_TYPE 0x90C7
#define GL_IMAGE_PIXEL_FORMAT 0x82A9
#define GL_IMAGE_PIXEL_TYPE 0x82AA
#define GL_IMAGE_TEXEL_SIZE 0x82A7
#define GL_IMPLEMENTATION_COLOR_READ_FORMAT 0x8B9B
#define GL_IMPLEMENTATION_COLOR_READ_TYPE 0x8B9A
#define GL_INCR 0x1E02
#define GL_INCR_WRAP 0x8507
#define GL_INDEX 0x8222
#define GL_INDEX_ARRAY 0x8077
#define GL_INDEX_ARRAY_BUFFER_BINDING 0x8899
#define GL_INDEX_ARRAY_POINTER 0x8091
#define GL_INDEX_ARRAY_STRIDE 0x8086
#define GL_INDEX_ARRAY_TYPE 0x8085
#define GL_INDEX_BITS 0x0D51
#define GL_INDEX_CLEAR_VALUE 0x0C20
#define GL_INDEX_LOGIC_OP 0x0BF1
#define GL_INDEX_MODE 0x0C30
#define GL_INDEX_OFFSET 0x0D13
#define GL_INDEX_SHIFT 0x0D12
#define GL_INDEX_WRITEMASK 0x0C21
#define GL_INFO_LOG_LENGTH 0x8B84
#define GL_INNOCENT_CONTEXT_RESET 0x8254
#define GL_INNOCENT_CONTEXT_RESET_ARB 0x8254
#define GL_INT 0x1404
#define GL_INTENSITY 0x8049
#define GL_INTENSITY12 0x804C
#define GL_INTENSITY16 0x804D
#define GL_INTENSITY4 0x804A
#define GL_INTENSITY8 0x804B
#define GL_INTERLEAVED_ATTRIBS 0x8C8C
#define GL_INTERNALFORMAT_ALPHA_SIZE 0x8274
#define GL_INTERNALFORMAT_ALPHA_TYPE 0x827B
#define GL_INTERNALFORMAT_BLUE_SIZE 0x8273
#define GL_INTERNALFORMAT_BLUE_TYPE 0x827A
#define GL_INTERNALFORMAT_DEPTH_SIZE 0x8275
#define GL_INTERNALFORMAT_DEPTH_TYPE 0x827C
#define GL_INTERNALFORMAT_GREEN_SIZE 0x8272
#define GL_INTERNALFORMAT_GREEN_TYPE 0x8279
#define GL_INTERNALFORMAT_PREFERRED 0x8270
#define GL_INTERNALFORMAT_RED_SIZE 0x8271
#define GL_INTERNALFORMAT_RED_TYPE 0x8278
#define GL_INTERNALFORMAT_SHARED_SIZE 0x8277
#define GL_INTERNALFORMAT_STENCIL_SIZE 0x8276
#define GL_INTERNALFORMAT_STENCIL_TYPE 0x827D
#define GL_INTERNALFORMAT_SUPPORTED 0x826F
#define GL_INTERPOLATE 0x8575
#define GL_INT_2_10_10_10_REV 0x8D9F
#define GL_INT_IMAGE_1D 0x9057
#define GL_INT_IMAGE_1D_ARRAY 0x905D
#define GL_INT_IMAGE_2D 0x9058
#define GL_INT_IMAGE_2D_ARRAY 0x905E
#define GL_INT_IMAGE_2D_MULTISAMPLE 0x9060
#define GL_INT_IMAGE_2D_MULTISAMPLE_ARRAY 0x9061
#define GL_INT_IMAGE_2D_RECT 0x905A
#define GL_INT_IMAGE_3D 0x9059
#define GL_INT_IMAGE_BUFFER 0x905C
#define GL_INT_IMAGE_CUBE 0x905B
#define GL_INT_IMAGE_CUBE_MAP_ARRAY 0x905F
#define GL_INT_SAMPLER_1D 0x8DC9
#define GL_INT_SAMPLER_1D_ARRAY 0x8DCE
#define GL_INT_SAMPLER_2D 0x8DCA
#define GL_INT_SAMPLER_2D_ARRAY 0x8DCF
#define GL_INT_SAMPLER_2D_MULTISAMPLE 0x9109
#define GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY 0x910C
#define GL_INT_SAMPLER_2D_RECT 0x8DCD
#define GL_INT_SAMPLER_3D 0x8DCB
#define GL_INT_SAMPLER_BUFFER 0x8DD0
#define GL_INT_SAMPLER_CUBE 0x8DCC
#define GL_INT_SAMPLER_CUBE_MAP_ARRAY 0x900E
#define GL_INT_VEC2 0x8B53
#define GL_INT_VEC3 0x8B54
#define GL_INT_VEC4 0x8B55
#define GL_INVALID_ENUM 0x0500
#define GL_INVALID_FRAMEBUFFER_OPERATION 0x0506
#define GL_INVALID_INDEX 0xFFFFFFFF
#define GL_INVALID_OPERATION 0x0502
#define GL_INVALID_VALUE 0x0501
#define GL_INVERT 0x150A
#define GL_ISOLINES 0x8E7A
#define GL_IS_PER_PATCH 0x92E7
#define GL_IS_ROW_MAJOR 0x9300
#define GL_KEEP 0x1E00
#define GL_LAST_VERTEX_CONVENTION 0x8E4E
#define GL_LAYER_PROVOKING_VERTEX 0x825E
#define GL_LEFT 0x0406
#define GL_LEQUAL 0x0203
#define GL_LESS 0x0201
#define GL_LIGHT0 0x4000
#define GL_LIGHT1 0x4001
#define GL_LIGHT2 0x4002
#define GL_LIGHT3 0x4003
#define GL_LIGHT4 0x4004
#define GL_LIGHT5 0x4005
#define GL_LIGHT6 0x4006
#define GL_LIGHT7 0x4007
#define GL_LIGHTING 0x0B50
#define GL_LIGHTING_BIT 0x00000040
#define GL_LIGHT_MODEL_AMBIENT 0x0B53
#define GL_LIGHT_MODEL_COLOR_CONTROL 0x81F8
#define GL_LIGHT_MODEL_LOCAL_VIEWER 0x0B51
#define GL_LIGHT_MODEL_TWO_SIDE 0x0B52
#define GL_LINE 0x1B01
#define GL_LINEAR 0x2601
#define GL_LINEAR_ATTENUATION 0x1208
#define GL_LINEAR_MIPMAP_LINEAR 0x2703
#define GL_LINEAR_MIPMAP_NEAREST 0x2701
#define GL_LINES 0x0001
#define GL_LINES_ADJACENCY 0x000A
#define GL_LINE_BIT 0x00000004
#define GL_LINE_LOOP 0x0002
#define GL_LINE_RESET_TOKEN 0x0<PASSWORD>
#define GL_LINE_SMOOTH 0x0B20
#define GL_LINE_SMOOTH_HINT 0x0C52
#define GL_LINE_STIPPLE 0x0B24
#define GL_LINE_STIPPLE_PATTERN 0x0B25
#define GL_LINE_STIPPLE_REPEAT 0x0B26
#define GL_LINE_STRIP 0x0003
#define GL_LINE_STRIP_ADJACENCY 0x000B
#define GL_LINE_TOKEN 0x0702
#define GL_LINE_WIDTH 0x0B21
#define GL_LINE_WIDTH_GRANULARITY 0x0B23
#define GL_LINE_WIDTH_RANGE 0x0B22
#define GL_LINK_STATUS 0x8B82
#define GL_LIST_BASE 0x0B32
#define GL_LIST_BIT 0x00020000
#define GL_LIST_INDEX 0x0B33
#define GL_LIST_MODE 0x0B30
#define GL_LOAD 0x0101
#define GL_LOCATION 0x930E
#define GL_LOCATION_COMPONENT 0x934A
#define GL_LOCATION_INDEX 0x930F
#define GL_LOGIC_OP 0x0BF1
#define GL_LOGIC_OP_MODE 0x0BF0
#define GL_LOSE_CONTEXT_ON_RESET 0x8252
#define GL_LOSE_CONTEXT_ON_RESET_ARB 0x8252
#define GL_LOWER_LEFT 0x8CA1
#define GL_LOW_FLOAT 0x8DF0
#define GL_LOW_INT 0x8DF3
#define GL_LUMINANCE 0x1909
#define GL_LUMINANCE12 0x8041
#define GL_LUMINANCE12_ALPHA12 0x8047
#define GL_LUMINANCE12_ALPHA4 0x8046
#define GL_LUMINANCE16 0x8042
#define GL_LUMINANCE16_ALPHA16 0x8048
#define GL_LUMINANCE4 0x803F
#define GL_LUMINANCE4_ALPHA4 0x8043
#define GL_LUMINANCE6_ALPHA2 0x8044
#define GL_LUMINANCE8 0x8040
#define GL_LUMINANCE8_ALPHA8 0x8045
#define GL_LUMINANCE_ALPHA 0x190A
#define GL_MAJOR_VERSION 0x821B
#define GL_MANUAL_GENERATE_MIPMAP 0x8294
#define GL_MAP1_COLOR_4 0x0D90
#define GL_MAP1_GRID_DOMAIN 0x0DD0
#define GL_MAP1_GRID_SEGMENTS 0x0DD1
#define GL_MAP1_INDEX 0x0D91
#define GL_MAP1_NORMAL 0x0D92
#define GL_MAP1_TEXTURE_COORD_1 0x0D93
#define GL_MAP1_TEXTURE_COORD_2 0x0D94
#define GL_MAP1_TEXTURE_COORD_3 0x0D95
#define GL_MAP1_TEXTURE_COORD_4 0x0D96
#define GL_MAP1_VERTEX_3 0x0D97
#define GL_MAP1_VERTEX_4 0x0D98
#define GL_MAP2_COLOR_4 0x0DB0
#define GL_MAP2_GRID_DOMAIN 0x0DD2
#define GL_MAP2_GRID_SEGMENTS 0x0DD3
#define GL_MAP2_INDEX 0x0DB1
#define GL_MAP2_NORMAL 0x0DB2
#define GL_MAP2_TEXTURE_COORD_1 0x0DB3
#define GL_MAP2_TEXTURE_COORD_2 0x0DB4
#define GL_MAP2_TEXTURE_COORD_3 0x0DB5
#define GL_MAP2_TEXTURE_COORD_4 0x0DB6
#define GL_MAP2_VERTEX_3 0x0DB7
#define GL_MAP2_VERTEX_4 0x0DB8
#define GL_MAP_COHERENT_BIT 0x0080
#define GL_MAP_COLOR 0x0D10
#define GL_MAP_FLUSH_EXPLICIT_BIT 0x0010
#define GL_MAP_INVALIDATE_BUFFER_BIT 0x0008
#define GL_MAP_INVALIDATE_RANGE_BIT 0x0004
#define GL_MAP_PERSISTENT_BIT 0x0040
#define GL_MAP_READ_BIT 0x0001
#define GL_MAP_STENCIL 0x0D11
#define GL_MAP_UNSYNCHRONIZED_BIT 0x0020
#define GL_MAP_WRITE_BIT 0x0002
#define GL_MATRIX_MODE 0x0BA0
#define GL_MATRIX_STRIDE 0x92FF
#define GL_MAX 0x8008
#define GL_MAX_3D_TEXTURE_SIZE 0x8073
#define GL_MAX_ARRAY_TEXTURE_LAYERS 0x88FF
#define GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS 0x92DC
#define GL_MAX_ATOMIC_COUNTER_BUFFER_SIZE 0x92D8
#define GL_MAX_ATTRIB_STACK_DEPTH 0x0D35
#define GL_MAX_CLIENT_ATTRIB_STACK_DEPTH 0x0D3B
#define GL_MAX_CLIP_DISTANCES 0x0D32
#define GL_MAX_CLIP_PLANES 0x0D32
#define GL_MAX_COLOR_ATTACHMENTS 0x8CDF
#define GL_MAX_COLOR_TEXTURE_SAMPLES 0x910E
#define GL_MAX_COMBINED_ATOMIC_COUNTERS 0x92D7
#define GL_MAX_COMBINED_ATOMIC_COUNTER_BUFFERS 0x92D1
#define GL_MAX_COMBINED_CLIP_AND_CULL_DISTANCES 0x82FA
#define GL_MAX_COMBINED_COMPUTE_UNIFORM_COMPONENTS 0x8266
#define GL_MAX_COMBINED_DIMENSIONS 0x8282
#define GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS 0x8A33
#define GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS 0x8A32
#define GL_MAX_COMBINED_IMAGE_UNIFORMS 0x90CF
#define GL_MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS 0x8F39
#define GL_MAX_COMBINED_SHADER_OUTPUT_RESOURCES 0x8F39
#define GL_MAX_COMBINED_SHADER_STORAGE_BLOCKS 0x90DC
#define GL_MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS 0x8E1E
#define GL_MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS 0x8E1F
#define GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS 0x8B4D
#define GL_MAX_COMBINED_UNIFORM_BLOCKS 0x8A2E
#define GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS 0x8A31
#define GL_MAX_COMPUTE_ATOMIC_COUNTERS 0x8265
#define GL_MAX_COMPUTE_ATOMIC_COUNTER_BUFFERS 0x8264
#define GL_MAX_COMPUTE_IMAGE_UNIFORMS 0x91BD
#define GL_MAX_COMPUTE_SHADER_STORAGE_BLOCKS 0x90DB
#define GL_MAX_COMPUTE_SHARED_MEMORY_SIZE 0x8262
#define GL_MAX_COMPUTE_TEXTURE_IMAGE_UNITS 0x91BC
#define GL_MAX_COMPUTE_UNIFORM_BLOCKS 0x91BB
#define GL_MAX_COMPUTE_UNIFORM_COMPONENTS 0x8263
#define GL_MAX_COMPUTE_WORK_GROUP_COUNT 0x91BE
#define GL_MAX_COMPUTE_WORK_GROUP_INVOCATIONS 0x90EB
#define GL_MAX_COMPUTE_WORK_GROUP_SIZE 0x91BF
#define GL_MAX_CUBE_MAP_TEXTURE_SIZE 0x851C
#define GL_MAX_CULL_DISTANCES 0x82F9
#define GL_MAX_DEBUG_GROUP_STACK_DEPTH 0x826C
#define GL_MAX_DEBUG_LOGGED_MESSAGES 0x9144
#define GL_MAX_DEBUG_MESSAGE_LENGTH 0x9143
#define GL_MAX_DEPTH 0x8280
#define GL_MAX_DEPTH_TEXTURE_SAMPLES 0x910F
#define GL_MAX_DRAW_BUFFERS 0x8824
#define GL_MAX_DUAL_SOURCE_DRAW_BUFFERS 0x88FC
#define GL_MAX_ELEMENTS_INDICES 0x80E9
#define GL_MAX_ELEMENTS_VERTICES 0x80E8
#define GL_MAX_ELEMENT_INDEX 0x8D6B
#define GL_MAX_EVAL_ORDER 0x0D30
#define GL_MAX_FRAGMENT_ATOMIC_COUNTERS 0x92D6
#define GL_MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS 0x92D0
#define GL_MAX_FRAGMENT_IMAGE_UNIFORMS 0x90CE
#define GL_MAX_FRAGMENT_INPUT_COMPONENTS 0x9125
#define GL_MAX_FRAGMENT_INTERPOLATION_OFFSET 0x8E5C
#define GL_MAX_FRAGMENT_SHADER_STORAGE_BLOCKS 0x90DA
#define GL_MAX_FRAGMENT_UNIFORM_BLOCKS 0x8A2D
#define GL_MAX_FRAGMENT_UNIFORM_COMPONENTS 0x8B49
#define GL_MAX_FRAGMENT_UNIFORM_VECTORS 0x8DFD
#define GL_MAX_FRAMEBUFFER_HEIGHT 0x9316
#define GL_MAX_FRAMEBUFFER_LAYERS 0x9317
#define GL_MAX_FRAMEBUFFER_SAMPLES 0x9318
#define GL_MAX_FRAMEBUFFER_WIDTH 0x9315
#define GL_MAX_GEOMETRY_ATOMIC_COUNTERS 0x92D5
#define GL_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS 0x92CF
#define GL_MAX_GEOMETRY_IMAGE_UNIFORMS 0x90CD
#define GL_MAX_GEOMETRY_INPUT_COMPONENTS 0x9123
#define GL_MAX_GEOMETRY_OUTPUT_COMPONENTS 0x9124
#define GL_MAX_GEOMETRY_OUTPUT_VERTICES 0x8DE0
#define GL_MAX_GEOMETRY_SHADER_INVOCATIONS 0x8E5A
#define GL_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS 0x90D7
#define GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS 0x8C29
#define GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS 0x8DE1
#define GL_MAX_GEOMETRY_UNIFORM_BLOCKS 0x8A2C
#define GL_MAX_GEOMETRY_UNIFORM_COMPONENTS 0x8DDF
#define GL_MAX_HEIGHT 0x827F
#define GL_MAX_IMAGE_SAMPLES 0x906D
#define GL_MAX_IMAGE_UNITS 0x8F38
#define GL_MAX_INTEGER_SAMPLES 0x9110
#define GL_MAX_LABEL_LENGTH 0x82E8
#define GL_MAX_LAYERS 0x8281
#define GL_MAX_LIGHTS 0x0D31
#define GL_MAX_LIST_NESTING 0x0B31
#define GL_MAX_MODELVIEW_STACK_DEPTH 0x0D36
#define GL_MAX_NAME_LENGTH 0x92F6
#define GL_MAX_NAME_STACK_DEPTH 0x0D37
#define GL_MAX_NUM_ACTIVE_VARIABLES 0x92F7
#define GL_MAX_NUM_COMPATIBLE_SUBROUTINES 0x92F8
#define GL_MAX_PATCH_VERTICES 0x8E7D
#define GL_MAX_PIXEL_MAP_TABLE 0x0D34
#define GL_MAX_PROGRAM_TEXEL_OFFSET 0x8905
#define GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET 0x8E5F
#define GL_MAX_PROJECTION_STACK_DEPTH 0x0D38
#define GL_MAX_RECTANGLE_TEXTURE_SIZE 0x84F8
#define GL_MAX_RENDERBUFFER_SIZE 0x84E8
#define GL_MAX_SAMPLES 0x8D57
#define GL_MAX_SAMPLE_MASK_WORDS 0x8E59
#define GL_MAX_SERVER_WAIT_TIMEOUT 0x9111
#define GL_MAX_SHADER_STORAGE_BLOCK_SIZE 0x90DE
#define GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS 0x90DD
#define GL_MAX_SUBROUTINES 0x8DE7
#define GL_MAX_SUBROUTINE_UNIFORM_LOCATIONS 0x8DE8
#define GL_MAX_TESS_CONTROL_ATOMIC_COUNTERS 0x92D3
#define GL_MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS 0x92CD
#define GL_MAX_TESS_CONTROL_IMAGE_UNIFORMS 0x90CB
#define GL_MAX_TESS_CONTROL_INPUT_COMPONENTS 0x886C
#define GL_MAX_TESS_CONTROL_OUTPUT_COMPONENTS 0x8E83
#define GL_MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS 0x90D8
#define GL_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS 0x8E81
#define GL_MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS 0x8E85
#define GL_MAX_TESS_CONTROL_UNIFORM_BLOCKS 0x8E89
#define GL_MAX_TESS_CONTROL_UNIFORM_COMPONENTS 0x8E7F
#define GL_MAX_TESS_EVALUATION_ATOMIC_COUNTERS 0x92D4
#define GL_MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS 0x92CE
#define GL_MAX_TESS_EVALUATION_IMAGE_UNIFORMS 0x90CC
#define GL_MAX_TESS_EVALUATION_INPUT_COMPONENTS 0x886D
#define GL_MAX_TESS_EVALUATION_OUTPUT_COMPONENTS 0x8E86
#define GL_MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS 0x90D9
#define GL_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS 0x8E82
#define GL_MAX_TESS_EVALUATION_UNIFORM_BLOCKS 0x8E8A
#define GL_MAX_TESS_EVALUATION_UNIFORM_COMPONENTS 0x8E80
#define GL_MAX_TESS_GEN_LEVEL 0x8E7E
#define GL_MAX_TESS_PATCH_COMPONENTS 0x8E84
#define GL_MAX_TEXTURE_BUFFER_SIZE 0x8C2B
#define GL_MAX_TEXTURE_COORDS 0x8871
#define GL_MAX_TEXTURE_IMAGE_UNITS 0x8872
#define GL_MAX_TEXTURE_LOD_BIAS 0x84FD
#define GL_MAX_TEXTURE_MAX_ANISOTROPY 0x84FF
#define GL_MAX_TEXTURE_SIZE 0x0D33
#define GL_MAX_TEXTURE_STACK_DEPTH 0x0D39
#define GL_MAX_TEXTURE_UNITS 0x84E2
#define GL_MAX_TRANSFORM_FEEDBACK_BUFFERS 0x8E70
#define GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS 0x8C8A
#define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS 0x8C8B
#define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS 0x8C80
#define GL_MAX_UNIFORM_BLOCK_SIZE 0x8A30
#define GL_MAX_UNIFORM_BUFFER_BINDINGS 0x8A2F
#define GL_MAX_UNIFORM_LOCATIONS 0x826E
#define GL_MAX_VARYING_COMPONENTS 0x8B4B
#define GL_MAX_VARYING_FLOATS 0x8B4B
#define GL_MAX_VARYING_VECTORS 0x8DFC
#define GL_MAX_VERTEX_ATOMIC_COUNTERS 0x92D2
#define GL_MAX_VERTEX_ATOMIC_COUNTER_BUFFERS 0x92CC
#define GL_MAX_VERTEX_ATTRIBS 0x8869
#define GL_MAX_VERTEX_ATTRIB_BINDINGS 0x82DA
#define GL_MAX_VERTEX_ATTRIB_RELATIVE_OFFSET 0x82D9
#define GL_MAX_VERTEX_ATTRIB_STRIDE 0x82E5
#define GL_MAX_VERTEX_IMAGE_UNIFORMS 0x90CA
#define GL_MAX_VERTEX_OUTPUT_COMPONENTS 0x9122
#define GL_MAX_VERTEX_SHADER_STORAGE_BLOCKS 0x90D6
#define GL_MAX_VERTEX_STREAMS 0x8E71
#define GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS 0x8B4C
#define GL_MAX_VERTEX_UNIFORM_BLOCKS 0x8A2B
#define GL_MAX_VERTEX_UNIFORM_COMPONENTS 0x8B4A
#define GL_MAX_VERTEX_UNIFORM_VECTORS 0x8DFB
#define GL_MAX_VIEWPORTS 0x825B
#define GL_MAX_VIEWPORT_DIMS 0x0D3A
#define GL_MAX_WIDTH 0x827E
#define GL_MEDIUM_FLOAT 0x8DF1
#define GL_MEDIUM_INT 0x8DF4
#define GL_MIN 0x8007
#define GL_MINMAX 0x802E
#define GL_MINOR_VERSION 0x821C
#define GL_MIN_FRAGMENT_INTERPOLATION_OFFSET 0x8E5B
#define GL_MIN_MAP_BUFFER_ALIGNMENT 0x90BC
#define GL_MIN_PROGRAM_TEXEL_OFFSET 0x8904
#define GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET 0x8E5E
#define GL_MIN_SAMPLE_SHADING_VALUE 0x8C37
#define GL_MIPMAP 0x8293
#define GL_MIRRORED_REPEAT 0x8370
#define GL_MIRROR_CLAMP_TO_EDGE 0x8743
#define GL_MODELVIEW 0x1700
#define GL_MODELVIEW_MATRIX 0x0BA6
#define GL_MODELVIEW_STACK_DEPTH 0x0BA3
#define GL_MODULATE 0x2100
#define GL_MULT 0x0103
#define GL_MULTISAMPLE 0x809D
#define GL_MULTISAMPLE_ARB 0x809D
#define GL_MULTISAMPLE_BIT 0x20000000
#define GL_MULTISAMPLE_BIT_ARB 0x20000000
#define GL_N3F_V3F 0x2A25
#define GL_NAME_LENGTH 0x92F9
#define GL_NAME_STACK_DEPTH 0x0D70
#define GL_NAND 0x150E
#define GL_NEAREST 0x2600
#define GL_NEAREST_MIPMAP_LINEAR 0x2702
#define GL_NEAREST_MIPMAP_NEAREST 0x2700
#define GL_NEGATIVE_ONE_TO_ONE 0x935E
#define GL_NEVER 0x0200
#define GL_NICEST 0x1102
#define GL_NONE 0
#define GL_NOOP 0x1505
#define GL_NOR 0x1508
#define GL_NORMALIZE 0x0BA1
#define GL_NORMAL_ARRAY 0x8075
#define GL_NORMAL_ARRAY_BUFFER_BINDING 0x8897
#define GL_NORMAL_ARRAY_POINTER 0x808F
#define GL_NORMAL_ARRAY_STRIDE 0x807F
#define GL_NORMAL_ARRAY_TYPE 0x807E
#define GL_NORMAL_MAP 0x8511
#define GL_NOTEQUAL 0x0205
#define GL_NO_ERROR 0
#define GL_NO_RESET_NOTIFICATION 0x8261
#define GL_NO_RESET_NOTIFICATION_ARB 0x8261
#define GL_NUM_ACTIVE_VARIABLES 0x9304
#define GL_NUM_COMPATIBLE_SUBROUTINES 0x8E4A
#define GL_NUM_COMPRESSED_TEXTURE_FORMATS 0x86A2
#define GL_NUM_EXTENSIONS 0x821D
#define GL_NUM_PROGRAM_BINARY_FORMATS 0x87FE
#define GL_NUM_SAMPLE_COUNTS 0x9380
#define GL_NUM_SHADER_BINARY_FORMATS 0x8DF9
#define GL_NUM_SHADING_LANGUAGE_VERSIONS 0x82E9
#define GL_NUM_SPIR_V_EXTENSIONS 0x9554
#define GL_OBJECT_LINEAR 0x2401
#define GL_OBJECT_PLANE 0x2501
#define GL_OBJECT_TYPE 0x9112
#define GL_OFFSET 0x92FC
#define GL_ONE 1
#define GL_ONE_MINUS_CONSTANT_ALPHA 0x8004
#define GL_ONE_MINUS_CONSTANT_COLOR 0x8002
#define GL_ONE_MINUS_DST_ALPHA 0x0305
#define GL_ONE_MINUS_DST_COLOR 0x0307
#define GL_ONE_MINUS_SRC1_ALPHA 0x88FB
#define GL_ONE_MINUS_SRC1_COLOR 0x88FA
#define GL_ONE_MINUS_SRC_ALPHA 0x0303
#define GL_ONE_MINUS_SRC_COLOR 0x0301
#define GL_OPERAND0_ALPHA 0x8598
#define GL_OPERAND0_RGB 0x8590
#define GL_OPERAND1_ALPHA 0x8599
#define GL_OPERAND1_RGB 0x8591
#define GL_OPERAND2_ALPHA 0x859A
#define GL_OPERAND2_RGB 0x8592
#define GL_OR 0x1507
#define GL_ORDER 0x0A01
#define GL_OR_INVERTED 0x150D
#define GL_OR_REVERSE 0x150B
#define GL_OUT_OF_MEMORY 0x0505
#define GL_PACK_ALIGNMENT 0x0D05
#define GL_PACK_COMPRESSED_BLOCK_DEPTH 0x912D
#define GL_PACK_COMPRESSED_BLOCK_HEIGHT 0x912C
#define GL_PACK_COMPRESSED_BLOCK_SIZE 0x912E
#define GL_PACK_COMPRESSED_BLOCK_WIDTH 0x912B
#define GL_PACK_IMAGE_HEIGHT 0x806C
#define GL_PACK_LSB_FIRST 0x0D01
#define GL_PACK_ROW_LENGTH 0x0D02
#define GL_PACK_SKIP_IMAGES 0x806B
#define GL_PACK_SKIP_PIXELS 0x0D04
#define GL_PACK_SKIP_ROWS 0x0D03
#define GL_PACK_SWAP_BYTES 0x0D00
#define GL_PARAMETER_BUFFER 0x80EE
#define GL_PARAMETER_BUFFER_BINDING 0x80EF
#define GL_PASS_THROUGH_TOKEN 0x0700
#define GL_PATCHES 0x000E
#define GL_PATCH_DEFAULT_INNER_LEVEL 0x8E73
#define GL_PATCH_DEFAULT_OUTER_LEVEL 0x8E74
#define GL_PATCH_VERTICES 0x8E72
#define GL_PERSPECTIVE_CORRECTION_HINT 0x0C50
#define GL_PIXEL_BUFFER_BARRIER_BIT 0x00000080
#define GL_PIXEL_MAP_A_TO_A 0x0C79
#define GL_PIXEL_MAP_A_TO_A_SIZE 0x0CB9
#define GL_PIXEL_MAP_B_TO_B 0x0C78
#define GL_PIXEL_MAP_B_TO_B_SIZE 0x0CB8
#define GL_PIXEL_MAP_G_TO_G 0x0C77
#define GL_PIXEL_MAP_G_TO_G_SIZE 0x0CB7
#define GL_PIXEL_MAP_I_TO_A 0x0C75
#define GL_PIXEL_MAP_I_TO_A_SIZE 0x0CB5
#define GL_PIXEL_MAP_I_TO_B 0x0C74
#define GL_PIXEL_MAP_I_TO_B_SIZE 0x0CB4
#define GL_PIXEL_MAP_I_TO_G 0x0C73
#define GL_PIXEL_MAP_I_TO_G_SIZE 0x0CB3
#define GL_PIXEL_MAP_I_TO_I 0x0C70
#define GL_PIXEL_MAP_I_TO_I_SIZE 0x0CB0
#define GL_PIXEL_MAP_I_TO_R 0x0C72
#define GL_PIXEL_MAP_I_TO_R_SIZE 0x0CB2
#define GL_PIXEL_MAP_R_TO_R 0x0C76
#define GL_PIXEL_MAP_R_TO_R_SIZE 0x0CB6
#define GL_PIXEL_MAP_S_TO_S 0x0C71
#define GL_PIXEL_MAP_S_TO_S_SIZE 0x0CB1
#define GL_PIXEL_MODE_BIT 0x00000020
#define GL_PIXEL_PACK_BUFFER 0x88EB
#define GL_PIXEL_PACK_BUFFER_BINDING 0x88ED
#define GL_PIXEL_UNPACK_BUFFER 0x88EC
#define GL_PIXEL_UNPACK_BUFFER_BINDING 0x88EF
#define GL_POINT 0x1B00
#define GL_POINTS 0x0000
#define GL_POINT_BIT 0x00000002
#define GL_POINT_DISTANCE_ATTENUATION 0x8129
#define GL_POINT_FADE_THRESHOLD_SIZE 0x8128
#define GL_POINT_SIZE 0x0B11
#define GL_POINT_SIZE_GRANULARITY 0x0B13
#define GL_POINT_SIZE_MAX 0x8127
#define GL_POINT_SIZE_MIN 0x8126
#define GL_POINT_SIZE_RANGE 0x0B12
#define GL_POINT_SMOOTH 0x0B10
#define GL_POINT_SMOOTH_HINT 0x0C51
#define GL_POINT_SPRITE 0x8861
#define GL_POINT_SPRITE_COORD_ORIGIN 0x8CA0
#define GL_POINT_TOKEN 0x0701
#define GL_POLYGON 0x0009
#define GL_POLYGON_BIT 0x00000008
#define GL_POLYGON_MODE 0x0B40
#define GL_POLYGON_OFFSET_CLAMP 0x8E1B
#define GL_POLYGON_OFFSET_FACTOR 0x8038
#define GL_POLYGON_OFFSET_FILL 0x8037
#define GL_POLYGON_OFFSET_LINE 0x2A02
#define GL_POLYGON_OFFSET_POINT 0x2A01
#define GL_POLYGON_OFFSET_UNITS 0x2A00
#define GL_POLYGON_SMOOTH 0x0B41
#define GL_POLYGON_SMOOTH_HINT 0x0C53
#define GL_POLYGON_STIPPLE 0x0B42
#define GL_POLYGON_STIPPLE_BIT 0x00000010
#define GL_POLYGON_TOKEN 0x<PASSWORD>
#define GL_POSITION 0x1203
#define GL_POST_COLOR_MATRIX_COLOR_TABLE 0x80D2
#define GL_POST_CONVOLUTION_COLOR_TABLE 0x80D1
#define GL_PREVIOUS 0x8578
#define GL_PRIMARY_COLOR 0x8577
#define GL_PRIMITIVES_GENERATED 0x8C87
#define GL_PRIMITIVES_SUBMITTED 0x82EF
#define GL_PRIMITIVE_RESTART 0x8F9D
#define GL_PRIMITIVE_RESTART_FIXED_INDEX 0x8D69
#define GL_PRIMITIVE_RESTART_FOR_PATCHES_SUPPORTED 0x8221
#define GL_PRIMITIVE_RESTART_INDEX 0x8F9E
#define GL_PROGRAM 0x82E2
#define GL_PROGRAM_BINARY_FORMATS 0x87FF
#define GL_PROGRAM_BINARY_LENGTH 0x8741
#define GL_PROGRAM_BINARY_RETRIEVABLE_HINT 0x8257
#define GL_PROGRAM_INPUT 0x92E3
#define GL_PROGRAM_OUTPUT 0x92E4
#define GL_PROGRAM_PIPELINE 0x82E4
#define GL_PROGRAM_PIPELINE_BINDING 0x825A
#define GL_PROGRAM_POINT_SIZE 0x8642
#define GL_PROGRAM_SEPARABLE 0x8258
#define GL_PROJECTION 0x1701
#define GL_PROJECTION_MATRIX 0x0BA7
#define GL_PROJECTION_STACK_DEPTH 0x0BA4
#define GL_PROVOKING_VERTEX 0x8E4F
#define GL_PROXY_COLOR_TABLE 0x80D3
#define GL_PROXY_HISTOGRAM 0x8025
#define GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE 0x80D5
#define GL_PROXY_POST_CONVOLUTION_COLOR_TABLE 0x80D4
#define GL_PROXY_TEXTURE_1D 0x8063
#define GL_PROXY_TEXTURE_1D_ARRAY 0x8C19
#define GL_PROXY_TEXTURE_2D 0x8064
#define GL_PROXY_TEXTURE_2D_ARRAY 0x8C1B
#define GL_PROXY_TEXTURE_2D_MULTISAMPLE 0x9101
#define GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY 0x9103
#define GL_PROXY_TEXTURE_3D 0x8070
#define GL_PROXY_TEXTURE_CUBE_MAP 0x851B
#define GL_PROXY_TEXTURE_CUBE_MAP_ARRAY 0x900B
#define GL_PROXY_TEXTURE_RECTANGLE 0x84F7
#define GL_Q 0x2003
#define GL_QUADRATIC_ATTENUATION 0x1209
#define GL_QUADS 0x0007
#define GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION 0x8E4C
#define GL_QUAD_STRIP 0x0008
#define GL_QUERY 0x82E3
#define GL_QUERY_BUFFER 0x9192
#define GL_QUERY_BUFFER_BARRIER_BIT 0x00008000
#define GL_QUERY_BUFFER_BINDING 0x9193
#define GL_QUERY_BY_REGION_NO_WAIT 0x8E16
#define GL_QUERY_BY_REGION_NO_WAIT_INVERTED 0x8E1A
#define GL_QUERY_BY_REGION_WAIT 0x8E15
#define GL_QUERY_BY_REGION_WAIT_INVERTED 0x8E19
#define GL_QUERY_COUNTER_BITS 0x8864
#define GL_QUERY_NO_WAIT 0x8E14
#define GL_QUERY_NO_WAIT_INVERTED 0x8E18
#define GL_QUERY_RESULT 0x8866
#define GL_QUERY_RESULT_AVAILABLE 0x8867
#define GL_QUERY_RESULT_NO_WAIT 0x9194
#define GL_QUERY_TARGET 0x82EA
#define GL_QUERY_WAIT 0x8E13
#define GL_QUERY_WAIT_INVERTED 0x8E17
#define GL_R 0x2002
#define GL_R11F_G11F_B10F 0x8C3A
#define GL_R16 0x822A
#define GL_R16F 0x822D
#define GL_R16I 0x8233
#define GL_R16UI 0x8234
#define GL_R16_SNORM 0x8F98
#define GL_R32F 0x822E
#define GL_R32I 0x8235
#define GL_R32UI 0x8236
#define GL_R3_G3_B2 0x2A10
#define GL_R8 0x8229
#define GL_R8I 0x8231
#define GL_R8UI 0x8232
#define GL_R8_SNORM 0x8F94
#define GL_RASTERIZER_DISCARD 0x8C89
#define GL_READ_BUFFER 0x0C02
#define GL_READ_FRAMEBUFFER 0x8CA8
#define GL_READ_FRAMEBUFFER_BINDING 0x8CAA
#define GL_READ_ONLY 0x88B8
#define GL_READ_PIXELS 0x828C
#define GL_READ_PIXELS_FORMAT 0x828D
#define GL_READ_PIXELS_TYPE 0x828E
#define GL_READ_WRITE 0x88BA
#define GL_RED 0x1903
#define GL_RED_BIAS 0x0D15
#define GL_RED_BITS 0x0D52
#define GL_RED_INTEGER 0x8D94
#define GL_RED_SCALE 0x0D14
#define GL_REFERENCED_BY_COMPUTE_SHADER 0x930B
#define GL_REFERENCED_BY_FRAGMENT_SHADER 0x930A
#define GL_REFERENCED_BY_GEOMETRY_SHADER 0x9309
#define GL_REFERENCED_BY_TESS_CONTROL_SHADER 0x9307
#define GL_REFERENCED_BY_TESS_EVALUATION_SHADER 0x9308
#define GL_REFERENCED_BY_VERTEX_SHADER 0x9306
#define GL_REFLECTION_MAP 0x8512
#define GL_RENDER 0x1C00
#define GL_RENDERBUFFER 0x8D41
#define GL_RENDERBUFFER_ALPHA_SIZE 0x8D53
#define GL_RENDERBUFFER_BINDING 0x8CA7
#define GL_RENDERBUFFER_BLUE_SIZE 0x8D52
#define GL_RENDERBUFFER_DEPTH_SIZE 0x8D54
#define GL_RENDERBUFFER_GREEN_SIZE 0x8D51
#define GL_RENDERBUFFER_HEIGHT 0x8D43
#define GL_RENDERBUFFER_INTERNAL_FORMAT 0x8D44
#define GL_RENDERBUFFER_RED_SIZE 0x8D50
#define GL_RENDERBUFFER_SAMPLES 0x8CAB
#define GL_RENDERBUFFER_STENCIL_SIZE 0x8D55
#define GL_RENDERBUFFER_WIDTH 0x8D42
#define GL_RENDERER 0x1F01
#define GL_RENDER_MODE 0x0C40
#define GL_REPEAT 0x2901
#define GL_REPLACE 0x1E01
#define GL_RESCALE_NORMAL 0x803A
#define GL_RESET_NOTIFICATION_STRATEGY 0x8256
#define GL_RESET_NOTIFICATION_STRATEGY_ARB 0x8256
#define GL_RETURN 0x0102
#define GL_RG 0x8227
#define GL_RG16 0x822C
#define GL_RG16F 0x822F
#define GL_RG16I 0x8239
#define GL_RG16UI 0x823A
#define GL_RG16_SNORM 0x8F99
#define GL_RG32F 0x8230
#define GL_RG32I 0x823B
#define GL_RG32UI 0x823C
#define GL_RG8 0x822B
#define GL_RG8I 0x8237
#define GL_RG8UI 0x8238
#define GL_RG8_SNORM 0x8F95
#define GL_RGB 0x1907
#define GL_RGB10 0x8052
#define GL_RGB10_A2 0x8059
#define GL_RGB10_A2UI 0x906F
#define GL_RGB12 0x8053
#define GL_RGB16 0x8054
#define GL_RGB16F 0x881B
#define GL_RGB16I 0x8D89
#define GL_RGB16UI 0x8D77
#define GL_RGB16_SNORM 0x8F9A
#define GL_RGB32F 0x8815
#define GL_RGB32I 0x8D83
#define GL_RGB32UI 0x8D71
#define GL_RGB4 0x804F
#define GL_RGB5 0x8050
#define GL_RGB565 0x8D62
#define GL_RGB5_A1 0x8057
#define GL_RGB8 0x8051
#define GL_RGB8I 0x8D8F
#define GL_RGB8UI 0x8D7D
#define GL_RGB8_SNORM 0x8F96
#define GL_RGB9_E5 0x8C3D
#define GL_RGBA 0x1908
#define GL_RGBA12 0x805A
#define GL_RGBA16 0x805B
#define GL_RGBA16F 0x881A
#define GL_RGBA16I 0x8D88
#define GL_RGBA16UI 0x8D76
#define GL_RGBA16_SNORM 0x8F9B
#define GL_RGBA2 0x8055
#define GL_RGBA32F 0x8814
#define GL_RGBA32I 0x8D82
#define GL_RGBA32UI 0x8D70
#define GL_RGBA4 0x8056
#define GL_RGBA8 0x8058
#define GL_RGBA8I 0x8D8E
#define GL_RGBA8UI 0x8D7C
#define GL_RGBA8_SNORM 0x8F97
#define GL_RGBA_INTEGER 0x8D99
#define GL_RGBA_MODE 0x0C31
#define GL_RGB_INTEGER 0x8D98
#define GL_RGB_SCALE 0x8573
#define GL_RG_INTEGER 0x8228
#define GL_RIGHT 0x0407
#define GL_S 0x2000
#define GL_SAMPLER 0x82E6
#define GL_SAMPLER_1D 0x8B5D
#define GL_SAMPLER_1D_ARRAY 0x8DC0
#define GL_SAMPLER_1D_ARRAY_SHADOW 0x8DC3
#define GL_SAMPLER_1D_SHADOW 0x8B61
#define GL_SAMPLER_2D 0x8B5E
#define GL_SAMPLER_2D_ARRAY 0x8DC1
#define GL_SAMPLER_2D_ARRAY_SHADOW 0x8DC4
#define GL_SAMPLER_2D_MULTISAMPLE 0x9108
#define GL_SAMPLER_2D_MULTISAMPLE_ARRAY 0x910B
#define GL_SAMPLER_2D_RECT 0x8B63
#define GL_SAMPLER_2D_RECT_SHADOW 0x8B64
#define GL_SAMPLER_2D_SHADOW 0x8B62
#define GL_SAMPLER_3D 0x8B5F
#define GL_SAMPLER_BINDING 0x8919
#define GL_SAMPLER_BUFFER 0x8DC2
#define GL_SAMPLER_CUBE 0x8B60
#define GL_SAMPLER_CUBE_MAP_ARRAY 0x900C
#define GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW 0x900D
#define GL_SAMPLER_CUBE_SHADOW 0x8DC5
#define GL_SAMPLES 0x80A9
#define GL_SAMPLES_ARB 0x80A9
#define GL_SAMPLES_PASSED 0x8914
#define GL_SAMPLE_ALPHA_TO_COVERAGE 0x809E
#define GL_SAMPLE_ALPHA_TO_COVERAGE_ARB 0x809E
#define GL_SAMPLE_ALPHA_TO_ONE 0x809F
#define GL_SAMPLE_ALPHA_TO_ONE_ARB 0x809F
#define GL_SAMPLE_BUFFERS 0x80A8
#define GL_SAMPLE_BUFFERS_ARB 0x80A8
#define GL_SAMPLE_COVERAGE 0x80A0
#define GL_SAMPLE_COVERAGE_ARB 0x80A0
#define GL_SAMPLE_COVERAGE_INVERT 0x80AB
#define GL_SAMPLE_COVERAGE_INVERT_ARB 0x80AB
#define GL_SAMPLE_COVERAGE_VALUE 0x80AA
#define GL_SAMPLE_COVERAGE_VALUE_ARB 0x80AA
#define GL_SAMPLE_MASK 0x8E51
#define GL_SAMPLE_MASK_VALUE 0x8E52
#define GL_SAMPLE_POSITION 0x8E50
#define GL_SAMPLE_SHADING 0x8C36
#define GL_SCISSOR_BIT 0x00080000
#define GL_SCISSOR_BOX 0x0C10
#define GL_SCISSOR_TEST 0x0C11
#define GL_SECONDARY_COLOR_ARRAY 0x845E
#define GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING 0x889C
#define GL_SECONDARY_COLOR_ARRAY_POINTER 0x845D
#define GL_SECONDARY_COLOR_ARRAY_SIZE 0x845A
#define GL_SECONDARY_COLOR_ARRAY_STRIDE 0x845C
#define GL_SECONDARY_COLOR_ARRAY_TYPE 0x845B
#define GL_SELECT 0x1C02
#define GL_SELECTION_BUFFER_POINTER 0x0DF3
#define GL_SELECTION_BUFFER_SIZE 0x0DF4
#define GL_SEPARABLE_2D 0x8012
#define GL_SEPARATE_ATTRIBS 0x8C8D
#define GL_SEPARATE_SPECULAR_COLOR 0x81FA
#define GL_SET 0x150F
#define GL_SHADER 0x82E1
#define GL_SHADER_BINARY_FORMATS 0x8DF8
#define GL_SHADER_BINARY_FORMAT_SPIR_V 0x9551
#define GL_SHADER_COMPILER 0x8DFA
#define GL_SHADER_IMAGE_ACCESS_BARRIER_BIT 0x00000020
#define GL_SHADER_IMAGE_ATOMIC 0x82A6
#define GL_SHADER_IMAGE_LOAD 0x82A4
#define GL_SHADER_IMAGE_STORE 0x82A5
#define GL_SHADER_SOURCE_LENGTH 0x8B88
#define GL_SHADER_STORAGE_BARRIER_BIT 0x00002000
#define GL_SHADER_STORAGE_BLOCK 0x92E6
#define GL_SHADER_STORAGE_BUFFER 0x90D2
#define GL_SHADER_STORAGE_BUFFER_BINDING 0x90D3
#define GL_SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT 0x90DF
#define GL_SHADER_STORAGE_BUFFER_SIZE 0x90D5
#define GL_SHADER_STORAGE_BUFFER_START 0x90D4
#define GL_SHADER_TYPE 0x8B4F
#define GL_SHADE_MODEL 0x0B54
#define GL_SHADING_LANGUAGE_VERSION 0x8B8C
#define GL_SHININESS 0x1601
#define GL_SHORT 0x1402
#define GL_SIGNALED 0x9119
#define GL_SIGNED_NORMALIZED 0x8F9C
#define GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_TEST 0x82AC
#define GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_WRITE 0x82AE
#define GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_TEST 0x82AD
#define GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_WRITE 0x82AF
#define GL_SINGLE_COLOR 0x81F9
#define GL_SLUMINANCE 0x8C46
#define GL_SLUMINANCE8 0x8C47
#define GL_SLUMINANCE8_ALPHA8 0x8C45
#define GL_SLUMINANCE_ALPHA 0x8C44
#define GL_SMOOTH 0x1D01
#define GL_SMOOTH_LINE_WIDTH_GRANULARITY 0x0B23
#define GL_SMOOTH_LINE_WIDTH_RANGE 0x0B22
#define GL_SMOOTH_POINT_SIZE_GRANULARITY 0x0B13
#define GL_SMOOTH_POINT_SIZE_RANGE 0x0B12
#define GL_SOURCE0_ALPHA 0x8588
#define GL_SOURCE0_RGB 0x8580
#define GL_SOURCE1_ALPHA 0x8589
#define GL_SOURCE1_RGB 0x8581
#define GL_SOURCE2_ALPHA 0x858A
#define GL_SOURCE2_RGB 0x8582
#define GL_SPECULAR 0x1202
#define GL_SPHERE_MAP 0x2402
#define GL_SPIR_V_BINARY 0x9552
#define GL_SPIR_V_EXTENSIONS 0x9553
#define GL_SPOT_CUTOFF 0x1206
#define GL_SPOT_DIRECTION 0x1204
#define GL_SPOT_EXPONENT 0x1205
#define GL_SRC0_ALPHA 0x8588
#define GL_SRC0_RGB 0x8580
#define GL_SRC1_ALPHA 0x8589
#define GL_SRC1_COLOR 0x88F9
#define GL_SRC1_RGB 0x8581
#define GL_SRC2_ALPHA 0x858A
#define GL_SRC2_RGB 0x8582
#define GL_SRC_ALPHA 0x0302
#define GL_SRC_ALPHA_SATURATE 0x0308
#define GL_SRC_COLOR 0x0300
#define GL_SRGB 0x8C40
#define GL_SRGB8 0x8C41
#define GL_SRGB8_ALPHA8 0x8C43
#define GL_SRGB_ALPHA 0x8C42
#define GL_SRGB_READ 0x8297
#define GL_SRGB_WRITE 0x8298
#define GL_STACK_OVERFLOW 0x0503
#define GL_STACK_UNDERFLOW 0x0504
#define GL_STATIC_COPY 0x88E6
#define GL_STATIC_DRAW 0x88E4
#define GL_STATIC_READ 0x88E5
#define GL_STENCIL 0x1802
#define GL_STENCIL_ATTACHMENT 0x8D20
#define GL_STENCIL_BACK_FAIL 0x8801
#define GL_STENCIL_BACK_FUNC 0x8800
#define GL_STENCIL_BACK_PASS_DEPTH_FAIL 0x8802
#define GL_STENCIL_BACK_PASS_DEPTH_PASS 0x8803
#define GL_STENCIL_BACK_REF 0x8CA3
#define GL_STENCIL_BACK_VALUE_MASK 0x8CA4
#define GL_STENCIL_BACK_WRITEMASK 0x8CA5
#define GL_STENCIL_BITS 0x0D57
#define GL_STENCIL_BUFFER_BIT 0x00000400
#define GL_STENCIL_CLEAR_VALUE 0x0B91
#define GL_STENCIL_COMPONENTS 0x8285
#define GL_STENCIL_FAIL 0x0B94
#define GL_STENCIL_FUNC 0x0B92
#define GL_STENCIL_INDEX 0x1901
#define GL_STENCIL_INDEX1 0x8D46
#define GL_STENCIL_INDEX16 0x8D49
#define GL_STENCIL_INDEX4 0x8D47
#define GL_STENCIL_INDEX8 0x8D48
#define GL_STENCIL_PASS_DEPTH_FAIL 0x0B95
#define GL_STENCIL_PASS_DEPTH_PASS 0x0B96
#define GL_STENCIL_REF 0x0B97
#define GL_STENCIL_RENDERABLE 0x8288
#define GL_STENCIL_TEST 0x0B90
#define GL_STENCIL_VALUE_MASK 0x0B93
#define GL_STENCIL_WRITEMASK 0x0B98
#define GL_STEREO 0x0C33
#define GL_STREAM_COPY 0x88E2
#define GL_STREAM_DRAW 0x88E0
#define GL_STREAM_READ 0x88E1
#define GL_SUBPIXEL_BITS 0x0D50
#define GL_SUBTRACT 0x84E7
#define GL_SYNC_CONDITION 0x9113
#define GL_SYNC_FENCE 0x9116
#define GL_SYNC_FLAGS 0x9115
#define GL_SYNC_FLUSH_COMMANDS_BIT 0x00000001
#define GL_SYNC_GPU_COMMANDS_COMPLETE 0x9117
#define GL_SYNC_STATUS 0x9114
#define GL_T 0x2001
#define GL_T2F_C3F_V3F 0x2A2A
#define GL_T2F_C4F_N3F_V3F 0x2A2C
#define GL_T2F_C4UB_V3F 0x2A29
#define GL_T2F_N3F_V3F 0x2A2B
#define GL_T2F_V3F 0x2A27
#define GL_T4F_C4F_N3F_V4F 0x2A2D
#define GL_T4F_V4F 0x2A28
#define GL_TESS_CONTROL_OUTPUT_VERTICES 0x8E75
#define GL_TESS_CONTROL_SHADER 0x8E88
#define GL_TESS_CONTROL_SHADER_BIT 0x00000008
#define GL_TESS_CONTROL_SHADER_PATCHES 0x82F1
#define GL_TESS_CONTROL_SUBROUTINE 0x92E9
#define GL_TESS_CONTROL_SUBROUTINE_UNIFORM 0x92EF
#define GL_TESS_CONTROL_TEXTURE 0x829C
#define GL_TESS_EVALUATION_SHADER 0x8E87
#define GL_TESS_EVALUATION_SHADER_BIT 0x00000010
#define GL_TESS_EVALUATION_SHADER_INVOCATIONS 0x82F2
#define GL_TESS_EVALUATION_SUBROUTINE 0x92EA
#define GL_TESS_EVALUATION_SUBROUTINE_UNIFORM 0x92F0
#define GL_TESS_EVALUATION_TEXTURE 0x829D
#define GL_TESS_GEN_MODE 0x8E76
#define GL_TESS_GEN_POINT_MODE 0x8E79
#define GL_TESS_GEN_SPACING 0x8E77
#define GL_TESS_GEN_VERTEX_ORDER 0x8E78
#define GL_TEXTURE 0x1702
#define GL_TEXTURE0 0x84C0
#define GL_TEXTURE1 0x84C1
#define GL_TEXTURE10 0x84CA
#define GL_TEXTURE11 0x84CB
#define GL_TEXTURE12 0x84CC
#define GL_TEXTURE13 0x84CD
#define GL_TEXTURE14 0x84CE
#define GL_TEXTURE15 0x84CF
#define GL_TEXTURE16 0x84D0
#define GL_TEXTURE17 0x84D1
#define GL_TEXTURE18 0x84D2
#define GL_TEXTURE19 0x84D3
#define GL_TEXTURE2 0x84C2
#define GL_TEXTURE20 0x84D4
#define GL_TEXTURE21 0x84D5
#define GL_TEXTURE22 0x84D6
#define GL_TEXTURE23 0x84D7
#define GL_TEXTURE24 0x84D8
#define GL_TEXTURE25 0x84D9
#define GL_TEXTURE26 0x84DA
#define GL_TEXTURE27 0x84DB
#define GL_TEXTURE28 0x84DC
#define GL_TEXTURE29 0x84DD
#define GL_TEXTURE3 0x84C3
#define GL_TEXTURE30 0x84DE
#define GL_TEXTURE31 0x84DF
#define GL_TEXTURE4 0x84C4
#define GL_TEXTURE5 0x84C5
#define GL_TEXTURE6 0x84C6
#define GL_TEXTURE7 0x84C7
#define GL_TEXTURE8 0x84C8
#define GL_TEXTURE9 0x84C9
#define GL_TEXTURE_1D 0x0DE0
#define GL_TEXTURE_1D_ARRAY 0x8C18
#define GL_TEXTURE_2D 0x0DE1
#define GL_TEXTURE_2D_ARRAY 0x8C1A
#define GL_TEXTURE_2D_MULTISAMPLE 0x9100
#define GL_TEXTURE_2D_MULTISAMPLE_ARRAY 0x9102
#define GL_TEXTURE_3D 0x806F
#define GL_TEXTURE_ALPHA_SIZE 0x805F
#define GL_TEXTURE_ALPHA_TYPE 0x8C13
#define GL_TEXTURE_BASE_LEVEL 0x813C
#define GL_TEXTURE_BINDING_1D 0x8068
#define GL_TEXTURE_BINDING_1D_ARRAY 0x8C1C
#define GL_TEXTURE_BINDING_2D 0x8069
#define GL_TEXTURE_BINDING_2D_ARRAY 0x8C1D
#define GL_TEXTURE_BINDING_2D_MULTISAMPLE 0x9104
#define GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY 0x9105
#define GL_TEXTURE_BINDING_3D 0x806A
#define GL_TEXTURE_BINDING_BUFFER 0x8C2C
#define GL_TEXTURE_BINDING_CUBE_MAP 0x8514
#define GL_TEXTURE_BINDING_CUBE_MAP_ARRAY 0x900A
#define GL_TEXTURE_BINDING_RECTANGLE 0x84F6
#define GL_TEXTURE_BIT 0x00040000
#define GL_TEXTURE_BLUE_SIZE 0x805E
#define GL_TEXTURE_BLUE_TYPE 0x8C12
#define GL_TEXTURE_BORDER 0x1005
#define GL_TEXTURE_BORDER_COLOR 0x1004
#define GL_TEXTURE_BUFFER 0x8C2A
#define GL_TEXTURE_BUFFER_BINDING 0x8C2A
#define GL_TEXTURE_BUFFER_DATA_STORE_BINDING 0x8C2D
#define GL_TEXTURE_BUFFER_OFFSET 0x919D
#define GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT 0x919F
#define GL_TEXTURE_BUFFER_SIZE 0x919E
#define GL_TEXTURE_COMPARE_FUNC 0x884D
#define GL_TEXTURE_COMPARE_MODE 0x884C
#define GL_TEXTURE_COMPONENTS 0x1003
#define GL_TEXTURE_COMPRESSED 0x86A1
#define GL_TEXTURE_COMPRESSED_BLOCK_HEIGHT 0x82B2
#define GL_TEXTURE_COMPRESSED_BLOCK_SIZE 0x82B3
#define GL_TEXTURE_COMPRESSED_BLOCK_WIDTH 0x82B1
#define GL_TEXTURE_COMPRESSED_IMAGE_SIZE 0x86A0
#define GL_TEXTURE_COMPRESSION_HINT 0x84EF
#define GL_TEXTURE_COORD_ARRAY 0x8078
#define GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING 0x889A
#define GL_TEXTURE_COORD_ARRAY_POINTER 0x8092
#define GL_TEXTURE_COORD_ARRAY_SIZE 0x8088
#define GL_TEXTURE_COORD_ARRAY_STRIDE 0x808A
#define GL_TEXTURE_COORD_ARRAY_TYPE 0x8089
#define GL_TEXTURE_CUBE_MAP 0x8513
#define GL_TEXTURE_CUBE_MAP_ARRAY 0x9009
#define GL_TEXTURE_CUBE_MAP_NEGATIVE_X 0x8516
#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Y 0x8518
#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Z 0x851A
#define GL_TEXTURE_CUBE_MAP_POSITIVE_X 0x8515
#define GL_TEXTURE_CUBE_MAP_POSITIVE_Y 0x8517
#define GL_TEXTURE_CUBE_MAP_POSITIVE_Z 0x8519
#define GL_TEXTURE_CUBE_MAP_SEAMLESS 0x884F
#define GL_TEXTURE_DEPTH 0x8071
#define GL_TEXTURE_DEPTH_SIZE 0x884A
#define GL_TEXTURE_DEPTH_TYPE 0x8C16
#define GL_TEXTURE_ENV 0x2300
#define GL_TEXTURE_ENV_COLOR 0x2201
#define GL_TEXTURE_ENV_MODE 0x2200
#define GL_TEXTURE_FETCH_BARRIER_BIT 0x00000008
#define GL_TEXTURE_FILTER_CONTROL 0x8500
#define GL_TEXTURE_FIXED_SAMPLE_LOCATIONS 0x9107
#define GL_TEXTURE_GATHER 0x82A2
#define GL_TEXTURE_GATHER_SHADOW 0x82A3
#define GL_TEXTURE_GEN_MODE 0x2500
#define GL_TEXTURE_GEN_Q 0x0C63
#define GL_TEXTURE_GEN_R 0x0C62
#define GL_TEXTURE_GEN_S 0x0C60
#define GL_TEXTURE_GEN_T 0x0C61
#define GL_TEXTURE_GREEN_SIZE 0x805D
#define GL_TEXTURE_GREEN_TYPE 0x8C11
#define GL_TEXTURE_HEIGHT 0x1001
#define GL_TEXTURE_IMAGE_FORMAT 0x828F
#define GL_TEXTURE_IMAGE_TYPE 0x8290
#define GL_TEXTURE_IMMUTABLE_FORMAT 0x912F
#define GL_TEXTURE_IMMUTABLE_LEVELS 0x82DF
#define GL_TEXTURE_INTENSITY_SIZE 0x8061
#define GL_TEXTURE_INTENSITY_TYPE 0x8C15
#define GL_TEXTURE_INTERNAL_FORMAT 0x1003
#define GL_TEXTURE_LOD_BIAS 0x8501
#define GL_TEXTURE_LUMINANCE_SIZE 0x8060
#define GL_TEXTURE_LUMINANCE_TYPE 0x8C14
#define GL_TEXTURE_MAG_FILTER 0x2800
#define GL_TEXTURE_MATRIX 0x0BA8
#define GL_TEXTURE_MAX_ANISOTROPY 0x84FE
#define GL_TEXTURE_MAX_LEVEL 0x813D
#define GL_TEXTURE_MAX_LOD 0x813B
#define GL_TEXTURE_MIN_FILTER 0x2801
#define GL_TEXTURE_MIN_LOD 0x813A
#define GL_TEXTURE_PRIORITY 0x8066
#define GL_TEXTURE_RECTANGLE 0x84F5
#define GL_TEXTURE_RED_SIZE 0x805C
#define GL_TEXTURE_RED_TYPE 0x8C10
#define GL_TEXTURE_RESIDENT 0x8067
#define GL_TEXTURE_SAMPLES 0x9106
#define GL_TEXTURE_SHADOW 0x82A1
#define GL_TEXTURE_SHARED_SIZE 0x8C3F
#define GL_TEXTURE_STACK_DEPTH 0x0BA5
#define GL_TEXTURE_STENCIL_SIZE 0x88F1
#define GL_TEXTURE_SWIZZLE_A 0x8E45
#define GL_TEXTURE_SWIZZLE_B 0x8E44
#define GL_TEXTURE_SWIZZLE_G 0x8E43
#define GL_TEXTURE_SWIZZLE_R 0x8E42
#define GL_TEXTURE_SWIZZLE_RGBA 0x8E46
#define GL_TEXTURE_TARGET 0x1006
#define GL_TEXTURE_UPDATE_BARRIER_BIT 0x00000100
#define GL_TEXTURE_VIEW 0x82B5
#define GL_TEXTURE_VIEW_MIN_LAYER 0x82DD
#define GL_TEXTURE_VIEW_MIN_LEVEL 0x82DB
#define GL_TEXTURE_VIEW_NUM_LAYERS 0x82DE
#define GL_TEXTURE_VIEW_NUM_LEVELS 0x82DC
#define GL_TEXTURE_WIDTH 0x1000
#define GL_TEXTURE_WRAP_R 0x8072
#define GL_TEXTURE_WRAP_S 0x2802
#define GL_TEXTURE_WRAP_T 0x2803
#define GL_TIMEOUT_EXPIRED 0x911B
#define GL_TIMEOUT_IGNORED 0xFFFFFFFFFFFFFFFF
#define GL_TIMESTAMP 0x8E28
#define GL_TIME_ELAPSED 0x88BF
#define GL_TOP_LEVEL_ARRAY_SIZE 0x930C
#define GL_TOP_LEVEL_ARRAY_STRIDE 0x930D
#define GL_TRANSFORM_BIT 0x00001000
#define GL_TRANSFORM_FEEDBACK 0x8E22
#define GL_TRANSFORM_FEEDBACK_ACTIVE 0x8E24
#define GL_TRANSFORM_FEEDBACK_BARRIER_BIT 0x00000800
#define GL_TRANSFORM_FEEDBACK_BINDING 0x8E25
#define GL_TRANSFORM_FEEDBACK_BUFFER 0x8C8E
#define GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE 0x8E24
#define GL_TRANSFORM_FEEDBACK_BUFFER_BINDING 0x8C8F
#define GL_TRANSFORM_FEEDBACK_BUFFER_INDEX 0x934B
#define GL_TRANSFORM_FEEDBACK_BUFFER_MODE 0x8C7F
#define GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED 0x8E23
#define GL_TRANSFORM_FEEDBACK_BUFFER_SIZE 0x8C85
#define GL_TRANSFORM_FEEDBACK_BUFFER_START 0x8C84
#define GL_TRANSFORM_FEEDBACK_BUFFER_STRIDE 0x934C
#define GL_TRANSFORM_FEEDBACK_OVERFLOW 0x82EC
#define GL_TRANSFORM_FEEDBACK_PAUSED 0x8E23
#define GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN 0x8C88
#define GL_TRANSFORM_FEEDBACK_STREAM_OVERFLOW 0x82ED
#define GL_TRANSFORM_FEEDBACK_VARYING 0x92F4
#define GL_TRANSFORM_FEEDBACK_VARYINGS 0x8C83
#define GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH 0x8C76
#define GL_TRANSPOSE_COLOR_MATRIX 0x84E6
#define GL_TRANSPOSE_MODELVIEW_MATRIX 0x84E3
#define GL_TRANSPOSE_PROJECTION_MATRIX 0x84E4
#define GL_TRANSPOSE_TEXTURE_MATRIX 0x84E5
#define GL_TRIANGLES 0x0004
#define GL_TRIANGLES_ADJACENCY 0x000C
#define GL_TRIANGLE_FAN 0x0006
#define GL_TRIANGLE_STRIP 0x0005
#define GL_TRIANGLE_STRIP_ADJACENCY 0x000D
#define GL_TRUE 1
#define GL_TYPE 0x92FA
#define GL_UNDEFINED_VERTEX 0x8260
#define GL_UNIFORM 0x92E1
#define GL_UNIFORM_ARRAY_STRIDE 0x8A3C
#define GL_UNIFORM_ATOMIC_COUNTER_BUFFER_INDEX 0x92DA
#define GL_UNIFORM_BARRIER_BIT 0x00000004
#define GL_UNIFORM_BLOCK 0x92E2
#define GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS 0x8A42
#define GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES 0x8A43
#define GL_UNIFORM_BLOCK_BINDING 0x8A3F
#define GL_UNIFORM_BLOCK_DATA_SIZE 0x8A40
#define GL_UNIFORM_BLOCK_INDEX 0x8A3A
#define GL_UNIFORM_BLOCK_NAME_LENGTH 0x8A41
#define GL_UNIFORM_BLOCK_REFERENCED_BY_COMPUTE_SHADER 0x90EC
#define GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER 0x8A46
#define GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER 0x8A45
#define GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_CONTROL_SHADER 0x84F0
#define GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_EVALUATION_SHADER 0x84F1
#define GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER 0x8A44
#define GL_UNIFORM_BUFFER 0x8A11
#define GL_UNIFORM_BUFFER_BINDING 0x8A28
#define GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT 0x8A34
#define GL_UNIFORM_BUFFER_SIZE 0x8A2A
#define GL_UNIFORM_BUFFER_START 0x8A29
#define GL_UNIFORM_IS_ROW_MAJOR 0x8A3E
#define GL_UNIFORM_MATRIX_STRIDE 0x8A3D
#define GL_UNIFORM_NAME_LENGTH 0x8A39
#define GL_UNIFORM_OFFSET 0x8A3B
#define GL_UNIFORM_SIZE 0x8A38
#define GL_UNIFORM_TYPE 0x8A37
#define GL_UNKNOWN_CONTEXT_RESET 0x8255
#define GL_UNKNOWN_CONTEXT_RESET_ARB 0x8255
#define GL_UNPACK_ALIGNMENT 0x0CF5
#define GL_UNPACK_COMPRESSED_BLOCK_DEPTH 0x9129
#define GL_UNPACK_COMPRESSED_BLOCK_HEIGHT 0x9128
#define GL_UNPACK_COMPRESSED_BLOCK_SIZE 0x912A
#define GL_UNPACK_COMPRESSED_BLOCK_WIDTH 0x9127
#define GL_UNPACK_IMAGE_HEIGHT 0x806E
#define GL_UNPACK_LSB_FIRST 0x0CF1
#define GL_UNPACK_ROW_LENGTH 0x0CF2
#define GL_UNPACK_SKIP_IMAGES 0x806D
#define GL_UNPACK_SKIP_PIXELS 0x0CF4
#define GL_UNPACK_SKIP_ROWS 0x0CF3
#define GL_UNPACK_SWAP_BYTES 0x0CF0
#define GL_UNSIGNALED 0x9118
#define GL_UNSIGNED_BYTE 0x1401
#define GL_UNSIGNED_BYTE_2_3_3_REV 0x8362
#define GL_UNSIGNED_BYTE_3_3_2 0x8032
#define GL_UNSIGNED_INT 0x1405
#define GL_UNSIGNED_INT_10F_11F_11F_REV 0x8C3B
#define GL_UNSIGNED_INT_10_10_10_2 0x8036
#define GL_UNSIGNED_INT_24_8 0x84FA
#define GL_UNSIGNED_INT_2_10_10_10_REV 0x8368
#define GL_UNSIGNED_INT_5_9_9_9_REV 0x8C3E
#define GL_UNSIGNED_INT_8_8_8_8 0x8035
#define GL_UNSIGNED_INT_8_8_8_8_REV 0x8367
#define GL_UNSIGNED_INT_ATOMIC_COUNTER 0x92DB
#define GL_UNSIGNED_INT_IMAGE_1D 0x9062
#define GL_UNSIGNED_INT_IMAGE_1D_ARRAY 0x9068
#define GL_UNSIGNED_INT_IMAGE_2D 0x9063
#define GL_UNSIGNED_INT_IMAGE_2D_ARRAY 0x9069
#define GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE 0x906B
#define GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY 0x906C
#define GL_UNSIGNED_INT_IMAGE_2D_RECT 0x9065
#define GL_UNSIGNED_INT_IMAGE_3D 0x9064
#define GL_UNSIGNED_INT_IMAGE_BUFFER 0x9067
#define GL_UNSIGNED_INT_IMAGE_CUBE 0x9066
#define GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY 0x906A
#define GL_UNSIGNED_INT_SAMPLER_1D 0x8DD1
#define GL_UNSIGNED_INT_SAMPLER_1D_ARRAY 0x8DD6
#define GL_UNSIGNED_INT_SAMPLER_2D 0x8DD2
#define GL_UNSIGNED_INT_SAMPLER_2D_ARRAY 0x8DD7
#define GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE 0x910A
#define GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY 0x910D
#define GL_UNSIGNED_INT_SAMPLER_2D_RECT 0x8DD5
#define GL_UNSIGNED_INT_SAMPLER_3D 0x8DD3
#define GL_UNSIGNED_INT_SAMPLER_BUFFER 0x8DD8
#define GL_UNSIGNED_INT_SAMPLER_CUBE 0x8DD4
#define GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY 0x900F
#define GL_UNSIGNED_INT_VEC2 0x8DC6
#define GL_UNSIGNED_INT_VEC3 0x8DC7
#define GL_UNSIGNED_INT_VEC4 0x8DC8
#define GL_UNSIGNED_NORMALIZED 0x8C17
#define GL_UNSIGNED_SHORT 0x1403
#define GL_UNSIGNED_SHORT_1_5_5_5_REV 0x8366
#define GL_UNSIGNED_SHORT_4_4_4_4 0x8033
#define GL_UNSIGNED_SHORT_4_4_4_4_REV 0x8365
#define GL_UNSIGNED_SHORT_5_5_5_1 0x8034
#define GL_UNSIGNED_SHORT_5_6_5 0x8363
#define GL_UNSIGNED_SHORT_5_6_5_REV 0x8364
#define GL_UPPER_LEFT 0x8CA2
#define GL_V2F 0x2A20
#define GL_V3F 0x2A21
#define GL_VALIDATE_STATUS 0x8B83
#define GL_VENDOR 0x1F00
#define GL_VERSION 0x1F02
#define GL_VERTEX_ARRAY 0x8074
#define GL_VERTEX_ARRAY_BINDING 0x85B5
#define GL_VERTEX_ARRAY_BUFFER_BINDING 0x8896
#define GL_VERTEX_ARRAY_POINTER 0x808E
#define GL_VERTEX_ARRAY_SIZE 0x807A
#define GL_VERTEX_ARRAY_STRIDE 0x807C
#define GL_VERTEX_ARRAY_TYPE 0x807B
#define GL_VERTEX_ATTRIB_ARRAY_BARRIER_BIT 0x00000001
#define GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING 0x889F
#define GL_VERTEX_ATTRIB_ARRAY_DIVISOR 0x88FE
#define GL_VERTEX_ATTRIB_ARRAY_ENABLED 0x8622
#define GL_VERTEX_ATTRIB_ARRAY_INTEGER 0x88FD
#define GL_VERTEX_ATTRIB_ARRAY_LONG 0x874E
#define GL_VERTEX_ATTRIB_ARRAY_NORMALIZED 0x886A
#define GL_VERTEX_ATTRIB_ARRAY_POINTER 0x8645
#define GL_VERTEX_ATTRIB_ARRAY_SIZE 0x8623
#define GL_VERTEX_ATTRIB_ARRAY_STRIDE 0x8624
#define GL_VERTEX_ATTRIB_ARRAY_TYPE 0x8625
#define GL_VERTEX_ATTRIB_BINDING 0x82D4
#define GL_VERTEX_ATTRIB_RELATIVE_OFFSET 0x82D5
#define GL_VERTEX_BINDING_BUFFER 0x8F4F
#define GL_VERTEX_BINDING_DIVISOR 0x82D6
#define GL_VERTEX_BINDING_OFFSET 0x82D7
#define GL_VERTEX_BINDING_STRIDE 0x82D8
#define GL_VERTEX_PROGRAM_POINT_SIZE 0x8642
#define GL_VERTEX_PROGRAM_TWO_SIDE 0x8643
#define GL_VERTEX_SHADER 0x8B31
#define GL_VERTEX_SHADER_BIT 0x00000001
#define GL_VERTEX_SHADER_INVOCATIONS 0x82F0
#define GL_VERTEX_SUBROUTINE 0x92E8
#define GL_VERTEX_SUBROUTINE_UNIFORM 0x92EE
#define GL_VERTEX_TEXTURE 0x829B
#define GL_VERTICES_SUBMITTED 0x82EE
#define GL_VIEWPORT 0x0BA2
#define GL_VIEWPORT_BIT 0x00000800
#define GL_VIEWPORT_BOUNDS_RANGE 0x825D
#define GL_VIEWPORT_INDEX_PROVOKING_VERTEX 0x825F
#define GL_VIEWPORT_SUBPIXEL_BITS 0x825C
#define GL_VIEW_CLASS_128_BITS 0x82C4
#define GL_VIEW_CLASS_16_BITS 0x82CA
#define GL_VIEW_CLASS_24_BITS 0x82C9
#define GL_VIEW_CLASS_32_BITS 0x82C8
#define GL_VIEW_CLASS_48_BITS 0x82C7
#define GL_VIEW_CLASS_64_BITS 0x82C6
#define GL_VIEW_CLASS_8_BITS 0x82CB
#define GL_VIEW_CLASS_96_BITS 0x82C5
#define GL_VIEW_CLASS_BPTC_FLOAT 0x82D3
#define GL_VIEW_CLASS_BPTC_UNORM 0x82D2
#define GL_VIEW_CLASS_RGTC1_RED 0x82D0
#define GL_VIEW_CLASS_RGTC2_RG 0x82D1
#define GL_VIEW_CLASS_S3TC_DXT1_RGB 0x82CC
#define GL_VIEW_CLASS_S3TC_DXT1_RGBA 0x82CD
#define GL_VIEW_CLASS_S3TC_DXT3_RGBA 0x82CE
#define GL_VIEW_CLASS_S3TC_DXT5_RGBA 0x82CF
#define GL_VIEW_COMPATIBILITY_CLASS 0x82B6
#define GL_WAIT_FAILED 0x911D
#define GL_WEIGHT_ARRAY_BUFFER_BINDING 0x889E
#define GL_WRITE_ONLY 0x88B9
#define GL_XOR 0x1506
#define GL_ZERO 0
#define GL_ZERO_TO_ONE 0x935F
#define GL_ZOOM_X 0x0D16
#define GL_ZOOM_Y 0x0D17
#ifndef __khrplatform_h_
#define __khrplatform_h_
/*
** Copyright (c) 2008-2018 The Khronos Group Inc.
**
** Permission is hereby granted, free of charge, to any person obtaining a
** copy of this software and/or associated documentation files (the
** "Materials"), to deal in the Materials without restriction, including
** without limitation the rights to use, copy, modify, merge, publish,
** distribute, sublicense, and/or sell copies of the Materials, and to
** permit persons to whom the Materials are furnished to do so, subject to
** the following conditions:
**
** The above copyright notice and this permission notice shall be included
** in all copies or substantial portions of the Materials.
**
** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
*/
/* Khronos platform-specific types and definitions.
*
* The master copy of khrplatform.h is maintained in the Khronos EGL
* Registry repository at https://github.com/KhronosGroup/EGL-Registry
* The last semantic modification to khrplatform.h was at commit ID:
* 67a3e0864c2d75ea5287b9f3d2eb74a745936692
*
* Adopters may modify this file to suit their platform. Adopters are
* encouraged to submit platform specific modifications to the Khronos
* group so that they can be included in future versions of this file.
* Please submit changes by filing pull requests or issues on
* the EGL Registry repository linked above.
*
*
* See the Implementer's Guidelines for information about where this file
* should be located on your system and for more details of its use:
* http://www.khronos.org/registry/implementers_guide.pdf
*
* This file should be included as
* #include <KHR/khrplatform.h>
* by Khronos client API header files that use its types and defines.
*
* The types in khrplatform.h should only be used to define API-specific types.
*
* Types defined in khrplatform.h:
* khronos_int8_t signed 8 bit
* khronos_uint8_t unsigned 8 bit
* khronos_int16_t signed 16 bit
* khronos_uint16_t unsigned 16 bit
* khronos_int32_t signed 32 bit
* khronos_uint32_t unsigned 32 bit
* khronos_int64_t signed 64 bit
* khronos_uint64_t unsigned 64 bit
* khronos_intptr_t signed same number of bits as a pointer
* khronos_uintptr_t unsigned same number of bits as a pointer
* khronos_ssize_t signed size
* khronos_usize_t unsigned size
* khronos_float_t signed 32 bit floating point
* khronos_time_ns_t unsigned 64 bit time in nanoseconds
* khronos_utime_nanoseconds_t unsigned time interval or absolute time in
* nanoseconds
* khronos_stime_nanoseconds_t signed time interval in nanoseconds
* khronos_boolean_enum_t enumerated boolean type. This should
* only be used as a base type when a client API's boolean type is
* an enum. Client APIs which use an integer or other type for
* booleans cannot use this as the base type for their boolean.
*
* Tokens defined in khrplatform.h:
*
* KHRONOS_FALSE, KHRONOS_TRUE Enumerated boolean false/true values.
*
* KHRONOS_SUPPORT_INT64 is 1 if 64 bit integers are supported; otherwise 0.
* KHRONOS_SUPPORT_FLOAT is 1 if floats are supported; otherwise 0.
*
* Calling convention macros defined in this file:
* KHRONOS_APICALL
* KHRONOS_GLAD_API_PTR
* KHRONOS_APIATTRIBUTES
*
* These may be used in function prototypes as:
*
* KHRONOS_APICALL void KHRONOS_GLAD_API_PTR funcname(
* int arg1,
* int arg2) KHRONOS_APIATTRIBUTES;
*/
#if defined(__SCITECH_SNAP__) && !defined(KHRONOS_STATIC)
# define KHRONOS_STATIC 1
#endif
/*-------------------------------------------------------------------------
* Definition of KHRONOS_APICALL
*-------------------------------------------------------------------------
* This precedes the return type of the function in the function prototype.
*/
#if defined(KHRONOS_STATIC)
/* If the preprocessor constant KHRONOS_STATIC is defined, make the
* header compatible with static linking. */
# define KHRONOS_APICALL
#elif defined(_WIN32)
# define KHRONOS_APICALL __declspec(dllimport)
#elif defined (__SYMBIAN32__)
# define KHRONOS_APICALL IMPORT_C
#elif defined(__ANDROID__)
# define KHRONOS_APICALL __attribute__((visibility("default")))
#else
# define KHRONOS_APICALL
#endif
/*-------------------------------------------------------------------------
* Definition of KHRONOS_GLAD_API_PTR
*-------------------------------------------------------------------------
* This follows the return type of the function and precedes the function
* name in the function prototype.
*/
#if defined(_WIN32) && !defined(_WIN32_WCE) && !defined(__SCITECH_SNAP__)
/* Win32 but not WinCE */
# define KHRONOS_GLAD_API_PTR __stdcall
#else
# define KHRONOS_GLAD_API_PTR
#endif
/*-------------------------------------------------------------------------
* Definition of KHRONOS_APIATTRIBUTES
*-------------------------------------------------------------------------
* This follows the closing parenthesis of the function prototype arguments.
*/
#if defined (__ARMCC_2__)
#define KHRONOS_APIATTRIBUTES __softfp
#else
#define KHRONOS_APIATTRIBUTES
#endif
/*-------------------------------------------------------------------------
* basic type definitions
*-----------------------------------------------------------------------*/
#if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) || defined(__GNUC__) || defined(__SCO__) || defined(__USLC__)
/*
* Using <stdint.h>
*/
#include <stdint.h>
typedef int32_t khronos_int32_t;
typedef uint32_t khronos_uint32_t;
typedef int64_t khronos_int64_t;
typedef uint64_t khronos_uint64_t;
#define KHRONOS_SUPPORT_INT64 1
#define KHRONOS_SUPPORT_FLOAT 1
/*
* To support platform where unsigned long cannot be used interchangeably with
* inptr_t (e.g. CHERI-extended ISAs), we can use the stdint.h intptr_t.
* Ideally, we could just use (u)intptr_t everywhere, but this could result in
* ABI breakage if khronos_uintptr_t is changed from unsigned long to
* unsigned long long or similar (this results in different C++ name mangling).
* To avoid changes for existing platforms, we restrict usage of intptr_t to
* platforms where the size of a pointer is larger than the size of long.
*/
#if defined(__SIZEOF_LONG__) && defined(__SIZEOF_POINTER__)
#if __SIZEOF_POINTER__ > __SIZEOF_LONG__
#define KHRONOS_USE_INTPTR_T
#endif
#endif
#elif defined(__VMS ) || defined(__sgi)
/*
* Using <inttypes.h>
*/
#include <inttypes.h>
typedef int32_t khronos_int32_t;
typedef uint32_t khronos_uint32_t;
typedef int64_t khronos_int64_t;
typedef uint64_t khronos_uint64_t;
#define KHRONOS_SUPPORT_INT64 1
#define KHRONOS_SUPPORT_FLOAT 1
#elif defined(_WIN32) && !defined(__SCITECH_SNAP__)
/*
* Win32
*/
typedef __int32 khronos_int32_t;
typedef unsigned __int32 khronos_uint32_t;
typedef __int64 khronos_int64_t;
typedef unsigned __int64 khronos_uint64_t;
#define KHRONOS_SUPPORT_INT64 1
#define KHRONOS_SUPPORT_FLOAT 1
#elif defined(__sun__) || defined(__digital__)
/*
* Sun or Digital
*/
typedef int khronos_int32_t;
typedef unsigned int khronos_uint32_t;
#if defined(__arch64__) || defined(_LP64)
typedef long int khronos_int64_t;
typedef unsigned long int khronos_uint64_t;
#else
typedef long long int khronos_int64_t;
typedef unsigned long long int khronos_uint64_t;
#endif /* __arch64__ */
#define KHRONOS_SUPPORT_INT64 1
#define KHRONOS_SUPPORT_FLOAT 1
#elif 0
/*
* Hypothetical platform with no float or int64 support
*/
typedef int khronos_int32_t;
typedef unsigned int khronos_uint32_t;
#define KHRONOS_SUPPORT_INT64 0
#define KHRONOS_SUPPORT_FLOAT 0
#else
/*
* Generic fallback
*/
#include <stdint.h>
typedef int32_t khronos_int32_t;
typedef uint32_t khronos_uint32_t;
typedef int64_t khronos_int64_t;
typedef uint64_t khronos_uint64_t;
#define KHRONOS_SUPPORT_INT64 1
#define KHRONOS_SUPPORT_FLOAT 1
#endif
/*
* Types that are (so far) the same on all platforms
*/
typedef signed char khronos_int8_t;
typedef unsigned char khronos_uint8_t;
typedef signed short int khronos_int16_t;
typedef unsigned short int khronos_uint16_t;
/*
* Types that differ between LLP64 and LP64 architectures - in LLP64,
* pointers are 64 bits, but 'long' is still 32 bits. Win64 appears
* to be the only LLP64 architecture in current use.
*/
#ifdef KHRONOS_USE_INTPTR_T
typedef intptr_t khronos_intptr_t;
typedef uintptr_t khronos_uintptr_t;
#elif defined(_WIN64)
typedef signed long long int khronos_intptr_t;
typedef unsigned long long int khronos_uintptr_t;
#else
typedef signed long int khronos_intptr_t;
typedef unsigned long int khronos_uintptr_t;
#endif
#if defined(_WIN64)
typedef signed long long int khronos_ssize_t;
typedef unsigned long long int khronos_usize_t;
#else
typedef signed long int khronos_ssize_t;
typedef unsigned long int khronos_usize_t;
#endif
#if KHRONOS_SUPPORT_FLOAT
/*
* Float type
*/
typedef float khronos_float_t;
#endif
#if KHRONOS_SUPPORT_INT64
/* Time types
*
* These types can be used to represent a time interval in nanoseconds or
* an absolute Unadjusted System Time. Unadjusted System Time is the number
* of nanoseconds since some arbitrary system event (e.g. since the last
* time the system booted). The Unadjusted System Time is an unsigned
* 64 bit value that wraps back to 0 every 584 years. Time intervals
* may be either signed or unsigned.
*/
typedef khronos_uint64_t khronos_utime_nanoseconds_t;
typedef khronos_int64_t khronos_stime_nanoseconds_t;
#endif
/*
* Dummy value used to pad enum types to 32 bits.
*/
#ifndef KHRONOS_MAX_ENUM
#define KHRONOS_MAX_ENUM 0x7FFFFFFF
#endif
/*
* Enumerated boolean type
*
* Values other than zero should be considered to be true. Therefore
* comparisons should not be made against KHRONOS_TRUE.
*/
typedef enum {
KHRONOS_FALSE = 0,
KHRONOS_TRUE = 1,
KHRONOS_BOOLEAN_ENUM_FORCE_SIZE = KHRONOS_MAX_ENUM
} khronos_boolean_enum_t;
#endif /* __khrplatform_h_ */
typedef unsigned int GLenum;
typedef unsigned char GLboolean;
typedef unsigned int GLbitfield;
typedef void GLvoid;
typedef khronos_int8_t GLbyte;
typedef khronos_uint8_t GLubyte;
typedef khronos_int16_t GLshort;
typedef khronos_uint16_t GLushort;
typedef int GLint;
typedef unsigned int GLuint;
typedef khronos_int32_t GLclampx;
typedef int GLsizei;
typedef khronos_float_t GLfloat;
typedef khronos_float_t GLclampf;
typedef double GLdouble;
typedef double GLclampd;
typedef void *GLeglClientBufferEXT;
typedef void *GLeglImageOES;
typedef char GLchar;
typedef char GLcharARB;
#ifdef __APPLE__
typedef void *GLhandleARB;
#else
typedef unsigned int GLhandleARB;
#endif
typedef khronos_uint16_t GLhalf;
typedef khronos_uint16_t GLhalfARB;
typedef khronos_int32_t GLfixed;
#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && (__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ > 1060)
typedef khronos_intptr_t GLintptr;
#else
typedef khronos_intptr_t GLintptr;
#endif
#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && (__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ > 1060)
typedef khronos_intptr_t GLintptrARB;
#else
typedef khronos_intptr_t GLintptrARB;
#endif
#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && (__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ > 1060)
typedef khronos_ssize_t GLsizeiptr;
#else
typedef khronos_ssize_t GLsizeiptr;
#endif
#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && (__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ > 1060)
typedef khronos_ssize_t GLsizeiptrARB;
#else
typedef khronos_ssize_t GLsizeiptrARB;
#endif
typedef khronos_int64_t GLint64;
typedef khronos_int64_t GLint64EXT;
typedef khronos_uint64_t GLuint64;
typedef khronos_uint64_t GLuint64EXT;
typedef struct __GLsync *GLsync;
struct _cl_context;
struct _cl_event;
typedef void (GLAD_API_PTR *GLDEBUGPROC)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam);
typedef void (GLAD_API_PTR *GLDEBUGPROCARB)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam);
typedef void (GLAD_API_PTR *GLDEBUGPROCKHR)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam);
typedef void (GLAD_API_PTR *GLDEBUGPROCAMD)(GLuint id,GLenum category,GLenum severity,GLsizei length,const GLchar *message,void *userParam);
typedef unsigned short GLhalfNV;
typedef GLintptr GLvdpauSurfaceNV;
typedef void (GLAD_API_PTR *GLVULKANPROCNV)(void);
#define GL_VERSION_1_0 1
GLAD_API_CALL int GLAD_GL_VERSION_1_0;
#define GL_VERSION_1_1 1
GLAD_API_CALL int GLAD_GL_VERSION_1_1;
#define GL_VERSION_1_2 1
GLAD_API_CALL int GLAD_GL_VERSION_1_2;
#define GL_VERSION_1_3 1
GLAD_API_CALL int GLAD_GL_VERSION_1_3;
#define GL_VERSION_1_4 1
GLAD_API_CALL int GLAD_GL_VERSION_1_4;
#define GL_VERSION_1_5 1
GLAD_API_CALL int GLAD_GL_VERSION_1_5;
#define GL_VERSION_2_0 1
GLAD_API_CALL int GLAD_GL_VERSION_2_0;
#define GL_VERSION_2_1 1
GLAD_API_CALL int GLAD_GL_VERSION_2_1;
#define GL_VERSION_3_0 1
GLAD_API_CALL int GLAD_GL_VERSION_3_0;
#define GL_VERSION_3_1 1
GLAD_API_CALL int GLAD_GL_VERSION_3_1;
#define GL_VERSION_3_2 1
GLAD_API_CALL int GLAD_GL_VERSION_3_2;
#define GL_VERSION_3_3 1
GLAD_API_CALL int GLAD_GL_VERSION_3_3;
#define GL_VERSION_4_0 1
GLAD_API_CALL int GLAD_GL_VERSION_4_0;
#define GL_VERSION_4_1 1
GLAD_API_CALL int GLAD_GL_VERSION_4_1;
#define GL_VERSION_4_2 1
GLAD_API_CALL int GLAD_GL_VERSION_4_2;
#define GL_VERSION_4_3 1
GLAD_API_CALL int GLAD_GL_VERSION_4_3;
#define GL_VERSION_4_4 1
GLAD_API_CALL int GLAD_GL_VERSION_4_4;
#define GL_VERSION_4_5 1
GLAD_API_CALL int GLAD_GL_VERSION_4_5;
#define GL_VERSION_4_6 1
GLAD_API_CALL int GLAD_GL_VERSION_4_6;
#define GL_ARB_multisample 1
GLAD_API_CALL int GLAD_GL_ARB_multisample;
#define GL_ARB_robustness 1
GLAD_API_CALL int GLAD_GL_ARB_robustness;
#define GL_KHR_debug 1
GLAD_API_CALL int GLAD_GL_KHR_debug;
typedef void (GLAD_API_PTR *PFNGLACCUMPROC)(GLenum op, GLfloat value);
typedef void (GLAD_API_PTR *PFNGLACTIVESHADERPROGRAMPROC)(GLuint pipeline, GLuint program);
typedef void (GLAD_API_PTR *PFNGLACTIVETEXTUREPROC)(GLenum texture);
typedef void (GLAD_API_PTR *PFNGLALPHAFUNCPROC)(GLenum func, GLfloat ref);
typedef GLboolean (GLAD_API_PTR *PFNGLARETEXTURESRESIDENTPROC)(GLsizei n, const GLuint * textures, GLboolean * residences);
typedef void (GLAD_API_PTR *PFNGLARRAYELEMENTPROC)(GLint i);
typedef void (GLAD_API_PTR *PFNGLATTACHSHADERPROC)(GLuint program, GLuint shader);
typedef void (GLAD_API_PTR *PFNGLBEGINPROC)(GLenum mode);
typedef void (GLAD_API_PTR *PFNGLBEGINCONDITIONALRENDERPROC)(GLuint id, GLenum mode);
typedef void (GLAD_API_PTR *PFNGLBEGINQUERYPROC)(GLenum target, GLuint id);
typedef void (GLAD_API_PTR *PFNGLBEGINQUERYINDEXEDPROC)(GLenum target, GLuint index, GLuint id);
typedef void (GLAD_API_PTR *PFNGLBEGINTRANSFORMFEEDBACKPROC)(GLenum primitiveMode);
typedef void (GLAD_API_PTR *PFNGLBINDATTRIBLOCATIONPROC)(GLuint program, GLuint index, const GLchar * name);
typedef void (GLAD_API_PTR *PFNGLBINDBUFFERPROC)(GLenum target, GLuint buffer);
typedef void (GLAD_API_PTR *PFNGLBINDBUFFERBASEPROC)(GLenum target, GLuint index, GLuint buffer);
typedef void (GLAD_API_PTR *PFNGLBINDBUFFERRANGEPROC)(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size);
typedef void (GLAD_API_PTR *PFNGLBINDBUFFERSBASEPROC)(GLenum target, GLuint first, GLsizei count, const GLuint * buffers);
typedef void (GLAD_API_PTR *PFNGLBINDBUFFERSRANGEPROC)(GLenum target, GLuint first, GLsizei count, const GLuint * buffers, const GLintptr * offsets, const GLsizeiptr * sizes);
typedef void (GLAD_API_PTR *PFNGLBINDFRAGDATALOCATIONPROC)(GLuint program, GLuint color, const GLchar * name);
typedef void (GLAD_API_PTR *PFNGLBINDFRAGDATALOCATIONINDEXEDPROC)(GLuint program, GLuint colorNumber, GLuint index, const GLchar * name);
typedef void (GLAD_API_PTR *PFNGLBINDFRAMEBUFFERPROC)(GLenum target, GLuint framebuffer);
typedef void (GLAD_API_PTR *PFNGLBINDIMAGETEXTUREPROC)(GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format);
typedef void (GLAD_API_PTR *PFNGLBINDIMAGETEXTURESPROC)(GLuint first, GLsizei count, const GLuint * textures);
typedef void (GLAD_API_PTR *PFNGLBINDPROGRAMPIPELINEPROC)(GLuint pipeline);
typedef void (GLAD_API_PTR *PFNGLBINDRENDERBUFFERPROC)(GLenum target, GLuint renderbuffer);
typedef void (GLAD_API_PTR *PFNGLBINDSAMPLERPROC)(GLuint unit, GLuint sampler);
typedef void (GLAD_API_PTR *PFNGLBINDSAMPLERSPROC)(GLuint first, GLsizei count, const GLuint * samplers);
typedef void (GLAD_API_PTR *PFNGLBINDTEXTUREPROC)(GLenum target, GLuint texture);
typedef void (GLAD_API_PTR *PFNGLBINDTEXTUREUNITPROC)(GLuint unit, GLuint texture);
typedef void (GLAD_API_PTR *PFNGLBINDTEXTURESPROC)(GLuint first, GLsizei count, const GLuint * textures);
typedef void (GLAD_API_PTR *PFNGLBINDTRANSFORMFEEDBACKPROC)(GLenum target, GLuint id);
typedef void (GLAD_API_PTR *PFNGLBINDVERTEXARRAYPROC)(GLuint array);
typedef void (GLAD_API_PTR *PFNGLBINDVERTEXBUFFERPROC)(GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride);
typedef void (GLAD_API_PTR *PFNGLBINDVERTEXBUFFERSPROC)(GLuint first, GLsizei count, const GLuint * buffers, const GLintptr * offsets, const GLsizei * strides);
typedef void (GLAD_API_PTR *PFNGLBITMAPPROC)(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte * bitmap);
typedef void (GLAD_API_PTR *PFNGLBLENDCOLORPROC)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
typedef void (GLAD_API_PTR *PFNGLBLENDEQUATIONPROC)(GLenum mode);
typedef void (GLAD_API_PTR *PFNGLBLENDEQUATIONSEPARATEPROC)(GLenum modeRGB, GLenum modeAlpha);
typedef void (GLAD_API_PTR *PFNGLBLENDEQUATIONSEPARATEIPROC)(GLuint buf, GLenum modeRGB, GLenum modeAlpha);
typedef void (GLAD_API_PTR *PFNGLBLENDEQUATIONIPROC)(GLuint buf, GLenum mode);
typedef void (GLAD_API_PTR *PFNGLBLENDFUNCPROC)(GLenum sfactor, GLenum dfactor);
typedef void (GLAD_API_PTR *PFNGLBLENDFUNCSEPARATEPROC)(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
typedef void (GLAD_API_PTR *PFNGLBLENDFUNCSEPARATEIPROC)(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha);
typedef void (GLAD_API_PTR *PFNGLBLENDFUNCIPROC)(GLuint buf, GLenum src, GLenum dst);
typedef void (GLAD_API_PTR *PFNGLBLITFRAMEBUFFERPROC)(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
typedef void (GLAD_API_PTR *PFNGLBLITNAMEDFRAMEBUFFERPROC)(GLuint readFramebuffer, GLuint drawFramebuffer, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
typedef void (GLAD_API_PTR *PFNGLBUFFERDATAPROC)(GLenum target, GLsizeiptr size, const void * data, GLenum usage);
typedef void (GLAD_API_PTR *PFNGLBUFFERSTORAGEPROC)(GLenum target, GLsizeiptr size, const void * data, GLbitfield flags);
typedef void (GLAD_API_PTR *PFNGLBUFFERSUBDATAPROC)(GLenum target, GLintptr offset, GLsizeiptr size, const void * data);
typedef void (GLAD_API_PTR *PFNGLCALLLISTPROC)(GLuint list);
typedef void (GLAD_API_PTR *PFNGLCALLLISTSPROC)(GLsizei n, GLenum type, const void * lists);
typedef GLenum (GLAD_API_PTR *PFNGLCHECKFRAMEBUFFERSTATUSPROC)(GLenum target);
typedef GLenum (GLAD_API_PTR *PFNGLCHECKNAMEDFRAMEBUFFERSTATUSPROC)(GLuint framebuffer, GLenum target);
typedef void (GLAD_API_PTR *PFNGLCLAMPCOLORPROC)(GLenum target, GLenum clamp);
typedef void (GLAD_API_PTR *PFNGLCLEARPROC)(GLbitfield mask);
typedef void (GLAD_API_PTR *PFNGLCLEARACCUMPROC)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
typedef void (GLAD_API_PTR *PFNGLCLEARBUFFERDATAPROC)(GLenum target, GLenum internalformat, GLenum format, GLenum type, const void * data);
typedef void (GLAD_API_PTR *PFNGLCLEARBUFFERSUBDATAPROC)(GLenum target, GLenum internalformat, GLintptr offset, GLsizeiptr size, GLenum format, GLenum type, const void * data);
typedef void (GLAD_API_PTR *PFNGLCLEARBUFFERFIPROC)(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil);
typedef void (GLAD_API_PTR *PFNGLCLEARBUFFERFVPROC)(GLenum buffer, GLint drawbuffer, const GLfloat * value);
typedef void (GLAD_API_PTR *PFNGLCLEARBUFFERIVPROC)(GLenum buffer, GLint drawbuffer, const GLint * value);
typedef void (GLAD_API_PTR *PFNGLCLEARBUFFERUIVPROC)(GLenum buffer, GLint drawbuffer, const GLuint * value);
typedef void (GLAD_API_PTR *PFNGLCLEARCOLORPROC)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
typedef void (GLAD_API_PTR *PFNGLCLEARDEPTHPROC)(GLdouble depth);
typedef void (GLAD_API_PTR *PFNGLCLEARDEPTHFPROC)(GLfloat d);
typedef void (GLAD_API_PTR *PFNGLCLEARINDEXPROC)(GLfloat c);
typedef void (GLAD_API_PTR *PFNGLCLEARNAMEDBUFFERDATAPROC)(GLuint buffer, GLenum internalformat, GLenum format, GLenum type, const void * data);
typedef void (GLAD_API_PTR *PFNGLCLEARNAMEDBUFFERSUBDATAPROC)(GLuint buffer, GLenum internalformat, GLintptr offset, GLsizeiptr size, GLenum format, GLenum type, const void * data);
typedef void (GLAD_API_PTR *PFNGLCLEARNAMEDFRAMEBUFFERFIPROC)(GLuint framebuffer, GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil);
typedef void (GLAD_API_PTR *PFNGLCLEARNAMEDFRAMEBUFFERFVPROC)(GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLfloat * value);
typedef void (GLAD_API_PTR *PFNGLCLEARNAMEDFRAMEBUFFERIVPROC)(GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLint * value);
typedef void (GLAD_API_PTR *PFNGLCLEARNAMEDFRAMEBUFFERUIVPROC)(GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLuint * value);
typedef void (GLAD_API_PTR *PFNGLCLEARSTENCILPROC)(GLint s);
typedef void (GLAD_API_PTR *PFNGLCLEARTEXIMAGEPROC)(GLuint texture, GLint level, GLenum format, GLenum type, const void * data);
typedef void (GLAD_API_PTR *PFNGLCLEARTEXSUBIMAGEPROC)(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void * data);
typedef void (GLAD_API_PTR *PFNGLCLIENTACTIVETEXTUREPROC)(GLenum texture);
typedef GLenum (GLAD_API_PTR *PFNGLCLIENTWAITSYNCPROC)(GLsync sync, GLbitfield flags, GLuint64 timeout);
typedef void (GLAD_API_PTR *PFNGLCLIPCONTROLPROC)(GLenum origin, GLenum depth);
typedef void (GLAD_API_PTR *PFNGLCLIPPLANEPROC)(GLenum plane, const GLdouble * equation);
typedef void (GLAD_API_PTR *PFNGLCOLOR3BPROC)(GLbyte red, GLbyte green, GLbyte blue);
typedef void (GLAD_API_PTR *PFNGLCOLOR3BVPROC)(const GLbyte * v);
typedef void (GLAD_API_PTR *PFNGLCOLOR3DPROC)(GLdouble red, GLdouble green, GLdouble blue);
typedef void (GLAD_API_PTR *PFNGLCOLOR3DVPROC)(const GLdouble * v);
typedef void (GLAD_API_PTR *PFNGLCOLOR3FPROC)(GLfloat red, GLfloat green, GLfloat blue);
typedef void (GLAD_API_PTR *PFNGLCOLOR3FVPROC)(const GLfloat * v);
typedef void (GLAD_API_PTR *PFNGLCOLOR3IPROC)(GLint red, GLint green, GLint blue);
typedef void (GLAD_API_PTR *PFNGLCOLOR3IVPROC)(const GLint * v);
typedef void (GLAD_API_PTR *PFNGLCOLOR3SPROC)(GLshort red, GLshort green, GLshort blue);
typedef void (GLAD_API_PTR *PFNGLCOLOR3SVPROC)(const GLshort * v);
typedef void (GLAD_API_PTR *PFNGLCOLOR3UBPROC)(GLubyte red, GLubyte green, GLubyte blue);
typedef void (GLAD_API_PTR *PFNGLCOLOR3UBVPROC)(const GLubyte * v);
typedef void (GLAD_API_PTR *PFNGLCOLOR3UIPROC)(GLuint red, GLuint green, GLuint blue);
typedef void (GLAD_API_PTR *PFNGLCOLOR3UIVPROC)(const GLuint * v);
typedef void (GLAD_API_PTR *PFNGLCOLOR3USPROC)(GLushort red, GLushort green, GLushort blue);
typedef void (GLAD_API_PTR *PFNGLCOLOR3USVPROC)(const GLushort * v);
typedef void (GLAD_API_PTR *PFNGLCOLOR4BPROC)(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha);
typedef void (GLAD_API_PTR *PFNGLCOLOR4BVPROC)(const GLbyte * v);
typedef void (GLAD_API_PTR *PFNGLCOLOR4DPROC)(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha);
typedef void (GLAD_API_PTR *PFNGLCOLOR4DVPROC)(const GLdouble * v);
typedef void (GLAD_API_PTR *PFNGLCOLOR4FPROC)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
typedef void (GLAD_API_PTR *PFNGLCOLOR4FVPROC)(const GLfloat * v);
typedef void (GLAD_API_PTR *PFNGLCOLOR4IPROC)(GLint red, GLint green, GLint blue, GLint alpha);
typedef void (GLAD_API_PTR *PFNGLCOLOR4IVPROC)(const GLint * v);
typedef void (GLAD_API_PTR *PFNGLCOLOR4SPROC)(GLshort red, GLshort green, GLshort blue, GLshort alpha);
typedef void (GLAD_API_PTR *PFNGLCOLOR4SVPROC)(const GLshort * v);
typedef void (GLAD_API_PTR *PFNGLCOLOR4UBPROC)(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha);
typedef void (GLAD_API_PTR *PFNGLCOLOR4UBVPROC)(const GLubyte * v);
typedef void (GLAD_API_PTR *PFNGLCOLOR4UIPROC)(GLuint red, GLuint green, GLuint blue, GLuint alpha);
typedef void (GLAD_API_PTR *PFNGLCOLOR4UIVPROC)(const GLuint * v);
typedef void (GLAD_API_PTR *PFNGLCOLOR4USPROC)(GLushort red, GLushort green, GLushort blue, GLushort alpha);
typedef void (GLAD_API_PTR *PFNGLCOLOR4USVPROC)(const GLushort * v);
typedef void (GLAD_API_PTR *PFNGLCOLORMASKPROC)(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
typedef void (GLAD_API_PTR *PFNGLCOLORMASKIPROC)(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a);
typedef void (GLAD_API_PTR *PFNGLCOLORMATERIALPROC)(GLenum face, GLenum mode);
typedef void (GLAD_API_PTR *PFNGLCOLORP3UIPROC)(GLenum type, GLuint color);
typedef void (GLAD_API_PTR *PFNGLCOLORP3UIVPROC)(GLenum type, const GLuint * color);
typedef void (GLAD_API_PTR *PFNGLCOLORP4UIPROC)(GLenum type, GLuint color);
typedef void (GLAD_API_PTR *PFNGLCOLORP4UIVPROC)(GLenum type, const GLuint * color);
typedef void (GLAD_API_PTR *PFNGLCOLORPOINTERPROC)(GLint size, GLenum type, GLsizei stride, const void * pointer);
typedef void (GLAD_API_PTR *PFNGLCOMPILESHADERPROC)(GLuint shader);
typedef void (GLAD_API_PTR *PFNGLCOMPRESSEDTEXIMAGE1DPROC)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void * data);
typedef void (GLAD_API_PTR *PFNGLCOMPRESSEDTEXIMAGE2DPROC)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void * data);
typedef void (GLAD_API_PTR *PFNGLCOMPRESSEDTEXIMAGE3DPROC)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void * data);
typedef void (GLAD_API_PTR *PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void * data);
typedef void (GLAD_API_PTR *PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void * data);
typedef void (GLAD_API_PTR *PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void * data);
typedef void (GLAD_API_PTR *PFNGLCOMPRESSEDTEXTURESUBIMAGE1DPROC)(GLuint texture, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void * data);
typedef void (GLAD_API_PTR *PFNGLCOMPRESSEDTEXTURESUBIMAGE2DPROC)(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void * data);
typedef void (GLAD_API_PTR *PFNGLCOMPRESSEDTEXTURESUBIMAGE3DPROC)(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void * data);
typedef void (GLAD_API_PTR *PFNGLCOPYBUFFERSUBDATAPROC)(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size);
typedef void (GLAD_API_PTR *PFNGLCOPYIMAGESUBDATAPROC)(GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei srcWidth, GLsizei srcHeight, GLsizei srcDepth);
typedef void (GLAD_API_PTR *PFNGLCOPYNAMEDBUFFERSUBDATAPROC)(GLuint readBuffer, GLuint writeBuffer, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size);
typedef void (GLAD_API_PTR *PFNGLCOPYPIXELSPROC)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type);
typedef void (GLAD_API_PTR *PFNGLCOPYTEXIMAGE1DPROC)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border);
typedef void (GLAD_API_PTR *PFNGLCOPYTEXIMAGE2DPROC)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
typedef void (GLAD_API_PTR *PFNGLCOPYTEXSUBIMAGE1DPROC)(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
typedef void (GLAD_API_PTR *PFNGLCOPYTEXSUBIMAGE2DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
typedef void (GLAD_API_PTR *PFNGLCOPYTEXSUBIMAGE3DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);
typedef void (GLAD_API_PTR *PFNGLCOPYTEXTURESUBIMAGE1DPROC)(GLuint texture, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
typedef void (GLAD_API_PTR *PFNGLCOPYTEXTURESUBIMAGE2DPROC)(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
typedef void (GLAD_API_PTR *PFNGLCOPYTEXTURESUBIMAGE3DPROC)(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);
typedef void (GLAD_API_PTR *PFNGLCREATEBUFFERSPROC)(GLsizei n, GLuint * buffers);
typedef void (GLAD_API_PTR *PFNGLCREATEFRAMEBUFFERSPROC)(GLsizei n, GLuint * framebuffers);
typedef GLuint (GLAD_API_PTR *PFNGLCREATEPROGRAMPROC)(void);
typedef void (GLAD_API_PTR *PFNGLCREATEPROGRAMPIPELINESPROC)(GLsizei n, GLuint * pipelines);
typedef void (GLAD_API_PTR *PFNGLCREATEQUERIESPROC)(GLenum target, GLsizei n, GLuint * ids);
typedef void (GLAD_API_PTR *PFNGLCREATERENDERBUFFERSPROC)(GLsizei n, GLuint * renderbuffers);
typedef void (GLAD_API_PTR *PFNGLCREATESAMPLERSPROC)(GLsizei n, GLuint * samplers);
typedef GLuint (GLAD_API_PTR *PFNGLCREATESHADERPROC)(GLenum type);
typedef GLuint (GLAD_API_PTR *PFNGLCREATESHADERPROGRAMVPROC)(GLenum type, GLsizei count, const GLchar *const* strings);
typedef void (GLAD_API_PTR *PFNGLCREATETEXTURESPROC)(GLenum target, GLsizei n, GLuint * textures);
typedef void (GLAD_API_PTR *PFNGLCREATETRANSFORMFEEDBACKSPROC)(GLsizei n, GLuint * ids);
typedef void (GLAD_API_PTR *PFNGLCREATEVERTEXARRAYSPROC)(GLsizei n, GLuint * arrays);
typedef void (GLAD_API_PTR *PFNGLCULLFACEPROC)(GLenum mode);
typedef void (GLAD_API_PTR *PFNGLDEBUGMESSAGECALLBACKPROC)(GLDEBUGPROC callback, const void * userParam);
typedef void (GLAD_API_PTR *PFNGLDEBUGMESSAGECONTROLPROC)(GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint * ids, GLboolean enabled);
typedef void (GLAD_API_PTR *PFNGLDEBUGMESSAGEINSERTPROC)(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar * buf);
typedef void (GLAD_API_PTR *PFNGLDELETEBUFFERSPROC)(GLsizei n, const GLuint * buffers);
typedef void (GLAD_API_PTR *PFNGLDELETEFRAMEBUFFERSPROC)(GLsizei n, const GLuint * framebuffers);
typedef void (GLAD_API_PTR *PFNGLDELETELISTSPROC)(GLuint list, GLsizei range);
typedef void (GLAD_API_PTR *PFNGLDELETEPROGRAMPROC)(GLuint program);
typedef void (GLAD_API_PTR *PFNGLDELETEPROGRAMPIPELINESPROC)(GLsizei n, const GLuint * pipelines);
typedef void (GLAD_API_PTR *PFNGLDELETEQUERIESPROC)(GLsizei n, const GLuint * ids);
typedef void (GLAD_API_PTR *PFNGLDELETERENDERBUFFERSPROC)(GLsizei n, const GLuint * renderbuffers);
typedef void (GLAD_API_PTR *PFNGLDELETESAMPLERSPROC)(GLsizei count, const GLuint * samplers);
typedef void (GLAD_API_PTR *PFNGLDELETESHADERPROC)(GLuint shader);
typedef void (GLAD_API_PTR *PFNGLDELETESYNCPROC)(GLsync sync);
typedef void (GLAD_API_PTR *PFNGLDELETETEXTURESPROC)(GLsizei n, const GLuint * textures);
typedef void (GLAD_API_PTR *PFNGLDELETETRANSFORMFEEDBACKSPROC)(GLsizei n, const GLuint * ids);
typedef void (GLAD_API_PTR *PFNGLDELETEVERTEXARRAYSPROC)(GLsizei n, const GLuint * arrays);
typedef void (GLAD_API_PTR *PFNGLDEPTHFUNCPROC)(GLenum func);
typedef void (GLAD_API_PTR *PFNGLDEPTHMASKPROC)(GLboolean flag);
typedef void (GLAD_API_PTR *PFNGLDEPTHRANGEPROC)(GLdouble n, GLdouble f);
typedef void (GLAD_API_PTR *PFNGLDEPTHRANGEARRAYVPROC)(GLuint first, GLsizei count, const GLdouble * v);
typedef void (GLAD_API_PTR *PFNGLDEPTHRANGEINDEXEDPROC)(GLuint index, GLdouble n, GLdouble f);
typedef void (GLAD_API_PTR *PFNGLDEPTHRANGEFPROC)(GLfloat n, GLfloat f);
typedef void (GLAD_API_PTR *PFNGLDETACHSHADERPROC)(GLuint program, GLuint shader);
typedef void (GLAD_API_PTR *PFNGLDISABLEPROC)(GLenum cap);
typedef void (GLAD_API_PTR *PFNGLDISABLECLIENTSTATEPROC)(GLenum array);
typedef void (GLAD_API_PTR *PFNGLDISABLEVERTEXARRAYATTRIBPROC)(GLuint vaobj, GLuint index);
typedef void (GLAD_API_PTR *PFNGLDISABLEVERTEXATTRIBARRAYPROC)(GLuint index);
typedef void (GLAD_API_PTR *PFNGLDISABLEIPROC)(GLenum target, GLuint index);
typedef void (GLAD_API_PTR *PFNGLDISPATCHCOMPUTEPROC)(GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z);
typedef void (GLAD_API_PTR *PFNGLDISPATCHCOMPUTEINDIRECTPROC)(GLintptr indirect);
typedef void (GLAD_API_PTR *PFNGLDRAWARRAYSPROC)(GLenum mode, GLint first, GLsizei count);
typedef void (GLAD_API_PTR *PFNGLDRAWARRAYSINDIRECTPROC)(GLenum mode, const void * indirect);
typedef void (GLAD_API_PTR *PFNGLDRAWARRAYSINSTANCEDPROC)(GLenum mode, GLint first, GLsizei count, GLsizei instancecount);
typedef void (GLAD_API_PTR *PFNGLDRAWARRAYSINSTANCEDBASEINSTANCEPROC)(GLenum mode, GLint first, GLsizei count, GLsizei instancecount, GLuint baseinstance);
typedef void (GLAD_API_PTR *PFNGLDRAWBUFFERPROC)(GLenum buf);
typedef void (GLAD_API_PTR *PFNGLDRAWBUFFERSPROC)(GLsizei n, const GLenum * bufs);
typedef void (GLAD_API_PTR *PFNGLDRAWELEMENTSPROC)(GLenum mode, GLsizei count, GLenum type, const void * indices);
typedef void (GLAD_API_PTR *PFNGLDRAWELEMENTSBASEVERTEXPROC)(GLenum mode, GLsizei count, GLenum type, const void * indices, GLint basevertex);
typedef void (GLAD_API_PTR *PFNGLDRAWELEMENTSINDIRECTPROC)(GLenum mode, GLenum type, const void * indirect);
typedef void (GLAD_API_PTR *PFNGLDRAWELEMENTSINSTANCEDPROC)(GLenum mode, GLsizei count, GLenum type, const void * indices, GLsizei instancecount);
typedef void (GLAD_API_PTR *PFNGLDRAWELEMENTSINSTANCEDBASEINSTANCEPROC)(GLenum mode, GLsizei count, GLenum type, const void * indices, GLsizei instancecount, GLuint baseinstance);
typedef void (GLAD_API_PTR *PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC)(GLenum mode, GLsizei count, GLenum type, const void * indices, GLsizei instancecount, GLint basevertex);
typedef void (GLAD_API_PTR *PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCEPROC)(GLenum mode, GLsizei count, GLenum type, const void * indices, GLsizei instancecount, GLint basevertex, GLuint baseinstance);
typedef void (GLAD_API_PTR *PFNGLDRAWPIXELSPROC)(GLsizei width, GLsizei height, GLenum format, GLenum type, const void * pixels);
typedef void (GLAD_API_PTR *PFNGLDRAWRANGEELEMENTSPROC)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void * indices);
typedef void (GLAD_API_PTR *PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void * indices, GLint basevertex);
typedef void (GLAD_API_PTR *PFNGLDRAWTRANSFORMFEEDBACKPROC)(GLenum mode, GLuint id);
typedef void (GLAD_API_PTR *PFNGLDRAWTRANSFORMFEEDBACKINSTANCEDPROC)(GLenum mode, GLuint id, GLsizei instancecount);
typedef void (GLAD_API_PTR *PFNGLDRAWTRANSFORMFEEDBACKSTREAMPROC)(GLenum mode, GLuint id, GLuint stream);
typedef void (GLAD_API_PTR *PFNGLDRAWTRANSFORMFEEDBACKSTREAMINSTANCEDPROC)(GLenum mode, GLuint id, GLuint stream, GLsizei instancecount);
typedef void (GLAD_API_PTR *PFNGLEDGEFLAGPROC)(GLboolean flag);
typedef void (GLAD_API_PTR *PFNGLEDGEFLAGPOINTERPROC)(GLsizei stride, const void * pointer);
typedef void (GLAD_API_PTR *PFNGLEDGEFLAGVPROC)(const GLboolean * flag);
typedef void (GLAD_API_PTR *PFNGLENABLEPROC)(GLenum cap);
typedef void (GLAD_API_PTR *PFNGLENABLECLIENTSTATEPROC)(GLenum array);
typedef void (GLAD_API_PTR *PFNGLENABLEVERTEXARRAYATTRIBPROC)(GLuint vaobj, GLuint index);
typedef void (GLAD_API_PTR *PFNGLENABLEVERTEXATTRIBARRAYPROC)(GLuint index);
typedef void (GLAD_API_PTR *PFNGLENABLEIPROC)(GLenum target, GLuint index);
typedef void (GLAD_API_PTR *PFNGLENDPROC)(void);
typedef void (GLAD_API_PTR *PFNGLENDCONDITIONALRENDERPROC)(void);
typedef void (GLAD_API_PTR *PFNGLENDLISTPROC)(void);
typedef void (GLAD_API_PTR *PFNGLENDQUERYPROC)(GLenum target);
typedef void (GLAD_API_PTR *PFNGLENDQUERYINDEXEDPROC)(GLenum target, GLuint index);
typedef void (GLAD_API_PTR *PFNGLENDTRANSFORMFEEDBACKPROC)(void);
typedef void (GLAD_API_PTR *PFNGLEVALCOORD1DPROC)(GLdouble u);
typedef void (GLAD_API_PTR *PFNGLEVALCOORD1DVPROC)(const GLdouble * u);
typedef void (GLAD_API_PTR *PFNGLEVALCOORD1FPROC)(GLfloat u);
typedef void (GLAD_API_PTR *PFNGLEVALCOORD1FVPROC)(const GLfloat * u);
typedef void (GLAD_API_PTR *PFNGLEVALCOORD2DPROC)(GLdouble u, GLdouble v);
typedef void (GLAD_API_PTR *PFNGLEVALCOORD2DVPROC)(const GLdouble * u);
typedef void (GLAD_API_PTR *PFNGLEVALCOORD2FPROC)(GLfloat u, GLfloat v);
typedef void (GLAD_API_PTR *PFNGLEVALCOORD2FVPROC)(const GLfloat * u);
typedef void (GLAD_API_PTR *PFNGLEVALMESH1PROC)(GLenum mode, GLint i1, GLint i2);
typedef void (GLAD_API_PTR *PFNGLEVALMESH2PROC)(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2);
typedef void (GLAD_API_PTR *PFNGLEVALPOINT1PROC)(GLint i);
typedef void (GLAD_API_PTR *PFNGLEVALPOINT2PROC)(GLint i, GLint j);
typedef void (GLAD_API_PTR *PFNGLFEEDBACKBUFFERPROC)(GLsizei size, GLenum type, GLfloat * buffer);
typedef GLsync (GLAD_API_PTR *PFNGLFENCESYNCPROC)(GLenum condition, GLbitfield flags);
typedef void (GLAD_API_PTR *PFNGLFINISHPROC)(void);
typedef void (GLAD_API_PTR *PFNGLFLUSHPROC)(void);
typedef void (GLAD_API_PTR *PFNGLFLUSHMAPPEDBUFFERRANGEPROC)(GLenum target, GLintptr offset, GLsizeiptr length);
typedef void (GLAD_API_PTR *PFNGLFLUSHMAPPEDNAMEDBUFFERRANGEPROC)(GLuint buffer, GLintptr offset, GLsizeiptr length);
typedef void (GLAD_API_PTR *PFNGLFOGCOORDPOINTERPROC)(GLenum type, GLsizei stride, const void * pointer);
typedef void (GLAD_API_PTR *PFNGLFOGCOORDDPROC)(GLdouble coord);
typedef void (GLAD_API_PTR *PFNGLFOGCOORDDVPROC)(const GLdouble * coord);
typedef void (GLAD_API_PTR *PFNGLFOGCOORDFPROC)(GLfloat coord);
typedef void (GLAD_API_PTR *PFNGLFOGCOORDFVPROC)(const GLfloat * coord);
typedef void (GLAD_API_PTR *PFNGLFOGFPROC)(GLenum pname, GLfloat param);
typedef void (GLAD_API_PTR *PFNGLFOGFVPROC)(GLenum pname, const GLfloat * params);
typedef void (GLAD_API_PTR *PFNGLFOGIPROC)(GLenum pname, GLint param);
typedef void (GLAD_API_PTR *PFNGLFOGIVPROC)(GLenum pname, const GLint * params);
typedef void (GLAD_API_PTR *PFNGLFRAMEBUFFERPARAMETERIPROC)(GLenum target, GLenum pname, GLint param);
typedef void (GLAD_API_PTR *PFNGLFRAMEBUFFERRENDERBUFFERPROC)(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
typedef void (GLAD_API_PTR *PFNGLFRAMEBUFFERTEXTUREPROC)(GLenum target, GLenum attachment, GLuint texture, GLint level);
typedef void (GLAD_API_PTR *PFNGLFRAMEBUFFERTEXTURE1DPROC)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
typedef void (GLAD_API_PTR *PFNGLFRAMEBUFFERTEXTURE2DPROC)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
typedef void (GLAD_API_PTR *PFNGLFRAMEBUFFERTEXTURE3DPROC)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset);
typedef void (GLAD_API_PTR *PFNGLFRAMEBUFFERTEXTURELAYERPROC)(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer);
typedef void (GLAD_API_PTR *PFNGLFRONTFACEPROC)(GLenum mode);
typedef void (GLAD_API_PTR *PFNGLFRUSTUMPROC)(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
typedef void (GLAD_API_PTR *PFNGLGENBUFFERSPROC)(GLsizei n, GLuint * buffers);
typedef void (GLAD_API_PTR *PFNGLGENFRAMEBUFFERSPROC)(GLsizei n, GLuint * framebuffers);
typedef GLuint (GLAD_API_PTR *PFNGLGENLISTSPROC)(GLsizei range);
typedef void (GLAD_API_PTR *PFNGLGENPROGRAMPIPELINESPROC)(GLsizei n, GLuint * pipelines);
typedef void (GLAD_API_PTR *PFNGLGENQUERIESPROC)(GLsizei n, GLuint * ids);
typedef void (GLAD_API_PTR *PFNGLGENRENDERBUFFERSPROC)(GLsizei n, GLuint * renderbuffers);
typedef void (GLAD_API_PTR *PFNGLGENSAMPLERSPROC)(GLsizei count, GLuint * samplers);
typedef void (GLAD_API_PTR *PFNGLGENTEXTURESPROC)(GLsizei n, GLuint * textures);
typedef void (GLAD_API_PTR *PFNGLGENTRANSFORMFEEDBACKSPROC)(GLsizei n, GLuint * ids);
typedef void (GLAD_API_PTR *PFNGLGENVERTEXARRAYSPROC)(GLsizei n, GLuint * arrays);
typedef void (GLAD_API_PTR *PFNGLGENERATEMIPMAPPROC)(GLenum target);
typedef void (GLAD_API_PTR *PFNGLGENERATETEXTUREMIPMAPPROC)(GLuint texture);
typedef void (GLAD_API_PTR *PFNGLGETACTIVEATOMICCOUNTERBUFFERIVPROC)(GLuint program, GLuint bufferIndex, GLenum pname, GLint * params);
typedef void (GLAD_API_PTR *PFNGLGETACTIVEATTRIBPROC)(GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLint * size, GLenum * type, GLchar * name);
typedef void (GLAD_API_PTR *PFNGLGETACTIVESUBROUTINENAMEPROC)(GLuint program, GLenum shadertype, GLuint index, GLsizei bufSize, GLsizei * length, GLchar * name);
typedef void (GLAD_API_PTR *PFNGLGETACTIVESUBROUTINEUNIFORMNAMEPROC)(GLuint program, GLenum shadertype, GLuint index, GLsizei bufSize, GLsizei * length, GLchar * name);
typedef void (GLAD_API_PTR *PFNGLGETACTIVESUBROUTINEUNIFORMIVPROC)(GLuint program, GLenum shadertype, GLuint index, GLenum pname, GLint * values);
typedef void (GLAD_API_PTR *PFNGLGETACTIVEUNIFORMPROC)(GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLint * size, GLenum * type, GLchar * name);
typedef void (GLAD_API_PTR *PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC)(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei * length, GLchar * uniformBlockName);
typedef void (GLAD_API_PTR *PFNGLGETACTIVEUNIFORMBLOCKIVPROC)(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint * params);
typedef void (GLAD_API_PTR *PFNGLGETACTIVEUNIFORMNAMEPROC)(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei * length, GLchar * uniformName);
typedef void (GLAD_API_PTR *PFNGLGETACTIVEUNIFORMSIVPROC)(GLuint program, GLsizei uniformCount, const GLuint * uniformIndices, GLenum pname, GLint * params);
typedef void (GLAD_API_PTR *PFNGLGETATTACHEDSHADERSPROC)(GLuint program, GLsizei maxCount, GLsizei * count, GLuint * shaders);
typedef GLint (GLAD_API_PTR *PFNGLGETATTRIBLOCATIONPROC)(GLuint program, const GLchar * name);
typedef void (GLAD_API_PTR *PFNGLGETBOOLEANI_VPROC)(GLenum target, GLuint index, GLboolean * data);
typedef void (GLAD_API_PTR *PFNGLGETBOOLEANVPROC)(GLenum pname, GLboolean * data);
typedef void (GLAD_API_PTR *PFNGLGETBUFFERPARAMETERI64VPROC)(GLenum target, GLenum pname, GLint64 * params);
typedef void (GLAD_API_PTR *PFNGLGETBUFFERPARAMETERIVPROC)(GLenum target, GLenum pname, GLint * params);
typedef void (GLAD_API_PTR *PFNGLGETBUFFERPOINTERVPROC)(GLenum target, GLenum pname, void ** params);
typedef void (GLAD_API_PTR *PFNGLGETBUFFERSUBDATAPROC)(GLenum target, GLintptr offset, GLsizeiptr size, void * data);
typedef void (GLAD_API_PTR *PFNGLGETCLIPPLANEPROC)(GLenum plane, GLdouble * equation);
typedef void (GLAD_API_PTR *PFNGLGETCOMPRESSEDTEXIMAGEPROC)(GLenum target, GLint level, void * img);
typedef void (GLAD_API_PTR *PFNGLGETCOMPRESSEDTEXTUREIMAGEPROC)(GLuint texture, GLint level, GLsizei bufSize, void * pixels);
typedef void (GLAD_API_PTR *PFNGLGETCOMPRESSEDTEXTURESUBIMAGEPROC)(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei bufSize, void * pixels);
typedef GLuint (GLAD_API_PTR *PFNGLGETDEBUGMESSAGELOGPROC)(GLuint count, GLsizei bufSize, GLenum * sources, GLenum * types, GLuint * ids, GLenum * severities, GLsizei * lengths, GLchar * messageLog);
typedef void (GLAD_API_PTR *PFNGLGETDOUBLEI_VPROC)(GLenum target, GLuint index, GLdouble * data);
typedef void (GLAD_API_PTR *PFNGLGETDOUBLEVPROC)(GLenum pname, GLdouble * data);
typedef GLenum (GLAD_API_PTR *PFNGLGETERRORPROC)(void);
typedef void (GLAD_API_PTR *PFNGLGETFLOATI_VPROC)(GLenum target, GLuint index, GLfloat * data);
typedef void (GLAD_API_PTR *PFNGLGETFLOATVPROC)(GLenum pname, GLfloat * data);
typedef GLint (GLAD_API_PTR *PFNGLGETFRAGDATAINDEXPROC)(GLuint program, const GLchar * name);
typedef GLint (GLAD_API_PTR *PFNGLGETFRAGDATALOCATIONPROC)(GLuint program, const GLchar * name);
typedef void (GLAD_API_PTR *PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC)(GLenum target, GLenum attachment, GLenum pname, GLint * params);
typedef void (GLAD_API_PTR *PFNGLGETFRAMEBUFFERPARAMETERIVPROC)(GLenum target, GLenum pname, GLint * params);
typedef GLenum (GLAD_API_PTR *PFNGLGETGRAPHICSRESETSTATUSPROC)(void);
typedef GLenum (GLAD_API_PTR *PFNGLGETGRAPHICSRESETSTATUSARBPROC)(void);
typedef void (GLAD_API_PTR *PFNGLGETINTEGER64I_VPROC)(GLenum target, GLuint index, GLint64 * data);
typedef void (GLAD_API_PTR *PFNGLGETINTEGER64VPROC)(GLenum pname, GLint64 * data);
typedef void (GLAD_API_PTR *PFNGLGETINTEGERI_VPROC)(GLenum target, GLuint index, GLint * data);
typedef void (GLAD_API_PTR *PFNGLGETINTEGERVPROC)(GLenum pname, GLint * data);
typedef void (GLAD_API_PTR *PFNGLGETINTERNALFORMATI64VPROC)(GLenum target, GLenum internalformat, GLenum pname, GLsizei count, GLint64 * params);
typedef void (GLAD_API_PTR *PFNGLGETINTERNALFORMATIVPROC)(GLenum target, GLenum internalformat, GLenum pname, GLsizei count, GLint * params);
typedef void (GLAD_API_PTR *PFNGLGETLIGHTFVPROC)(GLenum light, GLenum pname, GLfloat * params);
typedef void (GLAD_API_PTR *PFNGLGETLIGHTIVPROC)(GLenum light, GLenum pname, GLint * params);
typedef void (GLAD_API_PTR *PFNGLGETMAPDVPROC)(GLenum target, GLenum query, GLdouble * v);
typedef void (GLAD_API_PTR *PFNGLGETMAPFVPROC)(GLenum target, GLenum query, GLfloat * v);
typedef void (GLAD_API_PTR *PFNGLGETMAPIVPROC)(GLenum target, GLenum query, GLint * v);
typedef void (GLAD_API_PTR *PFNGLGETMATERIALFVPROC)(GLenum face, GLenum pname, GLfloat * params);
typedef void (GLAD_API_PTR *PFNGLGETMATERIALIVPROC)(GLenum face, GLenum pname, GLint * params);
typedef void (GLAD_API_PTR *PFNGLGETMULTISAMPLEFVPROC)(GLenum pname, GLuint index, GLfloat * val);
typedef void (GLAD_API_PTR *PFNGLGETNAMEDBUFFERPARAMETERI64VPROC)(GLuint buffer, GLenum pname, GLint64 * params);
typedef void (GLAD_API_PTR *PFNGLGETNAMEDBUFFERPARAMETERIVPROC)(GLuint buffer, GLenum pname, GLint * params);
typedef void (GLAD_API_PTR *PFNGLGETNAMEDBUFFERPOINTERVPROC)(GLuint buffer, GLenum pname, void ** params);
typedef void (GLAD_API_PTR *PFNGLGETNAMEDBUFFERSUBDATAPROC)(GLuint buffer, GLintptr offset, GLsizeiptr size, void * data);
typedef void (GLAD_API_PTR *PFNGLGETNAMEDFRAMEBUFFERATTACHMENTPARAMETERIVPROC)(GLuint framebuffer, GLenum attachment, GLenum pname, GLint * params);
typedef void (GLAD_API_PTR *PFNGLGETNAMEDFRAMEBUFFERPARAMETERIVPROC)(GLuint framebuffer, GLenum pname, GLint * param);
typedef void (GLAD_API_PTR *PFNGLGETNAMEDRENDERBUFFERPARAMETERIVPROC)(GLuint renderbuffer, GLenum pname, GLint * params);
typedef void (GLAD_API_PTR *PFNGLGETOBJECTLABELPROC)(GLenum identifier, GLuint name, GLsizei bufSize, GLsizei * length, GLchar * label);
typedef void (GLAD_API_PTR *PFNGLGETOBJECTPTRLABELPROC)(const void * ptr, GLsizei bufSize, GLsizei * length, GLchar * label);
typedef void (GLAD_API_PTR *PFNGLGETPIXELMAPFVPROC)(GLenum map, GLfloat * values);
typedef void (GLAD_API_PTR *PFNGLGETPIXELMAPUIVPROC)(GLenum map, GLuint * values);
typedef void (GLAD_API_PTR *PFNGLGETPIXELMAPUSVPROC)(GLenum map, GLushort * values);
typedef void (GLAD_API_PTR *PFNGLGETPOINTERVPROC)(GLenum pname, void ** params);
typedef void (GLAD_API_PTR *PFNGLGETPOLYGONSTIPPLEPROC)(GLubyte * mask);
typedef void (GLAD_API_PTR *PFNGLGETPROGRAMBINARYPROC)(GLuint program, GLsizei bufSize, GLsizei * length, GLenum * binaryFormat, void * binary);
typedef void (GLAD_API_PTR *PFNGLGETPROGRAMINFOLOGPROC)(GLuint program, GLsizei bufSize, GLsizei * length, GLchar * infoLog);
typedef void (GLAD_API_PTR *PFNGLGETPROGRAMINTERFACEIVPROC)(GLuint program, GLenum programInterface, GLenum pname, GLint * params);
typedef void (GLAD_API_PTR *PFNGLGETPROGRAMPIPELINEINFOLOGPROC)(GLuint pipeline, GLsizei bufSize, GLsizei * length, GLchar * infoLog);
typedef void (GLAD_API_PTR *PFNGLGETPROGRAMPIPELINEIVPROC)(GLuint pipeline, GLenum pname, GLint * params);
typedef GLuint (GLAD_API_PTR *PFNGLGETPROGRAMRESOURCEINDEXPROC)(GLuint program, GLenum programInterface, const GLchar * name);
typedef GLint (GLAD_API_PTR *PFNGLGETPROGRAMRESOURCELOCATIONPROC)(GLuint program, GLenum programInterface, const GLchar * name);
typedef GLint (GLAD_API_PTR *PFNGLGETPROGRAMRESOURCELOCATIONINDEXPROC)(GLuint program, GLenum programInterface, const GLchar * name);
typedef void (GLAD_API_PTR *PFNGLGETPROGRAMRESOURCENAMEPROC)(GLuint program, GLenum programInterface, GLuint index, GLsizei bufSize, GLsizei * length, GLchar * name);
typedef void (GLAD_API_PTR *PFNGLGETPROGRAMRESOURCEIVPROC)(GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum * props, GLsizei count, GLsizei * length, GLint * params);
typedef void (GLAD_API_PTR *PFNGLGETPROGRAMSTAGEIVPROC)(GLuint program, GLenum shadertype, GLenum pname, GLint * values);
typedef void (GLAD_API_PTR *PFNGLGETPROGRAMIVPROC)(GLuint program, GLenum pname, GLint * params);
typedef void (GLAD_API_PTR *PFNGLGETQUERYBUFFEROBJECTI64VPROC)(GLuint id, GLuint buffer, GLenum pname, GLintptr offset);
typedef void (GLAD_API_PTR *PFNGLGETQUERYBUFFEROBJECTIVPROC)(GLuint id, GLuint buffer, GLenum pname, GLintptr offset);
typedef void (GLAD_API_PTR *PFNGLGETQUERYBUFFEROBJECTUI64VPROC)(GLuint id, GLuint buffer, GLenum pname, GLintptr offset);
typedef void (GLAD_API_PTR *PFNGLGETQUERYBUFFEROBJECTUIVPROC)(GLuint id, GLuint buffer, GLenum pname, GLintptr offset);
typedef void (GLAD_API_PTR *PFNGLGETQUERYINDEXEDIVPROC)(GLenum target, GLuint index, GLenum pname, GLint * params);
typedef void (GLAD_API_PTR *PFNGLGETQUERYOBJECTI64VPROC)(GLuint id, GLenum pname, GLint64 * params);
typedef void (GLAD_API_PTR *PFNGLGETQUERYOBJECTIVPROC)(GLuint id, GLenum pname, GLint * params);
typedef void (GLAD_API_PTR *PFNGLGETQUERYOBJECTUI64VPROC)(GLuint id, GLenum pname, GLuint64 * params);
typedef void (GLAD_API_PTR *PFNGLGETQUERYOBJECTUIVPROC)(GLuint id, GLenum pname, GLuint * params);
typedef void (GLAD_API_PTR *PFNGLGETQUERYIVPROC)(GLenum target, GLenum pname, GLint * params);
typedef void (GLAD_API_PTR *PFNGLGETRENDERBUFFERPARAMETERIVPROC)(GLenum target, GLenum pname, GLint * params);
typedef void (GLAD_API_PTR *PFNGLGETSAMPLERPARAMETERIIVPROC)(GLuint sampler, GLenum pname, GLint * params);
typedef void (GLAD_API_PTR *PFNGLGETSAMPLERPARAMETERIUIVPROC)(GLuint sampler, GLenum pname, GLuint * params);
typedef void (GLAD_API_PTR *PFNGLGETSAMPLERPARAMETERFVPROC)(GLuint sampler, GLenum pname, GLfloat * params);
typedef void (GLAD_API_PTR *PFNGLGETSAMPLERPARAMETERIVPROC)(GLuint sampler, GLenum pname, GLint * params);
typedef void (GLAD_API_PTR *PFNGLGETSHADERINFOLOGPROC)(GLuint shader, GLsizei bufSize, GLsizei * length, GLchar * infoLog);
typedef void (GLAD_API_PTR *PFNGLGETSHADERPRECISIONFORMATPROC)(GLenum shadertype, GLenum precisiontype, GLint * range, GLint * precision);
typedef void (GLAD_API_PTR *PFNGLGETSHADERSOURCEPROC)(GLuint shader, GLsizei bufSize, GLsizei * length, GLchar * source);
typedef void (GLAD_API_PTR *PFNGLGETSHADERIVPROC)(GLuint shader, GLenum pname, GLint * params);
typedef const GLubyte * (GLAD_API_PTR *PFNGLGETSTRINGPROC)(GLenum name);
typedef const GLubyte * (GLAD_API_PTR *PFNGLGETSTRINGIPROC)(GLenum name, GLuint index);
typedef GLuint (GLAD_API_PTR *PFNGLGETSUBROUTINEINDEXPROC)(GLuint program, GLenum shadertype, const GLchar * name);
typedef GLint (GLAD_API_PTR *PFNGLGETSUBROUTINEUNIFORMLOCATIONPROC)(GLuint program, GLenum shadertype, const GLchar * name);
typedef void (GLAD_API_PTR *PFNGLGETSYNCIVPROC)(GLsync sync, GLenum pname, GLsizei count, GLsizei * length, GLint * values);
typedef void (GLAD_API_PTR *PFNGLGETTEXENVFVPROC)(GLenum target, GLenum pname, GLfloat * params);
typedef void (GLAD_API_PTR *PFNGLGETTEXENVIVPROC)(GLenum target, GLenum pname, GLint * params);
typedef void (GLAD_API_PTR *PFNGLGETTEXGENDVPROC)(GLenum coord, GLenum pname, GLdouble * params);
typedef void (GLAD_API_PTR *PFNGLGETTEXGENFVPROC)(GLenum coord, GLenum pname, GLfloat * params);
typedef void (GLAD_API_PTR *PFNGLGETTEXGENIVPROC)(GLenum coord, GLenum pname, GLint * params);
typedef void (GLAD_API_PTR *PFNGLGETTEXIMAGEPROC)(GLenum target, GLint level, GLenum format, GLenum type, void * pixels);
typedef void (GLAD_API_PTR *PFNGLGETTEXLEVELPARAMETERFVPROC)(GLenum target, GLint level, GLenum pname, GLfloat * params);
typedef void (GLAD_API_PTR *PFNGLGETTEXLEVELPARAMETERIVPROC)(GLenum target, GLint level, GLenum pname, GLint * params);
typedef void (GLAD_API_PTR *PFNGLGETTEXPARAMETERIIVPROC)(GLenum target, GLenum pname, GLint * params);
typedef void (GLAD_API_PTR *PFNGLGETTEXPARAMETERIUIVPROC)(GLenum target, GLenum pname, GLuint * params);
typedef void (GLAD_API_PTR *PFNGLGETTEXPARAMETERFVPROC)(GLenum target, GLenum pname, GLfloat * params);
typedef void (GLAD_API_PTR *PFNGLGETTEXPARAMETERIVPROC)(GLenum target, GLenum pname, GLint * params);
typedef void (GLAD_API_PTR *PFNGLGETTEXTUREIMAGEPROC)(GLuint texture, GLint level, GLenum format, GLenum type, GLsizei bufSize, void * pixels);
typedef void (GLAD_API_PTR *PFNGLGETTEXTURELEVELPARAMETERFVPROC)(GLuint texture, GLint level, GLenum pname, GLfloat * params);
typedef void (GLAD_API_PTR *PFNGLGETTEXTURELEVELPARAMETERIVPROC)(GLuint texture, GLint level, GLenum pname, GLint * params);
typedef void (GLAD_API_PTR *PFNGLGETTEXTUREPARAMETERIIVPROC)(GLuint texture, GLenum pname, GLint * params);
typedef void (GLAD_API_PTR *PFNGLGETTEXTUREPARAMETERIUIVPROC)(GLuint texture, GLenum pname, GLuint * params);
typedef void (GLAD_API_PTR *PFNGLGETTEXTUREPARAMETERFVPROC)(GLuint texture, GLenum pname, GLfloat * params);
typedef void (GLAD_API_PTR *PFNGLGETTEXTUREPARAMETERIVPROC)(GLuint texture, GLenum pname, GLint * params);
typedef void (GLAD_API_PTR *PFNGLGETTEXTURESUBIMAGEPROC)(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLsizei bufSize, void * pixels);
typedef void (GLAD_API_PTR *PFNGLGETTRANSFORMFEEDBACKVARYINGPROC)(GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLsizei * size, GLenum * type, GLchar * name);
typedef void (GLAD_API_PTR *PFNGLGETTRANSFORMFEEDBACKI64_VPROC)(GLuint xfb, GLenum pname, GLuint index, GLint64 * param);
typedef void (GLAD_API_PTR *PFNGLGETTRANSFORMFEEDBACKI_VPROC)(GLuint xfb, GLenum pname, GLuint index, GLint * param);
typedef void (GLAD_API_PTR *PFNGLGETTRANSFORMFEEDBACKIVPROC)(GLuint xfb, GLenum pname, GLint * param);
typedef GLuint (GLAD_API_PTR *PFNGLGETUNIFORMBLOCKINDEXPROC)(GLuint program, const GLchar * uniformBlockName);
typedef void (GLAD_API_PTR *PFNGLGETUNIFORMINDICESPROC)(GLuint program, GLsizei uniformCount, const GLchar *const* uniformNames, GLuint * uniformIndices);
typedef GLint (GLAD_API_PTR *PFNGLGETUNIFORMLOCATIONPROC)(GLuint program, const GLchar * name);
typedef void (GLAD_API_PTR *PFNGLGETUNIFORMSUBROUTINEUIVPROC)(GLenum shadertype, GLint location, GLuint * params);
typedef void (GLAD_API_PTR *PFNGLGETUNIFORMDVPROC)(GLuint program, GLint location, GLdouble * params);
typedef void (GLAD_API_PTR *PFNGLGETUNIFORMFVPROC)(GLuint program, GLint location, GLfloat * params);
typedef void (GLAD_API_PTR *PFNGLGETUNIFORMIVPROC)(GLuint program, GLint location, GLint * params);
typedef void (GLAD_API_PTR *PFNGLGETUNIFORMUIVPROC)(GLuint program, GLint location, GLuint * params);
typedef void (GLAD_API_PTR *PFNGLGETVERTEXARRAYINDEXED64IVPROC)(GLuint vaobj, GLuint index, GLenum pname, GLint64 * param);
typedef void (GLAD_API_PTR *PFNGLGETVERTEXARRAYINDEXEDIVPROC)(GLuint vaobj, GLuint index, GLenum pname, GLint * param);
typedef void (GLAD_API_PTR *PFNGLGETVERTEXARRAYIVPROC)(GLuint vaobj, GLenum pname, GLint * param);
typedef void (GLAD_API_PTR *PFNGLGETVERTEXATTRIBIIVPROC)(GLuint index, GLenum pname, GLint * params);
typedef void (GLAD_API_PTR *PFNGLGETVERTEXATTRIBIUIVPROC)(GLuint index, GLenum pname, GLuint * params);
typedef void (GLAD_API_PTR *PFNGLGETVERTEXATTRIBLDVPROC)(GLuint index, GLenum pname, GLdouble * params);
typedef void (GLAD_API_PTR *PFNGLGETVERTEXATTRIBPOINTERVPROC)(GLuint index, GLenum pname, void ** pointer);
typedef void (GLAD_API_PTR *PFNGLGETVERTEXATTRIBDVPROC)(GLuint index, GLenum pname, GLdouble * params);
typedef void (GLAD_API_PTR *PFNGLGETVERTEXATTRIBFVPROC)(GLuint index, GLenum pname, GLfloat * params);
typedef void (GLAD_API_PTR *PFNGLGETVERTEXATTRIBIVPROC)(GLuint index, GLenum pname, GLint * params);
typedef void (GLAD_API_PTR *PFNGLGETNCOLORTABLEPROC)(GLenum target, GLenum format, GLenum type, GLsizei bufSize, void * table);
typedef void (GLAD_API_PTR *PFNGLGETNCOLORTABLEARBPROC)(GLenum target, GLenum format, GLenum type, GLsizei bufSize, void * table);
typedef void (GLAD_API_PTR *PFNGLGETNCOMPRESSEDTEXIMAGEPROC)(GLenum target, GLint lod, GLsizei bufSize, void * pixels);
typedef void (GLAD_API_PTR *PFNGLGETNCOMPRESSEDTEXIMAGEARBPROC)(GLenum target, GLint lod, GLsizei bufSize, void * img);
typedef void (GLAD_API_PTR *PFNGLGETNCONVOLUTIONFILTERPROC)(GLenum target, GLenum format, GLenum type, GLsizei bufSize, void * image);
typedef void (GLAD_API_PTR *PFNGLGETNCONVOLUTIONFILTERARBPROC)(GLenum target, GLenum format, GLenum type, GLsizei bufSize, void * image);
typedef void (GLAD_API_PTR *PFNGLGETNHISTOGRAMPROC)(GLenum target, GLboolean reset, GLenum format, GLenum type, GLsizei bufSize, void * values);
typedef void (GLAD_API_PTR *PFNGLGETNHISTOGRAMARBPROC)(GLenum target, GLboolean reset, GLenum format, GLenum type, GLsizei bufSize, void * values);
typedef void (GLAD_API_PTR *PFNGLGETNMAPDVPROC)(GLenum target, GLenum query, GLsizei bufSize, GLdouble * v);
typedef void (GLAD_API_PTR *PFNGLGETNMAPDVARBPROC)(GLenum target, GLenum query, GLsizei bufSize, GLdouble * v);
typedef void (GLAD_API_PTR *PFNGLGETNMAPFVPROC)(GLenum target, GLenum query, GLsizei bufSize, GLfloat * v);
typedef void (GLAD_API_PTR *PFNGLGETNMAPFVARBPROC)(GLenum target, GLenum query, GLsizei bufSize, GLfloat * v);
typedef void (GLAD_API_PTR *PFNGLGETNMAPIVPROC)(GLenum target, GLenum query, GLsizei bufSize, GLint * v);
typedef void (GLAD_API_PTR *PFNGLGETNMAPIVARBPROC)(GLenum target, GLenum query, GLsizei bufSize, GLint * v);
typedef void (GLAD_API_PTR *PFNGLGETNMINMAXPROC)(GLenum target, GLboolean reset, GLenum format, GLenum type, GLsizei bufSize, void * values);
typedef void (GLAD_API_PTR *PFNGLGETNMINMAXARBPROC)(GLenum target, GLboolean reset, GLenum format, GLenum type, GLsizei bufSize, void * values);
typedef void (GLAD_API_PTR *PFNGLGETNPIXELMAPFVPROC)(GLenum map, GLsizei bufSize, GLfloat * values);
typedef void (GLAD_API_PTR *PFNGLGETNPIXELMAPFVARBPROC)(GLenum map, GLsizei bufSize, GLfloat * values);
typedef void (GLAD_API_PTR *PFNGLGETNPIXELMAPUIVPROC)(GLenum map, GLsizei bufSize, GLuint * values);
typedef void (GLAD_API_PTR *PFNGLGETNPIXELMAPUIVARBPROC)(GLenum map, GLsizei bufSize, GLuint * values);
typedef void (GLAD_API_PTR *PFNGLGETNPIXELMAPUSVPROC)(GLenum map, GLsizei bufSize, GLushort * values);
typedef void (GLAD_API_PTR *PFNGLGETNPIXELMAPUSVARBPROC)(GLenum map, GLsizei bufSize, GLushort * values);
typedef void (GLAD_API_PTR *PFNGLGETNPOLYGONSTIPPLEPROC)(GLsizei bufSize, GLubyte * pattern);
typedef void (GLAD_API_PTR *PFNGLGETNPOLYGONSTIPPLEARBPROC)(GLsizei bufSize, GLubyte * pattern);
typedef void (GLAD_API_PTR *PFNGLGETNSEPARABLEFILTERPROC)(GLenum target, GLenum format, GLenum type, GLsizei rowBufSize, void * row, GLsizei columnBufSize, void * column, void * span);
typedef void (GLAD_API_PTR *PFNGLGETNSEPARABLEFILTERARBPROC)(GLenum target, GLenum format, GLenum type, GLsizei rowBufSize, void * row, GLsizei columnBufSize, void * column, void * span);
typedef void (GLAD_API_PTR *PFNGLGETNTEXIMAGEPROC)(GLenum target, GLint level, GLenum format, GLenum type, GLsizei bufSize, void * pixels);
typedef void (GLAD_API_PTR *PFNGLGETNTEXIMAGEARBPROC)(GLenum target, GLint level, GLenum format, GLenum type, GLsizei bufSize, void * img);
typedef void (GLAD_API_PTR *PFNGLGETNUNIFORMDVPROC)(GLuint program, GLint location, GLsizei bufSize, GLdouble * params);
typedef void (GLAD_API_PTR *PFNGLGETNUNIFORMDVARBPROC)(GLuint program, GLint location, GLsizei bufSize, GLdouble * params);
typedef void (GLAD_API_PTR *PFNGLGETNUNIFORMFVPROC)(GLuint program, GLint location, GLsizei bufSize, GLfloat * params);
typedef void (GLAD_API_PTR *PFNGLGETNUNIFORMFVARBPROC)(GLuint program, GLint location, GLsizei bufSize, GLfloat * params);
typedef void (GLAD_API_PTR *PFNGLGETNUNIFORMIVPROC)(GLuint program, GLint location, GLsizei bufSize, GLint * params);
typedef void (GLAD_API_PTR *PFNGLGETNUNIFORMIVARBPROC)(GLuint program, GLint location, GLsizei bufSize, GLint * params);
typedef void (GLAD_API_PTR *PFNGLGETNUNIFORMUIVPROC)(GLuint program, GLint location, GLsizei bufSize, GLuint * params);
typedef void (GLAD_API_PTR *PFNGLGETNUNIFORMUIVARBPROC)(GLuint program, GLint location, GLsizei bufSize, GLuint * params);
typedef void (GLAD_API_PTR *PFNGLHINTPROC)(GLenum target, GLenum mode);
typedef void (GLAD_API_PTR *PFNGLINDEXMASKPROC)(GLuint mask);
typedef void (GLAD_API_PTR *PFNGLINDEXPOINTERPROC)(GLenum type, GLsizei stride, const void * pointer);
typedef void (GLAD_API_PTR *PFNGLINDEXDPROC)(GLdouble c);
typedef void (GLAD_API_PTR *PFNGLINDEXDVPROC)(const GLdouble * c);
typedef void (GLAD_API_PTR *PFNGLINDEXFPROC)(GLfloat c);
typedef void (GLAD_API_PTR *PFNGLINDEXFVPROC)(const GLfloat * c);
typedef void (GLAD_API_PTR *PFNGLINDEXIPROC)(GLint c);
typedef void (GLAD_API_PTR *PFNGLINDEXIVPROC)(const GLint * c);
typedef void (GLAD_API_PTR *PFNGLINDEXSPROC)(GLshort c);
typedef void (GLAD_API_PTR *PFNGLINDEXSVPROC)(const GLshort * c);
typedef void (GLAD_API_PTR *PFNGLINDEXUBPROC)(GLubyte c);
typedef void (GLAD_API_PTR *PFNGLINDEXUBVPROC)(const GLubyte * c);
typedef void (GLAD_API_PTR *PFNGLINITNAMESPROC)(void);
typedef void (GLAD_API_PTR *PFNGLINTERLEAVEDARRAYSPROC)(GLenum format, GLsizei stride, const void * pointer);
typedef void (GLAD_API_PTR *PFNGLINVALIDATEBUFFERDATAPROC)(GLuint buffer);
typedef void (GLAD_API_PTR *PFNGLINVALIDATEBUFFERSUBDATAPROC)(GLuint buffer, GLintptr offset, GLsizeiptr length);
typedef void (GLAD_API_PTR *PFNGLINVALIDATEFRAMEBUFFERPROC)(GLenum target, GLsizei numAttachments, const GLenum * attachments);
typedef void (GLAD_API_PTR *PFNGLINVALIDATENAMEDFRAMEBUFFERDATAPROC)(GLuint framebuffer, GLsizei numAttachments, const GLenum * attachments);
typedef void (GLAD_API_PTR *PFNGLINVALIDATENAMEDFRAMEBUFFERSUBDATAPROC)(GLuint framebuffer, GLsizei numAttachments, const GLenum * attachments, GLint x, GLint y, GLsizei width, GLsizei height);
typedef void (GLAD_API_PTR *PFNGLINVALIDATESUBFRAMEBUFFERPROC)(GLenum target, GLsizei numAttachments, const GLenum * attachments, GLint x, GLint y, GLsizei width, GLsizei height);
typedef void (GLAD_API_PTR *PFNGLINVALIDATETEXIMAGEPROC)(GLuint texture, GLint level);
typedef void (GLAD_API_PTR *PFNGLINVALIDATETEXSUBIMAGEPROC)(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth);
typedef GLboolean (GLAD_API_PTR *PFNGLISBUFFERPROC)(GLuint buffer);
typedef GLboolean (GLAD_API_PTR *PFNGLISENABLEDPROC)(GLenum cap);
typedef GLboolean (GLAD_API_PTR *PFNGLISENABLEDIPROC)(GLenum target, GLuint index);
typedef GLboolean (GLAD_API_PTR *PFNGLISFRAMEBUFFERPROC)(GLuint framebuffer);
typedef GLboolean (GLAD_API_PTR *PFNGLISLISTPROC)(GLuint list);
typedef GLboolean (GLAD_API_PTR *PFNGLISPROGRAMPROC)(GLuint program);
typedef GLboolean (GLAD_API_PTR *PFNGLISPROGRAMPIPELINEPROC)(GLuint pipeline);
typedef GLboolean (GLAD_API_PTR *PFNGLISQUERYPROC)(GLuint id);
typedef GLboolean (GLAD_API_PTR *PFNGLISRENDERBUFFERPROC)(GLuint renderbuffer);
typedef GLboolean (GLAD_API_PTR *PFNGLISSAMPLERPROC)(GLuint sampler);
typedef GLboolean (GLAD_API_PTR *PFNGLISSHADERPROC)(GLuint shader);
typedef GLboolean (GLAD_API_PTR *PFNGLISSYNCPROC)(GLsync sync);
typedef GLboolean (GLAD_API_PTR *PFNGLISTEXTUREPROC)(GLuint texture);
typedef GLboolean (GLAD_API_PTR *PFNGLISTRANSFORMFEEDBACKPROC)(GLuint id);
typedef GLboolean (GLAD_API_PTR *PFNGLISVERTEXARRAYPROC)(GLuint array);
typedef void (GLAD_API_PTR *PFNGLLIGHTMODELFPROC)(GLenum pname, GLfloat param);
typedef void (GLAD_API_PTR *PFNGLLIGHTMODELFVPROC)(GLenum pname, const GLfloat * params);
typedef void (GLAD_API_PTR *PFNGLLIGHTMODELIPROC)(GLenum pname, GLint param);
typedef void (GLAD_API_PTR *PFNGLLIGHTMODELIVPROC)(GLenum pname, const GLint * params);
typedef void (GLAD_API_PTR *PFNGLLIGHTFPROC)(GLenum light, GLenum pname, GLfloat param);
typedef void (GLAD_API_PTR *PFNGLLIGHTFVPROC)(GLenum light, GLenum pname, const GLfloat * params);
typedef void (GLAD_API_PTR *PFNGLLIGHTIPROC)(GLenum light, GLenum pname, GLint param);
typedef void (GLAD_API_PTR *PFNGLLIGHTIVPROC)(GLenum light, GLenum pname, const GLint * params);
typedef void (GLAD_API_PTR *PFNGLLINESTIPPLEPROC)(GLint factor, GLushort pattern);
typedef void (GLAD_API_PTR *PFNGLLINEWIDTHPROC)(GLfloat width);
typedef void (GLAD_API_PTR *PFNGLLINKPROGRAMPROC)(GLuint program);
typedef void (GLAD_API_PTR *PFNGLLISTBASEPROC)(GLuint base);
typedef void (GLAD_API_PTR *PFNGLLOADIDENTITYPROC)(void);
typedef void (GLAD_API_PTR *PFNGLLOADMATRIXDPROC)(const GLdouble * m);
typedef void (GLAD_API_PTR *PFNGLLOADMATRIXFPROC)(const GLfloat * m);
typedef void (GLAD_API_PTR *PFNGLLOADNAMEPROC)(GLuint name);
typedef void (GLAD_API_PTR *PFNGLLOADTRANSPOSEMATRIXDPROC)(const GLdouble * m);
typedef void (GLAD_API_PTR *PFNGLLOADTRANSPOSEMATRIXFPROC)(const GLfloat * m);
typedef void (GLAD_API_PTR *PFNGLLOGICOPPROC)(GLenum opcode);
typedef void (GLAD_API_PTR *PFNGLMAP1DPROC)(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble * points);
typedef void (GLAD_API_PTR *PFNGLMAP1FPROC)(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat * points);
typedef void (GLAD_API_PTR *PFNGLMAP2DPROC)(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble * points);
typedef void (GLAD_API_PTR *PFNGLMAP2FPROC)(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat * points);
typedef void * (GLAD_API_PTR *PFNGLMAPBUFFERPROC)(GLenum target, GLenum access);
typedef void * (GLAD_API_PTR *PFNGLMAPBUFFERRANGEPROC)(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access);
typedef void (GLAD_API_PTR *PFNGLMAPGRID1DPROC)(GLint un, GLdouble u1, GLdouble u2);
typedef void (GLAD_API_PTR *PFNGLMAPGRID1FPROC)(GLint un, GLfloat u1, GLfloat u2);
typedef void (GLAD_API_PTR *PFNGLMAPGRID2DPROC)(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2);
typedef void (GLAD_API_PTR *PFNGLMAPGRID2FPROC)(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2);
typedef void * (GLAD_API_PTR *PFNGLMAPNAMEDBUFFERPROC)(GLuint buffer, GLenum access);
typedef void * (GLAD_API_PTR *PFNGLMAPNAMEDBUFFERRANGEPROC)(GLuint buffer, GLintptr offset, GLsizeiptr length, GLbitfield access);
typedef void (GLAD_API_PTR *PFNGLMATERIALFPROC)(GLenum face, GLenum pname, GLfloat param);
typedef void (GLAD_API_PTR *PFNGLMATERIALFVPROC)(GLenum face, GLenum pname, const GLfloat * params);
typedef void (GLAD_API_PTR *PFNGLMATERIALIPROC)(GLenum face, GLenum pname, GLint param);
typedef void (GLAD_API_PTR *PFNGLMATERIALIVPROC)(GLenum face, GLenum pname, const GLint * params);
typedef void (GLAD_API_PTR *PFNGLMATRIXMODEPROC)(GLenum mode);
typedef void (GLAD_API_PTR *PFNGLMEMORYBARRIERPROC)(GLbitfield barriers);
typedef void (GLAD_API_PTR *PFNGLMEMORYBARRIERBYREGIONPROC)(GLbitfield barriers);
typedef void (GLAD_API_PTR *PFNGLMINSAMPLESHADINGPROC)(GLfloat value);
typedef void (GLAD_API_PTR *PFNGLMULTMATRIXDPROC)(const GLdouble * m);
typedef void (GLAD_API_PTR *PFNGLMULTMATRIXFPROC)(const GLfloat * m);
typedef void (GLAD_API_PTR *PFNGLMULTTRANSPOSEMATRIXDPROC)(const GLdouble * m);
typedef void (GLAD_API_PTR *PFNGLMULTTRANSPOSEMATRIXFPROC)(const GLfloat * m);
typedef void (GLAD_API_PTR *PFNGLMULTIDRAWARRAYSPROC)(GLenum mode, const GLint * first, const GLsizei * count, GLsizei drawcount);
typedef void (GLAD_API_PTR *PFNGLMULTIDRAWARRAYSINDIRECTPROC)(GLenum mode, const void * indirect, GLsizei drawcount, GLsizei stride);
typedef void (GLAD_API_PTR *PFNGLMULTIDRAWARRAYSINDIRECTCOUNTPROC)(GLenum mode, const void * indirect, GLintptr drawcount, GLsizei maxdrawcount, GLsizei stride);
typedef void (GLAD_API_PTR *PFNGLMULTIDRAWELEMENTSPROC)(GLenum mode, const GLsizei * count, GLenum type, const void *const* indices, GLsizei drawcount);
typedef void (GLAD_API_PTR *PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC)(GLenum mode, const GLsizei * count, GLenum type, const void *const* indices, GLsizei drawcount, const GLint * basevertex);
typedef void (GLAD_API_PTR *PFNGLMULTIDRAWELEMENTSINDIRECTPROC)(GLenum mode, GLenum type, const void * indirect, GLsizei drawcount, GLsizei stride);
typedef void (GLAD_API_PTR *PFNGLMULTIDRAWELEMENTSINDIRECTCOUNTPROC)(GLenum mode, GLenum type, const void * indirect, GLintptr drawcount, GLsizei maxdrawcount, GLsizei stride);
typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD1DPROC)(GLenum target, GLdouble s);
typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD1DVPROC)(GLenum target, const GLdouble * v);
typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD1FPROC)(GLenum target, GLfloat s);
typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD1FVPROC)(GLenum target, const GLfloat * v);
typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD1IPROC)(GLenum target, GLint s);
typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD1IVPROC)(GLenum target, const GLint * v);
typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD1SPROC)(GLenum target, GLshort s);
typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD1SVPROC)(GLenum target, const GLshort * v);
typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD2DPROC)(GLenum target, GLdouble s, GLdouble t);
typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD2DVPROC)(GLenum target, const GLdouble * v);
typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD2FPROC)(GLenum target, GLfloat s, GLfloat t);
typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD2FVPROC)(GLenum target, const GLfloat * v);
typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD2IPROC)(GLenum target, GLint s, GLint t);
typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD2IVPROC)(GLenum target, const GLint * v);
typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD2SPROC)(GLenum target, GLshort s, GLshort t);
typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD2SVPROC)(GLenum target, const GLshort * v);
typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD3DPROC)(GLenum target, GLdouble s, GLdouble t, GLdouble r);
typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD3DVPROC)(GLenum target, const GLdouble * v);
typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD3FPROC)(GLenum target, GLfloat s, GLfloat t, GLfloat r);
typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD3FVPROC)(GLenum target, const GLfloat * v);
typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD3IPROC)(GLenum target, GLint s, GLint t, GLint r);
typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD3IVPROC)(GLenum target, const GLint * v);
typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD3SPROC)(GLenum target, GLshort s, GLshort t, GLshort r);
typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD3SVPROC)(GLenum target, const GLshort * v);
typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD4DPROC)(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q);
typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD4DVPROC)(GLenum target, const GLdouble * v);
typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD4FPROC)(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q);
typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD4FVPROC)(GLenum target, const GLfloat * v);
typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD4IPROC)(GLenum target, GLint s, GLint t, GLint r, GLint q);
typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD4IVPROC)(GLenum target, const GLint * v);
typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD4SPROC)(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q);
typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORD4SVPROC)(GLenum target, const GLshort * v);
typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORDP1UIPROC)(GLenum texture, GLenum type, GLuint coords);
typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORDP1UIVPROC)(GLenum texture, GLenum type, const GLuint * coords);
typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORDP2UIPROC)(GLenum texture, GLenum type, GLuint coords);
typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORDP2UIVPROC)(GLenum texture, GLenum type, const GLuint * coords);
typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORDP3UIPROC)(GLenum texture, GLenum type, GLuint coords);
typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORDP3UIVPROC)(GLenum texture, GLenum type, const GLuint * coords);
typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORDP4UIPROC)(GLenum texture, GLenum type, GLuint coords);
typedef void (GLAD_API_PTR *PFNGLMULTITEXCOORDP4UIVPROC)(GLenum texture, GLenum type, const GLuint * coords);
typedef void (GLAD_API_PTR *PFNGLNAMEDBUFFERDATAPROC)(GLuint buffer, GLsizeiptr size, const void * data, GLenum usage);
typedef void (GLAD_API_PTR *PFNGLNAMEDBUFFERSTORAGEPROC)(GLuint buffer, GLsizeiptr size, const void * data, GLbitfield flags);
typedef void (GLAD_API_PTR *PFNGLNAMEDBUFFERSUBDATAPROC)(GLuint buffer, GLintptr offset, GLsizeiptr size, const void * data);
typedef void (GLAD_API_PTR *PFNGLNAMEDFRAMEBUFFERDRAWBUFFERPROC)(GLuint framebuffer, GLenum buf);
typedef void (GLAD_API_PTR *PFNGLNAMEDFRAMEBUFFERDRAWBUFFERSPROC)(GLuint framebuffer, GLsizei n, const GLenum * bufs);
typedef void (GLAD_API_PTR *PFNGLNAMEDFRAMEBUFFERPARAMETERIPROC)(GLuint framebuffer, GLenum pname, GLint param);
typedef void (GLAD_API_PTR *PFNGLNAMEDFRAMEBUFFERREADBUFFERPROC)(GLuint framebuffer, GLenum src);
typedef void (GLAD_API_PTR *PFNGLNAMEDFRAMEBUFFERRENDERBUFFERPROC)(GLuint framebuffer, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
typedef void (GLAD_API_PTR *PFNGLNAMEDFRAMEBUFFERTEXTUREPROC)(GLuint framebuffer, GLenum attachment, GLuint texture, GLint level);
typedef void (GLAD_API_PTR *PFNGLNAMEDFRAMEBUFFERTEXTURELAYERPROC)(GLuint framebuffer, GLenum attachment, GLuint texture, GLint level, GLint layer);
typedef void (GLAD_API_PTR *PFNGLNAMEDRENDERBUFFERSTORAGEPROC)(GLuint renderbuffer, GLenum internalformat, GLsizei width, GLsizei height);
typedef void (GLAD_API_PTR *PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLEPROC)(GLuint renderbuffer, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height);
typedef void (GLAD_API_PTR *PFNGLNEWLISTPROC)(GLuint list, GLenum mode);
typedef void (GLAD_API_PTR *PFNGLNORMAL3BPROC)(GLbyte nx, GLbyte ny, GLbyte nz);
typedef void (GLAD_API_PTR *PFNGLNORMAL3BVPROC)(const GLbyte * v);
typedef void (GLAD_API_PTR *PFNGLNORMAL3DPROC)(GLdouble nx, GLdouble ny, GLdouble nz);
typedef void (GLAD_API_PTR *PFNGLNORMAL3DVPROC)(const GLdouble * v);
typedef void (GLAD_API_PTR *PFNGLNORMAL3FPROC)(GLfloat nx, GLfloat ny, GLfloat nz);
typedef void (GLAD_API_PTR *PFNGLNORMAL3FVPROC)(const GLfloat * v);
typedef void (GLAD_API_PTR *PFNGLNORMAL3IPROC)(GLint nx, GLint ny, GLint nz);
typedef void (GLAD_API_PTR *PFNGLNORMAL3IVPROC)(const GLint * v);
typedef void (GLAD_API_PTR *PFNGLNORMAL3SPROC)(GLshort nx, GLshort ny, GLshort nz);
typedef void (GLAD_API_PTR *PFNGLNORMAL3SVPROC)(const GLshort * v);
typedef void (GLAD_API_PTR *PFNGLNORMALP3UIPROC)(GLenum type, GLuint coords);
typedef void (GLAD_API_PTR *PFNGLNORMALP3UIVPROC)(GLenum type, const GLuint * coords);
typedef void (GLAD_API_PTR *PFNGLNORMALPOINTERPROC)(GLenum type, GLsizei stride, const void * pointer);
typedef void (GLAD_API_PTR *PFNGLOBJECTLABELPROC)(GLenum identifier, GLuint name, GLsizei length, const GLchar * label);
typedef void (GLAD_API_PTR *PFNGLOBJECTPTRLABELPROC)(const void * ptr, GLsizei length, const GLchar * label);
typedef void (GLAD_API_PTR *PFNGLORTHOPROC)(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
typedef void (GLAD_API_PTR *PFNGLPASSTHROUGHPROC)(GLfloat token);
typedef void (GLAD_API_PTR *PFNGLPATCHPARAMETERFVPROC)(GLenum pname, const GLfloat * values);
typedef void (GLAD_API_PTR *PFNGLPATCHPARAMETERIPROC)(GLenum pname, GLint value);
typedef void (GLAD_API_PTR *PFNGLPAUSETRANSFORMFEEDBACKPROC)(void);
typedef void (GLAD_API_PTR *PFNGLPIXELMAPFVPROC)(GLenum map, GLsizei mapsize, const GLfloat * values);
typedef void (GLAD_API_PTR *PFNGLPIXELMAPUIVPROC)(GLenum map, GLsizei mapsize, const GLuint * values);
typedef void (GLAD_API_PTR *PFNGLPIXELMAPUSVPROC)(GLenum map, GLsizei mapsize, const GLushort * values);
typedef void (GLAD_API_PTR *PFNGLPIXELSTOREFPROC)(GLenum pname, GLfloat param);
typedef void (GLAD_API_PTR *PFNGLPIXELSTOREIPROC)(GLenum pname, GLint param);
typedef void (GLAD_API_PTR *PFNGLPIXELTRANSFERFPROC)(GLenum pname, GLfloat param);
typedef void (GLAD_API_PTR *PFNGLPIXELTRANSFERIPROC)(GLenum pname, GLint param);
typedef void (GLAD_API_PTR *PFNGLPIXELZOOMPROC)(GLfloat xfactor, GLfloat yfactor);
typedef void (GLAD_API_PTR *PFNGLPOINTPARAMETERFPROC)(GLenum pname, GLfloat param);
typedef void (GLAD_API_PTR *PFNGLPOINTPARAMETERFVPROC)(GLenum pname, const GLfloat * params);
typedef void (GLAD_API_PTR *PFNGLPOINTPARAMETERIPROC)(GLenum pname, GLint param);
typedef void (GLAD_API_PTR *PFNGLPOINTPARAMETERIVPROC)(GLenum pname, const GLint * params);
typedef void (GLAD_API_PTR *PFNGLPOINTSIZEPROC)(GLfloat size);
typedef void (GLAD_API_PTR *PFNGLPOLYGONMODEPROC)(GLenum face, GLenum mode);
typedef void (GLAD_API_PTR *PFNGLPOLYGONOFFSETPROC)(GLfloat factor, GLfloat units);
typedef void (GLAD_API_PTR *PFNGLPOLYGONOFFSETCLAMPPROC)(GLfloat factor, GLfloat units, GLfloat clamp);
typedef void (GLAD_API_PTR *PFNGLPOLYGONSTIPPLEPROC)(const GLubyte * mask);
typedef void (GLAD_API_PTR *PFNGLPOPATTRIBPROC)(void);
typedef void (GLAD_API_PTR *PFNGLPOPCLIENTATTRIBPROC)(void);
typedef void (GLAD_API_PTR *PFNGLPOPDEBUGGROUPPROC)(void);
typedef void (GLAD_API_PTR *PFNGLPOPMATRIXPROC)(void);
typedef void (GLAD_API_PTR *PFNGLPOPNAMEPROC)(void);
typedef void (GLAD_API_PTR *PFNGLPRIMITIVERESTARTINDEXPROC)(GLuint index);
typedef void (GLAD_API_PTR *PFNGLPRIORITIZETEXTURESPROC)(GLsizei n, const GLuint * textures, const GLfloat * priorities);
typedef void (GLAD_API_PTR *PFNGLPROGRAMBINARYPROC)(GLuint program, GLenum binaryFormat, const void * binary, GLsizei length);
typedef void (GLAD_API_PTR *PFNGLPROGRAMPARAMETERIPROC)(GLuint program, GLenum pname, GLint value);
typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORM1DPROC)(GLuint program, GLint location, GLdouble v0);
typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORM1DVPROC)(GLuint program, GLint location, GLsizei count, const GLdouble * value);
typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORM1FPROC)(GLuint program, GLint location, GLfloat v0);
typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORM1FVPROC)(GLuint program, GLint location, GLsizei count, const GLfloat * value);
typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORM1IPROC)(GLuint program, GLint location, GLint v0);
typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORM1IVPROC)(GLuint program, GLint location, GLsizei count, const GLint * value);
typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORM1UIPROC)(GLuint program, GLint location, GLuint v0);
typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORM1UIVPROC)(GLuint program, GLint location, GLsizei count, const GLuint * value);
typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORM2DPROC)(GLuint program, GLint location, GLdouble v0, GLdouble v1);
typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORM2DVPROC)(GLuint program, GLint location, GLsizei count, const GLdouble * value);
typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORM2FPROC)(GLuint program, GLint location, GLfloat v0, GLfloat v1);
typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORM2FVPROC)(GLuint program, GLint location, GLsizei count, const GLfloat * value);
typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORM2IPROC)(GLuint program, GLint location, GLint v0, GLint v1);
typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORM2IVPROC)(GLuint program, GLint location, GLsizei count, const GLint * value);
typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORM2UIPROC)(GLuint program, GLint location, GLuint v0, GLuint v1);
typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORM2UIVPROC)(GLuint program, GLint location, GLsizei count, const GLuint * value);
typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORM3DPROC)(GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2);
typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORM3DVPROC)(GLuint program, GLint location, GLsizei count, const GLdouble * value);
typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORM3FPROC)(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORM3FVPROC)(GLuint program, GLint location, GLsizei count, const GLfloat * value);
typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORM3IPROC)(GLuint program, GLint location, GLint v0, GLint v1, GLint v2);
typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORM3IVPROC)(GLuint program, GLint location, GLsizei count, const GLint * value);
typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORM3UIPROC)(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2);
typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORM3UIVPROC)(GLuint program, GLint location, GLsizei count, const GLuint * value);
typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORM4DPROC)(GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3);
typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORM4DVPROC)(GLuint program, GLint location, GLsizei count, const GLdouble * value);
typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORM4FPROC)(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORM4FVPROC)(GLuint program, GLint location, GLsizei count, const GLfloat * value);
typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORM4IPROC)(GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3);
typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORM4IVPROC)(GLuint program, GLint location, GLsizei count, const GLint * value);
typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORM4UIPROC)(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3);
typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORM4UIVPROC)(GLuint program, GLint location, GLsizei count, const GLuint * value);
typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORMMATRIX2DVPROC)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value);
typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORMMATRIX2FVPROC)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value);
typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORMMATRIX2X3DVPROC)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value);
typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORMMATRIX2X3FVPROC)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value);
typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORMMATRIX2X4DVPROC)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value);
typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORMMATRIX2X4FVPROC)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value);
typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORMMATRIX3DVPROC)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value);
typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORMMATRIX3FVPROC)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value);
typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORMMATRIX3X2DVPROC)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value);
typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORMMATRIX3X2FVPROC)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value);
typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORMMATRIX3X4DVPROC)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value);
typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORMMATRIX3X4FVPROC)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value);
typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORMMATRIX4DVPROC)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value);
typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORMMATRIX4FVPROC)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value);
typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORMMATRIX4X2DVPROC)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value);
typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORMMATRIX4X2FVPROC)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value);
typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORMMATRIX4X3DVPROC)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value);
typedef void (GLAD_API_PTR *PFNGLPROGRAMUNIFORMMATRIX4X3FVPROC)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value);
typedef void (GLAD_API_PTR *PFNGLPROVOKINGVERTEXPROC)(GLenum mode);
typedef void (GLAD_API_PTR *PFNGLPUSHATTRIBPROC)(GLbitfield mask);
typedef void (GLAD_API_PTR *PFNGLPUSHCLIENTATTRIBPROC)(GLbitfield mask);
typedef void (GLAD_API_PTR *PFNGLPUSHDEBUGGROUPPROC)(GLenum source, GLuint id, GLsizei length, const GLchar * message);
typedef void (GLAD_API_PTR *PFNGLPUSHMATRIXPROC)(void);
typedef void (GLAD_API_PTR *PFNGLPUSHNAMEPROC)(GLuint name);
typedef void (GLAD_API_PTR *PFNGLQUERYCOUNTERPROC)(GLuint id, GLenum target);
typedef void (GLAD_API_PTR *PFNGLRASTERPOS2DPROC)(GLdouble x, GLdouble y);
typedef void (GLAD_API_PTR *PFNGLRASTERPOS2DVPROC)(const GLdouble * v);
typedef void (GLAD_API_PTR *PFNGLRASTERPOS2FPROC)(GLfloat x, GLfloat y);
typedef void (GLAD_API_PTR *PFNGLRASTERPOS2FVPROC)(const GLfloat * v);
typedef void (GLAD_API_PTR *PFNGLRASTERPOS2IPROC)(GLint x, GLint y);
typedef void (GLAD_API_PTR *PFNGLRASTERPOS2IVPROC)(const GLint * v);
typedef void (GLAD_API_PTR *PFNGLRASTERPOS2SPROC)(GLshort x, GLshort y);
typedef void (GLAD_API_PTR *PFNGLRASTERPOS2SVPROC)(const GLshort * v);
typedef void (GLAD_API_PTR *PFNGLRASTERPOS3DPROC)(GLdouble x, GLdouble y, GLdouble z);
typedef void (GLAD_API_PTR *PFNGLRASTERPOS3DVPROC)(const GLdouble * v);
typedef void (GLAD_API_PTR *PFNGLRASTERPOS3FPROC)(GLfloat x, GLfloat y, GLfloat z);
typedef void (GLAD_API_PTR *PFNGLRASTERPOS3FVPROC)(const GLfloat * v);
typedef void (GLAD_API_PTR *PFNGLRASTERPOS3IPROC)(GLint x, GLint y, GLint z);
typedef void (GLAD_API_PTR *PFNGLRASTERPOS3IVPROC)(const GLint * v);
typedef void (GLAD_API_PTR *PFNGLRASTERPOS3SPROC)(GLshort x, GLshort y, GLshort z);
typedef void (GLAD_API_PTR *PFNGLRASTERPOS3SVPROC)(const GLshort * v);
typedef void (GLAD_API_PTR *PFNGLRASTERPOS4DPROC)(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
typedef void (GLAD_API_PTR *PFNGLRASTERPOS4DVPROC)(const GLdouble * v);
typedef void (GLAD_API_PTR *PFNGLRASTERPOS4FPROC)(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
typedef void (GLAD_API_PTR *PFNGLRASTERPOS4FVPROC)(const GLfloat * v);
typedef void (GLAD_API_PTR *PFNGLRASTERPOS4IPROC)(GLint x, GLint y, GLint z, GLint w);
typedef void (GLAD_API_PTR *PFNGLRASTERPOS4IVPROC)(const GLint * v);
typedef void (GLAD_API_PTR *PFNGLRASTERPOS4SPROC)(GLshort x, GLshort y, GLshort z, GLshort w);
typedef void (GLAD_API_PTR *PFNGLRASTERPOS4SVPROC)(const GLshort * v);
typedef void (GLAD_API_PTR *PFNGLREADBUFFERPROC)(GLenum src);
typedef void (GLAD_API_PTR *PFNGLREADPIXELSPROC)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void * pixels);
typedef void (GLAD_API_PTR *PFNGLREADNPIXELSPROC)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei bufSize, void * data);
typedef void (GLAD_API_PTR *PFNGLREADNPIXELSARBPROC)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei bufSize, void * data);
typedef void (GLAD_API_PTR *PFNGLRECTDPROC)(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2);
typedef void (GLAD_API_PTR *PFNGLRECTDVPROC)(const GLdouble * v1, const GLdouble * v2);
typedef void (GLAD_API_PTR *PFNGLRECTFPROC)(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2);
typedef void (GLAD_API_PTR *PFNGLRECTFVPROC)(const GLfloat * v1, const GLfloat * v2);
typedef void (GLAD_API_PTR *PFNGLRECTIPROC)(GLint x1, GLint y1, GLint x2, GLint y2);
typedef void (GLAD_API_PTR *PFNGLRECTIVPROC)(const GLint * v1, const GLint * v2);
typedef void (GLAD_API_PTR *PFNGLRECTSPROC)(GLshort x1, GLshort y1, GLshort x2, GLshort y2);
typedef void (GLAD_API_PTR *PFNGLRECTSVPROC)(const GLshort * v1, const GLshort * v2);
typedef void (GLAD_API_PTR *PFNGLRELEASESHADERCOMPILERPROC)(void);
typedef GLint (GLAD_API_PTR *PFNGLRENDERMODEPROC)(GLenum mode);
typedef void (GLAD_API_PTR *PFNGLRENDERBUFFERSTORAGEPROC)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height);
typedef void (GLAD_API_PTR *PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height);
typedef void (GLAD_API_PTR *PFNGLRESUMETRANSFORMFEEDBACKPROC)(void);
typedef void (GLAD_API_PTR *PFNGLROTATEDPROC)(GLdouble angle, GLdouble x, GLdouble y, GLdouble z);
typedef void (GLAD_API_PTR *PFNGLROTATEFPROC)(GLfloat angle, GLfloat x, GLfloat y, GLfloat z);
typedef void (GLAD_API_PTR *PFNGLSAMPLECOVERAGEPROC)(GLfloat value, GLboolean invert);
typedef void (GLAD_API_PTR *PFNGLSAMPLECOVERAGEARBPROC)(GLfloat value, GLboolean invert);
typedef void (GLAD_API_PTR *PFNGLSAMPLEMASKIPROC)(GLuint maskNumber, GLbitfield mask);
typedef void (GLAD_API_PTR *PFNGLSAMPLERPARAMETERIIVPROC)(GLuint sampler, GLenum pname, const GLint * param);
typedef void (GLAD_API_PTR *PFNGLSAMPLERPARAMETERIUIVPROC)(GLuint sampler, GLenum pname, const GLuint * param);
typedef void (GLAD_API_PTR *PFNGLSAMPLERPARAMETERFPROC)(GLuint sampler, GLenum pname, GLfloat param);
typedef void (GLAD_API_PTR *PFNGLSAMPLERPARAMETERFVPROC)(GLuint sampler, GLenum pname, const GLfloat * param);
typedef void (GLAD_API_PTR *PFNGLSAMPLERPARAMETERIPROC)(GLuint sampler, GLenum pname, GLint param);
typedef void (GLAD_API_PTR *PFNGLSAMPLERPARAMETERIVPROC)(GLuint sampler, GLenum pname, const GLint * param);
typedef void (GLAD_API_PTR *PFNGLSCALEDPROC)(GLdouble x, GLdouble y, GLdouble z);
typedef void (GLAD_API_PTR *PFNGLSCALEFPROC)(GLfloat x, GLfloat y, GLfloat z);
typedef void (GLAD_API_PTR *PFNGLSCISSORPROC)(GLint x, GLint y, GLsizei width, GLsizei height);
typedef void (GLAD_API_PTR *PFNGLSCISSORARRAYVPROC)(GLuint first, GLsizei count, const GLint * v);
typedef void (GLAD_API_PTR *PFNGLSCISSORINDEXEDPROC)(GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height);
typedef void (GLAD_API_PTR *PFNGLSCISSORINDEXEDVPROC)(GLuint index, const GLint * v);
typedef void (GLAD_API_PTR *PFNGLSECONDARYCOLOR3BPROC)(GLbyte red, GLbyte green, GLbyte blue);
typedef void (GLAD_API_PTR *PFNGLSECONDARYCOLOR3BVPROC)(const GLbyte * v);
typedef void (GLAD_API_PTR *PFNGLSECONDARYCOLOR3DPROC)(GLdouble red, GLdouble green, GLdouble blue);
typedef void (GLAD_API_PTR *PFNGLSECONDARYCOLOR3DVPROC)(const GLdouble * v);
typedef void (GLAD_API_PTR *PFNGLSECONDARYCOLOR3FPROC)(GLfloat red, GLfloat green, GLfloat blue);
typedef void (GLAD_API_PTR *PFNGLSECONDARYCOLOR3FVPROC)(const GLfloat * v);
typedef void (GLAD_API_PTR *PFNGLSECONDARYCOLOR3IPROC)(GLint red, GLint green, GLint blue);
typedef void (GLAD_API_PTR *PFNGLSECONDARYCOLOR3IVPROC)(const GLint * v);
typedef void (GLAD_API_PTR *PFNGLSECONDARYCOLOR3SPROC)(GLshort red, GLshort green, GLshort blue);
typedef void (GLAD_API_PTR *PFNGLSECONDARYCOLOR3SVPROC)(const GLshort * v);
typedef void (GLAD_API_PTR *PFNGLSECONDARYCOLOR3UBPROC)(GLubyte red, GLubyte green, GLubyte blue);
typedef void (GLAD_API_PTR *PFNGLSECONDARYCOLOR3UBVPROC)(const GLubyte * v);
typedef void (GLAD_API_PTR *PFNGLSECONDARYCOLOR3UIPROC)(GLuint red, GLuint green, GLuint blue);
typedef void (GLAD_API_PTR *PFNGLSECONDARYCOLOR3UIVPROC)(const GLuint * v);
typedef void (GLAD_API_PTR *PFNGLSECONDARYCOLOR3USPROC)(GLushort red, GLushort green, GLushort blue);
typedef void (GLAD_API_PTR *PFNGLSECONDARYCOLOR3USVPROC)(const GLushort * v);
typedef void (GLAD_API_PTR *PFNGLSECONDARYCOLORP3UIPROC)(GLenum type, GLuint color);
typedef void (GLAD_API_PTR *PFNGLSECONDARYCOLORP3UIVPROC)(GLenum type, const GLuint * color);
typedef void (GLAD_API_PTR *PFNGLSECONDARYCOLORPOINTERPROC)(GLint size, GLenum type, GLsizei stride, const void * pointer);
typedef void (GLAD_API_PTR *PFNGLSELECTBUFFERPROC)(GLsizei size, GLuint * buffer);
typedef void (GLAD_API_PTR *PFNGLSHADEMODELPROC)(GLenum mode);
typedef void (GLAD_API_PTR *PFNGLSHADERBINARYPROC)(GLsizei count, const GLuint * shaders, GLenum binaryFormat, const void * binary, GLsizei length);
typedef void (GLAD_API_PTR *PFNGLSHADERSOURCEPROC)(GLuint shader, GLsizei count, const GLchar *const* string, const GLint * length);
typedef void (GLAD_API_PTR *PFNGLSHADERSTORAGEBLOCKBINDINGPROC)(GLuint program, GLuint storageBlockIndex, GLuint storageBlockBinding);
typedef void (GLAD_API_PTR *PFNGLSPECIALIZESHADERPROC)(GLuint shader, const GLchar * pEntryPoint, GLuint numSpecializationConstants, const GLuint * pConstantIndex, const GLuint * pConstantValue);
typedef void (GLAD_API_PTR *PFNGLSTENCILFUNCPROC)(GLenum func, GLint ref, GLuint mask);
typedef void (GLAD_API_PTR *PFNGLSTENCILFUNCSEPARATEPROC)(GLenum face, GLenum func, GLint ref, GLuint mask);
typedef void (GLAD_API_PTR *PFNGLSTENCILMASKPROC)(GLuint mask);
typedef void (GLAD_API_PTR *PFNGLSTENCILMASKSEPARATEPROC)(GLenum face, GLuint mask);
typedef void (GLAD_API_PTR *PFNGLSTENCILOPPROC)(GLenum fail, GLenum zfail, GLenum zpass);
typedef void (GLAD_API_PTR *PFNGLSTENCILOPSEPARATEPROC)(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass);
typedef void (GLAD_API_PTR *PFNGLTEXBUFFERPROC)(GLenum target, GLenum internalformat, GLuint buffer);
typedef void (GLAD_API_PTR *PFNGLTEXBUFFERRANGEPROC)(GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size);
typedef void (GLAD_API_PTR *PFNGLTEXCOORD1DPROC)(GLdouble s);
typedef void (GLAD_API_PTR *PFNGLTEXCOORD1DVPROC)(const GLdouble * v);
typedef void (GLAD_API_PTR *PFNGLTEXCOORD1FPROC)(GLfloat s);
typedef void (GLAD_API_PTR *PFNGLTEXCOORD1FVPROC)(const GLfloat * v);
typedef void (GLAD_API_PTR *PFNGLTEXCOORD1IPROC)(GLint s);
typedef void (GLAD_API_PTR *PFNGLTEXCOORD1IVPROC)(const GLint * v);
typedef void (GLAD_API_PTR *PFNGLTEXCOORD1SPROC)(GLshort s);
typedef void (GLAD_API_PTR *PFNGLTEXCOORD1SVPROC)(const GLshort * v);
typedef void (GLAD_API_PTR *PFNGLTEXCOORD2DPROC)(GLdouble s, GLdouble t);
typedef void (GLAD_API_PTR *PFNGLTEXCOORD2DVPROC)(const GLdouble * v);
typedef void (GLAD_API_PTR *PFNGLTEXCOORD2FPROC)(GLfloat s, GLfloat t);
typedef void (GLAD_API_PTR *PFNGLTEXCOORD2FVPROC)(const GLfloat * v);
typedef void (GLAD_API_PTR *PFNGLTEXCOORD2IPROC)(GLint s, GLint t);
typedef void (GLAD_API_PTR *PFNGLTEXCOORD2IVPROC)(const GLint * v);
typedef void (GLAD_API_PTR *PFNGLTEXCOORD2SPROC)(GLshort s, GLshort t);
typedef void (GLAD_API_PTR *PFNGLTEXCOORD2SVPROC)(const GLshort * v);
typedef void (GLAD_API_PTR *PFNGLTEXCOORD3DPROC)(GLdouble s, GLdouble t, GLdouble r);
typedef void (GLAD_API_PTR *PFNGLTEXCOORD3DVPROC)(const GLdouble * v);
typedef void (GLAD_API_PTR *PFNGLTEXCOORD3FPROC)(GLfloat s, GLfloat t, GLfloat r);
typedef void (GLAD_API_PTR *PFNGLTEXCOORD3FVPROC)(const GLfloat * v);
typedef void (GLAD_API_PTR *PFNGLTEXCOORD3IPROC)(GLint s, GLint t, GLint r);
typedef void (GLAD_API_PTR *PFNGLTEXCOORD3IVPROC)(const GLint * v);
typedef void (GLAD_API_PTR *PFNGLTEXCOORD3SPROC)(GLshort s, GLshort t, GLshort r);
typedef void (GLAD_API_PTR *PFNGLTEXCOORD3SVPROC)(const GLshort * v);
typedef void (GLAD_API_PTR *PFNGLTEXCOORD4DPROC)(GLdouble s, GLdouble t, GLdouble r, GLdouble q);
typedef void (GLAD_API_PTR *PFNGLTEXCOORD4DVPROC)(const GLdouble * v);
typedef void (GLAD_API_PTR *PFNGLTEXCOORD4FPROC)(GLfloat s, GLfloat t, GLfloat r, GLfloat q);
typedef void (GLAD_API_PTR *PFNGLTEXCOORD4FVPROC)(const GLfloat * v);
typedef void (GLAD_API_PTR *PFNGLTEXCOORD4IPROC)(GLint s, GLint t, GLint r, GLint q);
typedef void (GLAD_API_PTR *PFNGLTEXCOORD4IVPROC)(const GLint * v);
typedef void (GLAD_API_PTR *PFNGLTEXCOORD4SPROC)(GLshort s, GLshort t, GLshort r, GLshort q);
typedef void (GLAD_API_PTR *PFNGLTEXCOORD4SVPROC)(const GLshort * v);
typedef void (GLAD_API_PTR *PFNGLTEXCOORDP1UIPROC)(GLenum type, GLuint coords);
typedef void (GLAD_API_PTR *PFNGLTEXCOORDP1UIVPROC)(GLenum type, const GLuint * coords);
typedef void (GLAD_API_PTR *PFNGLTEXCOORDP2UIPROC)(GLenum type, GLuint coords);
typedef void (GLAD_API_PTR *PFNGLTEXCOORDP2UIVPROC)(GLenum type, const GLuint * coords);
typedef void (GLAD_API_PTR *PFNGLTEXCOORDP3UIPROC)(GLenum type, GLuint coords);
typedef void (GLAD_API_PTR *PFNGLTEXCOORDP3UIVPROC)(GLenum type, const GLuint * coords);
typedef void (GLAD_API_PTR *PFNGLTEXCOORDP4UIPROC)(GLenum type, GLuint coords);
typedef void (GLAD_API_PTR *PFNGLTEXCOORDP4UIVPROC)(GLenum type, const GLuint * coords);
typedef void (GLAD_API_PTR *PFNGLTEXCOORDPOINTERPROC)(GLint size, GLenum type, GLsizei stride, const void * pointer);
typedef void (GLAD_API_PTR *PFNGLTEXENVFPROC)(GLenum target, GLenum pname, GLfloat param);
typedef void (GLAD_API_PTR *PFNGLTEXENVFVPROC)(GLenum target, GLenum pname, const GLfloat * params);
typedef void (GLAD_API_PTR *PFNGLTEXENVIPROC)(GLenum target, GLenum pname, GLint param);
typedef void (GLAD_API_PTR *PFNGLTEXENVIVPROC)(GLenum target, GLenum pname, const GLint * params);
typedef void (GLAD_API_PTR *PFNGLTEXGENDPROC)(GLenum coord, GLenum pname, GLdouble param);
typedef void (GLAD_API_PTR *PFNGLTEXGENDVPROC)(GLenum coord, GLenum pname, const GLdouble * params);
typedef void (GLAD_API_PTR *PFNGLTEXGENFPROC)(GLenum coord, GLenum pname, GLfloat param);
typedef void (GLAD_API_PTR *PFNGLTEXGENFVPROC)(GLenum coord, GLenum pname, const GLfloat * params);
typedef void (GLAD_API_PTR *PFNGLTEXGENIPROC)(GLenum coord, GLenum pname, GLint param);
typedef void (GLAD_API_PTR *PFNGLTEXGENIVPROC)(GLenum coord, GLenum pname, const GLint * params);
typedef void (GLAD_API_PTR *PFNGLTEXIMAGE1DPROC)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void * pixels);
typedef void (GLAD_API_PTR *PFNGLTEXIMAGE2DPROC)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void * pixels);
typedef void (GLAD_API_PTR *PFNGLTEXIMAGE2DMULTISAMPLEPROC)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations);
typedef void (GLAD_API_PTR *PFNGLTEXIMAGE3DPROC)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void * pixels);
typedef void (GLAD_API_PTR *PFNGLTEXIMAGE3DMULTISAMPLEPROC)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations);
typedef void (GLAD_API_PTR *PFNGLTEXPARAMETERIIVPROC)(GLenum target, GLenum pname, const GLint * params);
typedef void (GLAD_API_PTR *PFNGLTEXPARAMETERIUIVPROC)(GLenum target, GLenum pname, const GLuint * params);
typedef void (GLAD_API_PTR *PFNGLTEXPARAMETERFPROC)(GLenum target, GLenum pname, GLfloat param);
typedef void (GLAD_API_PTR *PFNGLTEXPARAMETERFVPROC)(GLenum target, GLenum pname, const GLfloat * params);
typedef void (GLAD_API_PTR *PFNGLTEXPARAMETERIPROC)(GLenum target, GLenum pname, GLint param);
typedef void (GLAD_API_PTR *PFNGLTEXPARAMETERIVPROC)(GLenum target, GLenum pname, const GLint * params);
typedef void (GLAD_API_PTR *PFNGLTEXSTORAGE1DPROC)(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width);
typedef void (GLAD_API_PTR *PFNGLTEXSTORAGE2DPROC)(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height);
typedef void (GLAD_API_PTR *PFNGLTEXSTORAGE2DMULTISAMPLEPROC)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations);
typedef void (GLAD_API_PTR *PFNGLTEXSTORAGE3DPROC)(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth);
typedef void (GLAD_API_PTR *PFNGLTEXSTORAGE3DMULTISAMPLEPROC)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations);
typedef void (GLAD_API_PTR *PFNGLTEXSUBIMAGE1DPROC)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void * pixels);
typedef void (GLAD_API_PTR *PFNGLTEXSUBIMAGE2DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void * pixels);
typedef void (GLAD_API_PTR *PFNGLTEXSUBIMAGE3DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void * pixels);
typedef void (GLAD_API_PTR *PFNGLTEXTUREBARRIERPROC)(void);
typedef void (GLAD_API_PTR *PFNGLTEXTUREBUFFERPROC)(GLuint texture, GLenum internalformat, GLuint buffer);
typedef void (GLAD_API_PTR *PFNGLTEXTUREBUFFERRANGEPROC)(GLuint texture, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size);
typedef void (GLAD_API_PTR *PFNGLTEXTUREPARAMETERIIVPROC)(GLuint texture, GLenum pname, const GLint * params);
typedef void (GLAD_API_PTR *PFNGLTEXTUREPARAMETERIUIVPROC)(GLuint texture, GLenum pname, const GLuint * params);
typedef void (GLAD_API_PTR *PFNGLTEXTUREPARAMETERFPROC)(GLuint texture, GLenum pname, GLfloat param);
typedef void (GLAD_API_PTR *PFNGLTEXTUREPARAMETERFVPROC)(GLuint texture, GLenum pname, const GLfloat * param);
typedef void (GLAD_API_PTR *PFNGLTEXTUREPARAMETERIPROC)(GLuint texture, GLenum pname, GLint param);
typedef void (GLAD_API_PTR *PFNGLTEXTUREPARAMETERIVPROC)(GLuint texture, GLenum pname, const GLint * param);
typedef void (GLAD_API_PTR *PFNGLTEXTURESTORAGE1DPROC)(GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width);
typedef void (GLAD_API_PTR *PFNGLTEXTURESTORAGE2DPROC)(GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height);
typedef void (GLAD_API_PTR *PFNGLTEXTURESTORAGE2DMULTISAMPLEPROC)(GLuint texture, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations);
typedef void (GLAD_API_PTR *PFNGLTEXTURESTORAGE3DPROC)(GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth);
typedef void (GLAD_API_PTR *PFNGLTEXTURESTORAGE3DMULTISAMPLEPROC)(GLuint texture, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations);
typedef void (GLAD_API_PTR *PFNGLTEXTURESUBIMAGE1DPROC)(GLuint texture, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void * pixels);
typedef void (GLAD_API_PTR *PFNGLTEXTURESUBIMAGE2DPROC)(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void * pixels);
typedef void (GLAD_API_PTR *PFNGLTEXTURESUBIMAGE3DPROC)(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void * pixels);
typedef void (GLAD_API_PTR *PFNGLTEXTUREVIEWPROC)(GLuint texture, GLenum target, GLuint origtexture, GLenum internalformat, GLuint minlevel, GLuint numlevels, GLuint minlayer, GLuint numlayers);
typedef void (GLAD_API_PTR *PFNGLTRANSFORMFEEDBACKBUFFERBASEPROC)(GLuint xfb, GLuint index, GLuint buffer);
typedef void (GLAD_API_PTR *PFNGLTRANSFORMFEEDBACKBUFFERRANGEPROC)(GLuint xfb, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size);
typedef void (GLAD_API_PTR *PFNGLTRANSFORMFEEDBACKVARYINGSPROC)(GLuint program, GLsizei count, const GLchar *const* varyings, GLenum bufferMode);
typedef void (GLAD_API_PTR *PFNGLTRANSLATEDPROC)(GLdouble x, GLdouble y, GLdouble z);
typedef void (GLAD_API_PTR *PFNGLTRANSLATEFPROC)(GLfloat x, GLfloat y, GLfloat z);
typedef void (GLAD_API_PTR *PFNGLUNIFORM1DPROC)(GLint location, GLdouble x);
typedef void (GLAD_API_PTR *PFNGLUNIFORM1DVPROC)(GLint location, GLsizei count, const GLdouble * value);
typedef void (GLAD_API_PTR *PFNGLUNIFORM1FPROC)(GLint location, GLfloat v0);
typedef void (GLAD_API_PTR *PFNGLUNIFORM1FVPROC)(GLint location, GLsizei count, const GLfloat * value);
typedef void (GLAD_API_PTR *PFNGLUNIFORM1IPROC)(GLint location, GLint v0);
typedef void (GLAD_API_PTR *PFNGLUNIFORM1IVPROC)(GLint location, GLsizei count, const GLint * value);
typedef void (GLAD_API_PTR *PFNGLUNIFORM1UIPROC)(GLint location, GLuint v0);
typedef void (GLAD_API_PTR *PFNGLUNIFORM1UIVPROC)(GLint location, GLsizei count, const GLuint * value);
typedef void (GLAD_API_PTR *PFNGLUNIFORM2DPROC)(GLint location, GLdouble x, GLdouble y);
typedef void (GLAD_API_PTR *PFNGLUNIFORM2DVPROC)(GLint location, GLsizei count, const GLdouble * value);
typedef void (GLAD_API_PTR *PFNGLUNIFORM2FPROC)(GLint location, GLfloat v0, GLfloat v1);
typedef void (GLAD_API_PTR *PFNGLUNIFORM2FVPROC)(GLint location, GLsizei count, const GLfloat * value);
typedef void (GLAD_API_PTR *PFNGLUNIFORM2IPROC)(GLint location, GLint v0, GLint v1);
typedef void (GLAD_API_PTR *PFNGLUNIFORM2IVPROC)(GLint location, GLsizei count, const GLint * value);
typedef void (GLAD_API_PTR *PFNGLUNIFORM2UIPROC)(GLint location, GLuint v0, GLuint v1);
typedef void (GLAD_API_PTR *PFNGLUNIFORM2UIVPROC)(GLint location, GLsizei count, const GLuint * value);
typedef void (GLAD_API_PTR *PFNGLUNIFORM3DPROC)(GLint location, GLdouble x, GLdouble y, GLdouble z);
typedef void (GLAD_API_PTR *PFNGLUNIFORM3DVPROC)(GLint location, GLsizei count, const GLdouble * value);
typedef void (GLAD_API_PTR *PFNGLUNIFORM3FPROC)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
typedef void (GLAD_API_PTR *PFNGLUNIFORM3FVPROC)(GLint location, GLsizei count, const GLfloat * value);
typedef void (GLAD_API_PTR *PFNGLUNIFORM3IPROC)(GLint location, GLint v0, GLint v1, GLint v2);
typedef void (GLAD_API_PTR *PFNGLUNIFORM3IVPROC)(GLint location, GLsizei count, const GLint * value);
typedef void (GLAD_API_PTR *PFNGLUNIFORM3UIPROC)(GLint location, GLuint v0, GLuint v1, GLuint v2);
typedef void (GLAD_API_PTR *PFNGLUNIFORM3UIVPROC)(GLint location, GLsizei count, const GLuint * value);
typedef void (GLAD_API_PTR *PFNGLUNIFORM4DPROC)(GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
typedef void (GLAD_API_PTR *PFNGLUNIFORM4DVPROC)(GLint location, GLsizei count, const GLdouble * value);
typedef void (GLAD_API_PTR *PFNGLUNIFORM4FPROC)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
typedef void (GLAD_API_PTR *PFNGLUNIFORM4FVPROC)(GLint location, GLsizei count, const GLfloat * value);
typedef void (GLAD_API_PTR *PFNGLUNIFORM4IPROC)(GLint location, GLint v0, GLint v1, GLint v2, GLint v3);
typedef void (GLAD_API_PTR *PFNGLUNIFORM4IVPROC)(GLint location, GLsizei count, const GLint * value);
typedef void (GLAD_API_PTR *PFNGLUNIFORM4UIPROC)(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3);
typedef void (GLAD_API_PTR *PFNGLUNIFORM4UIVPROC)(GLint location, GLsizei count, const GLuint * value);
typedef void (GLAD_API_PTR *PFNGLUNIFORMBLOCKBINDINGPROC)(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding);
typedef void (GLAD_API_PTR *PFNGLUNIFORMMATRIX2DVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLdouble * value);
typedef void (GLAD_API_PTR *PFNGLUNIFORMMATRIX2FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value);
typedef void (GLAD_API_PTR *PFNGLUNIFORMMATRIX2X3DVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLdouble * value);
typedef void (GLAD_API_PTR *PFNGLUNIFORMMATRIX2X3FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value);
typedef void (GLAD_API_PTR *PFNGLUNIFORMMATRIX2X4DVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLdouble * value);
typedef void (GLAD_API_PTR *PFNGLUNIFORMMATRIX2X4FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value);
typedef void (GLAD_API_PTR *PFNGLUNIFORMMATRIX3DVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLdouble * value);
typedef void (GLAD_API_PTR *PFNGLUNIFORMMATRIX3FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value);
typedef void (GLAD_API_PTR *PFNGLUNIFORMMATRIX3X2DVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLdouble * value);
typedef void (GLAD_API_PTR *PFNGLUNIFORMMATRIX3X2FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value);
typedef void (GLAD_API_PTR *PFNGLUNIFORMMATRIX3X4DVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLdouble * value);
typedef void (GLAD_API_PTR *PFNGLUNIFORMMATRIX3X4FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value);
typedef void (GLAD_API_PTR *PFNGLUNIFORMMATRIX4DVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLdouble * value);
typedef void (GLAD_API_PTR *PFNGLUNIFORMMATRIX4FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value);
typedef void (GLAD_API_PTR *PFNGLUNIFORMMATRIX4X2DVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLdouble * value);
typedef void (GLAD_API_PTR *PFNGLUNIFORMMATRIX4X2FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value);
typedef void (GLAD_API_PTR *PFNGLUNIFORMMATRIX4X3DVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLdouble * value);
typedef void (GLAD_API_PTR *PFNGLUNIFORMMATRIX4X3FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value);
typedef void (GLAD_API_PTR *PFNGLUNIFORMSUBROUTINESUIVPROC)(GLenum shadertype, GLsizei count, const GLuint * indices);
typedef GLboolean (GLAD_API_PTR *PFNGLUNMAPBUFFERPROC)(GLenum target);
typedef GLboolean (GLAD_API_PTR *PFNGLUNMAPNAMEDBUFFERPROC)(GLuint buffer);
typedef void (GLAD_API_PTR *PFNGLUSEPROGRAMPROC)(GLuint program);
typedef void (GLAD_API_PTR *PFNGLUSEPROGRAMSTAGESPROC)(GLuint pipeline, GLbitfield stages, GLuint program);
typedef void (GLAD_API_PTR *PFNGLVALIDATEPROGRAMPROC)(GLuint program);
typedef void (GLAD_API_PTR *PFNGLVALIDATEPROGRAMPIPELINEPROC)(GLuint pipeline);
typedef void (GLAD_API_PTR *PFNGLVERTEX2DPROC)(GLdouble x, GLdouble y);
typedef void (GLAD_API_PTR *PFNGLVERTEX2DVPROC)(const GLdouble * v);
typedef void (GLAD_API_PTR *PFNGLVERTEX2FPROC)(GLfloat x, GLfloat y);
typedef void (GLAD_API_PTR *PFNGLVERTEX2FVPROC)(const GLfloat * v);
typedef void (GLAD_API_PTR *PFNGLVERTEX2IPROC)(GLint x, GLint y);
typedef void (GLAD_API_PTR *PFNGLVERTEX2IVPROC)(const GLint * v);
typedef void (GLAD_API_PTR *PFNGLVERTEX2SPROC)(GLshort x, GLshort y);
typedef void (GLAD_API_PTR *PFNGLVERTEX2SVPROC)(const GLshort * v);
typedef void (GLAD_API_PTR *PFNGLVERTEX3DPROC)(GLdouble x, GLdouble y, GLdouble z);
typedef void (GLAD_API_PTR *PFNGLVERTEX3DVPROC)(const GLdouble * v);
typedef void (GLAD_API_PTR *PFNGLVERTEX3FPROC)(GLfloat x, GLfloat y, GLfloat z);
typedef void (GLAD_API_PTR *PFNGLVERTEX3FVPROC)(const GLfloat * v);
typedef void (GLAD_API_PTR *PFNGLVERTEX3IPROC)(GLint x, GLint y, GLint z);
typedef void (GLAD_API_PTR *PFNGLVERTEX3IVPROC)(const GLint * v);
typedef void (GLAD_API_PTR *PFNGLVERTEX3SPROC)(GLshort x, GLshort y, GLshort z);
typedef void (GLAD_API_PTR *PFNGLVERTEX3SVPROC)(const GLshort * v);
typedef void (GLAD_API_PTR *PFNGLVERTEX4DPROC)(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
typedef void (GLAD_API_PTR *PFNGLVERTEX4DVPROC)(const GLdouble * v);
typedef void (GLAD_API_PTR *PFNGLVERTEX4FPROC)(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
typedef void (GLAD_API_PTR *PFNGLVERTEX4FVPROC)(const GLfloat * v);
typedef void (GLAD_API_PTR *PFNGLVERTEX4IPROC)(GLint x, GLint y, GLint z, GLint w);
typedef void (GLAD_API_PTR *PFNGLVERTEX4IVPROC)(const GLint * v);
typedef void (GLAD_API_PTR *PFNGLVERTEX4SPROC)(GLshort x, GLshort y, GLshort z, GLshort w);
typedef void (GLAD_API_PTR *PFNGLVERTEX4SVPROC)(const GLshort * v);
typedef void (GLAD_API_PTR *PFNGLVERTEXARRAYATTRIBBINDINGPROC)(GLuint vaobj, GLuint attribindex, GLuint bindingindex);
typedef void (GLAD_API_PTR *PFNGLVERTEXARRAYATTRIBFORMATPROC)(GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset);
typedef void (GLAD_API_PTR *PFNGLVERTEXARRAYATTRIBIFORMATPROC)(GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset);
typedef void (GLAD_API_PTR *PFNGLVERTEXARRAYATTRIBLFORMATPROC)(GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset);
typedef void (GLAD_API_PTR *PFNGLVERTEXARRAYBINDINGDIVISORPROC)(GLuint vaobj, GLuint bindingindex, GLuint divisor);
typedef void (GLAD_API_PTR *PFNGLVERTEXARRAYELEMENTBUFFERPROC)(GLuint vaobj, GLuint buffer);
typedef void (GLAD_API_PTR *PFNGLVERTEXARRAYVERTEXBUFFERPROC)(GLuint vaobj, GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride);
typedef void (GLAD_API_PTR *PFNGLVERTEXARRAYVERTEXBUFFERSPROC)(GLuint vaobj, GLuint first, GLsizei count, const GLuint * buffers, const GLintptr * offsets, const GLsizei * strides);
typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB1DPROC)(GLuint index, GLdouble x);
typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB1DVPROC)(GLuint index, const GLdouble * v);
typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB1FPROC)(GLuint index, GLfloat x);
typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB1FVPROC)(GLuint index, const GLfloat * v);
typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB1SPROC)(GLuint index, GLshort x);
typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB1SVPROC)(GLuint index, const GLshort * v);
typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB2DPROC)(GLuint index, GLdouble x, GLdouble y);
typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB2DVPROC)(GLuint index, const GLdouble * v);
typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB2FPROC)(GLuint index, GLfloat x, GLfloat y);
typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB2FVPROC)(GLuint index, const GLfloat * v);
typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB2SPROC)(GLuint index, GLshort x, GLshort y);
typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB2SVPROC)(GLuint index, const GLshort * v);
typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB3DPROC)(GLuint index, GLdouble x, GLdouble y, GLdouble z);
typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB3DVPROC)(GLuint index, const GLdouble * v);
typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB3FPROC)(GLuint index, GLfloat x, GLfloat y, GLfloat z);
typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB3FVPROC)(GLuint index, const GLfloat * v);
typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB3SPROC)(GLuint index, GLshort x, GLshort y, GLshort z);
typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB3SVPROC)(GLuint index, const GLshort * v);
typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4NBVPROC)(GLuint index, const GLbyte * v);
typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4NIVPROC)(GLuint index, const GLint * v);
typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4NSVPROC)(GLuint index, const GLshort * v);
typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4NUBPROC)(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w);
typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4NUBVPROC)(GLuint index, const GLubyte * v);
typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4NUIVPROC)(GLuint index, const GLuint * v);
typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4NUSVPROC)(GLuint index, const GLushort * v);
typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4BVPROC)(GLuint index, const GLbyte * v);
typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4DPROC)(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4DVPROC)(GLuint index, const GLdouble * v);
typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4FPROC)(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4FVPROC)(GLuint index, const GLfloat * v);
typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4IVPROC)(GLuint index, const GLint * v);
typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4SPROC)(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w);
typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4SVPROC)(GLuint index, const GLshort * v);
typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4UBVPROC)(GLuint index, const GLubyte * v);
typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4UIVPROC)(GLuint index, const GLuint * v);
typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIB4USVPROC)(GLuint index, const GLushort * v);
typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBBINDINGPROC)(GLuint attribindex, GLuint bindingindex);
typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBDIVISORPROC)(GLuint index, GLuint divisor);
typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBFORMATPROC)(GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset);
typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBI1IPROC)(GLuint index, GLint x);
typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBI1IVPROC)(GLuint index, const GLint * v);
typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBI1UIPROC)(GLuint index, GLuint x);
typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBI1UIVPROC)(GLuint index, const GLuint * v);
typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBI2IPROC)(GLuint index, GLint x, GLint y);
typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBI2IVPROC)(GLuint index, const GLint * v);
typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBI2UIPROC)(GLuint index, GLuint x, GLuint y);
typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBI2UIVPROC)(GLuint index, const GLuint * v);
typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBI3IPROC)(GLuint index, GLint x, GLint y, GLint z);
typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBI3IVPROC)(GLuint index, const GLint * v);
typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBI3UIPROC)(GLuint index, GLuint x, GLuint y, GLuint z);
typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBI3UIVPROC)(GLuint index, const GLuint * v);
typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBI4BVPROC)(GLuint index, const GLbyte * v);
typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBI4IPROC)(GLuint index, GLint x, GLint y, GLint z, GLint w);
typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBI4IVPROC)(GLuint index, const GLint * v);
typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBI4SVPROC)(GLuint index, const GLshort * v);
typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBI4UBVPROC)(GLuint index, const GLubyte * v);
typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBI4UIPROC)(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w);
typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBI4UIVPROC)(GLuint index, const GLuint * v);
typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBI4USVPROC)(GLuint index, const GLushort * v);
typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBIFORMATPROC)(GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset);
typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBIPOINTERPROC)(GLuint index, GLint size, GLenum type, GLsizei stride, const void * pointer);
typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBL1DPROC)(GLuint index, GLdouble x);
typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBL1DVPROC)(GLuint index, const GLdouble * v);
typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBL2DPROC)(GLuint index, GLdouble x, GLdouble y);
typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBL2DVPROC)(GLuint index, const GLdouble * v);
typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBL3DPROC)(GLuint index, GLdouble x, GLdouble y, GLdouble z);
typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBL3DVPROC)(GLuint index, const GLdouble * v);
typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBL4DPROC)(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBL4DVPROC)(GLuint index, const GLdouble * v);
typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBLFORMATPROC)(GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset);
typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBLPOINTERPROC)(GLuint index, GLint size, GLenum type, GLsizei stride, const void * pointer);
typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBP1UIPROC)(GLuint index, GLenum type, GLboolean normalized, GLuint value);
typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBP1UIVPROC)(GLuint index, GLenum type, GLboolean normalized, const GLuint * value);
typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBP2UIPROC)(GLuint index, GLenum type, GLboolean normalized, GLuint value);
typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBP2UIVPROC)(GLuint index, GLenum type, GLboolean normalized, const GLuint * value);
typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBP3UIPROC)(GLuint index, GLenum type, GLboolean normalized, GLuint value);
typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBP3UIVPROC)(GLuint index, GLenum type, GLboolean normalized, const GLuint * value);
typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBP4UIPROC)(GLuint index, GLenum type, GLboolean normalized, GLuint value);
typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBP4UIVPROC)(GLuint index, GLenum type, GLboolean normalized, const GLuint * value);
typedef void (GLAD_API_PTR *PFNGLVERTEXATTRIBPOINTERPROC)(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void * pointer);
typedef void (GLAD_API_PTR *PFNGLVERTEXBINDINGDIVISORPROC)(GLuint bindingindex, GLuint divisor);
typedef void (GLAD_API_PTR *PFNGLVERTEXP2UIPROC)(GLenum type, GLuint value);
typedef void (GLAD_API_PTR *PFNGLVERTEXP2UIVPROC)(GLenum type, const GLuint * value);
typedef void (GLAD_API_PTR *PFNGLVERTEXP3UIPROC)(GLenum type, GLuint value);
typedef void (GLAD_API_PTR *PFNGLVERTEXP3UIVPROC)(GLenum type, const GLuint * value);
typedef void (GLAD_API_PTR *PFNGLVERTEXP4UIPROC)(GLenum type, GLuint value);
typedef void (GLAD_API_PTR *PFNGLVERTEXP4UIVPROC)(GLenum type, const GLuint * value);
typedef void (GLAD_API_PTR *PFNGLVERTEXPOINTERPROC)(GLint size, GLenum type, GLsizei stride, const void * pointer);
typedef void (GLAD_API_PTR *PFNGLVIEWPORTPROC)(GLint x, GLint y, GLsizei width, GLsizei height);
typedef void (GLAD_API_PTR *PFNGLVIEWPORTARRAYVPROC)(GLuint first, GLsizei count, const GLfloat * v);
typedef void (GLAD_API_PTR *PFNGLVIEWPORTINDEXEDFPROC)(GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h);
typedef void (GLAD_API_PTR *PFNGLVIEWPORTINDEXEDFVPROC)(GLuint index, const GLfloat * v);
typedef void (GLAD_API_PTR *PFNGLWAITSYNCPROC)(GLsync sync, GLbitfield flags, GLuint64 timeout);
typedef void (GLAD_API_PTR *PFNGLWINDOWPOS2DPROC)(GLdouble x, GLdouble y);
typedef void (GLAD_API_PTR *PFNGLWINDOWPOS2DVPROC)(const GLdouble * v);
typedef void (GLAD_API_PTR *PFNGLWINDOWPOS2FPROC)(GLfloat x, GLfloat y);
typedef void (GLAD_API_PTR *PFNGLWINDOWPOS2FVPROC)(const GLfloat * v);
typedef void (GLAD_API_PTR *PFNGLWINDOWPOS2IPROC)(GLint x, GLint y);
typedef void (GLAD_API_PTR *PFNGLWINDOWPOS2IVPROC)(const GLint * v);
typedef void (GLAD_API_PTR *PFNGLWINDOWPOS2SPROC)(GLshort x, GLshort y);
typedef void (GLAD_API_PTR *PFNGLWINDOWPOS2SVPROC)(const GLshort * v);
typedef void (GLAD_API_PTR *PFNGLWINDOWPOS3DPROC)(GLdouble x, GLdouble y, GLdouble z);
typedef void (GLAD_API_PTR *PFNGLWINDOWPOS3DVPROC)(const GLdouble * v);
typedef void (GLAD_API_PTR *PFNGLWINDOWPOS3FPROC)(GLfloat x, GLfloat y, GLfloat z);
typedef void (GLAD_API_PTR *PFNGLWINDOWPOS3FVPROC)(const GLfloat * v);
typedef void (GLAD_API_PTR *PFNGLWINDOWPOS3IPROC)(GLint x, GLint y, GLint z);
typedef void (GLAD_API_PTR *PFNGLWINDOWPOS3IVPROC)(const GLint * v);
typedef void (GLAD_API_PTR *PFNGLWINDOWPOS3SPROC)(GLshort x, GLshort y, GLshort z);
typedef void (GLAD_API_PTR *PFNGLWINDOWPOS3SVPROC)(const GLshort * v);
GLAD_API_CALL PFNGLACCUMPROC glad_glAccum;
#define glAccum glad_glAccum
GLAD_API_CALL PFNGLACTIVESHADERPROGRAMPROC glad_glActiveShaderProgram;
#define glActiveShaderProgram glad_glActiveShaderProgram
GLAD_API_CALL PFNGLACTIVETEXTUREPROC glad_glActiveTexture;
#define glActiveTexture glad_glActiveTexture
GLAD_API_CALL PFNGLALPHAFUNCPROC glad_glAlphaFunc;
#define glAlphaFunc glad_glAlphaFunc
GLAD_API_CALL PFNGLARETEXTURESRESIDENTPROC glad_glAreTexturesResident;
#define glAreTexturesResident glad_glAreTexturesResident
GLAD_API_CALL PFNGLARRAYELEMENTPROC glad_glArrayElement;
#define glArrayElement glad_glArrayElement
GLAD_API_CALL PFNGLATTACHSHADERPROC glad_glAttachShader;
#define glAttachShader glad_glAttachShader
GLAD_API_CALL PFNGLBEGINPROC glad_glBegin;
#define glBegin glad_glBegin
GLAD_API_CALL PFNGLBEGINCONDITIONALRENDERPROC glad_glBeginConditionalRender;
#define glBeginConditionalRender glad_glBeginConditionalRender
GLAD_API_CALL PFNGLBEGINQUERYPROC glad_glBeginQuery;
#define glBeginQuery glad_glBeginQuery
GLAD_API_CALL PFNGLBEGINQUERYINDEXEDPROC glad_glBeginQueryIndexed;
#define glBeginQueryIndexed glad_glBeginQueryIndexed
GLAD_API_CALL PFNGLBEGINTRANSFORMFEEDBACKPROC glad_glBeginTransformFeedback;
#define glBeginTransformFeedback glad_glBeginTransformFeedback
GLAD_API_CALL PFNGLBINDATTRIBLOCATIONPROC glad_glBindAttribLocation;
#define glBindAttribLocation glad_glBindAttribLocation
GLAD_API_CALL PFNGLBINDBUFFERPROC glad_glBindBuffer;
#define glBindBuffer glad_glBindBuffer
GLAD_API_CALL PFNGLBINDBUFFERBASEPROC glad_glBindBufferBase;
#define glBindBufferBase glad_glBindBufferBase
GLAD_API_CALL PFNGLBINDBUFFERRANGEPROC glad_glBindBufferRange;
#define glBindBufferRange glad_glBindBufferRange
GLAD_API_CALL PFNGLBINDBUFFERSBASEPROC glad_glBindBuffersBase;
#define glBindBuffersBase glad_glBindBuffersBase
GLAD_API_CALL PFNGLBINDBUFFERSRANGEPROC glad_glBindBuffersRange;
#define glBindBuffersRange glad_glBindBuffersRange
GLAD_API_CALL PFNGLBINDFRAGDATALOCATIONPROC glad_glBindFragDataLocation;
#define glBindFragDataLocation glad_glBindFragDataLocation
GLAD_API_CALL PFNGLBINDFRAGDATALOCATIONINDEXEDPROC glad_glBindFragDataLocationIndexed;
#define glBindFragDataLocationIndexed glad_glBindFragDataLocationIndexed
GLAD_API_CALL PFNGLBINDFRAMEBUFFERPROC glad_glBindFramebuffer;
#define glBindFramebuffer glad_glBindFramebuffer
GLAD_API_CALL PFNGLBINDIMAGETEXTUREPROC glad_glBindImageTexture;
#define glBindImageTexture glad_glBindImageTexture
GLAD_API_CALL PFNGLBINDIMAGETEXTURESPROC glad_glBindImageTextures;
#define glBindImageTextures glad_glBindImageTextures
GLAD_API_CALL PFNGLBINDPROGRAMPIPELINEPROC glad_glBindProgramPipeline;
#define glBindProgramPipeline glad_glBindProgramPipeline
GLAD_API_CALL PFNGLBINDRENDERBUFFERPROC glad_glBindRenderbuffer;
#define glBindRenderbuffer glad_glBindRenderbuffer
GLAD_API_CALL PFNGLBINDSAMPLERPROC glad_glBindSampler;
#define glBindSampler glad_glBindSampler
GLAD_API_CALL PFNGLBINDSAMPLERSPROC glad_glBindSamplers;
#define glBindSamplers glad_glBindSamplers
GLAD_API_CALL PFNGLBINDTEXTUREPROC glad_glBindTexture;
#define glBindTexture glad_glBindTexture
GLAD_API_CALL PFNGLBINDTEXTUREUNITPROC glad_glBindTextureUnit;
#define glBindTextureUnit glad_glBindTextureUnit
GLAD_API_CALL PFNGLBINDTEXTURESPROC glad_glBindTextures;
#define glBindTextures glad_glBindTextures
GLAD_API_CALL PFNGLBINDTRANSFORMFEEDBACKPROC glad_glBindTransformFeedback;
#define glBindTransformFeedback glad_glBindTransformFeedback
GLAD_API_CALL PFNGLBINDVERTEXARRAYPROC glad_glBindVertexArray;
#define glBindVertexArray glad_glBindVertexArray
GLAD_API_CALL PFNGLBINDVERTEXBUFFERPROC glad_glBindVertexBuffer;
#define glBindVertexBuffer glad_glBindVertexBuffer
GLAD_API_CALL PFNGLBINDVERTEXBUFFERSPROC glad_glBindVertexBuffers;
#define glBindVertexBuffers glad_glBindVertexBuffers
GLAD_API_CALL PFNGLBITMAPPROC glad_glBitmap;
#define glBitmap glad_glBitmap
GLAD_API_CALL PFNGLBLENDCOLORPROC glad_glBlendColor;
#define glBlendColor glad_glBlendColor
GLAD_API_CALL PFNGLBLENDEQUATIONPROC glad_glBlendEquation;
#define glBlendEquation glad_glBlendEquation
GLAD_API_CALL PFNGLBLENDEQUATIONSEPARATEPROC glad_glBlendEquationSeparate;
#define glBlendEquationSeparate glad_glBlendEquationSeparate
GLAD_API_CALL PFNGLBLENDEQUATIONSEPARATEIPROC glad_glBlendEquationSeparatei;
#define glBlendEquationSeparatei glad_glBlendEquationSeparatei
GLAD_API_CALL PFNGLBLENDEQUATIONIPROC glad_glBlendEquationi;
#define glBlendEquationi glad_glBlendEquationi
GLAD_API_CALL PFNGLBLENDFUNCPROC glad_glBlendFunc;
#define glBlendFunc glad_glBlendFunc
GLAD_API_CALL PFNGLBLENDFUNCSEPARATEPROC glad_glBlendFuncSeparate;
#define glBlendFuncSeparate glad_glBlendFuncSeparate
GLAD_API_CALL PFNGLBLENDFUNCSEPARATEIPROC glad_glBlendFuncSeparatei;
#define glBlendFuncSeparatei glad_glBlendFuncSeparatei
GLAD_API_CALL PFNGLBLENDFUNCIPROC glad_glBlendFunci;
#define glBlendFunci glad_glBlendFunci
GLAD_API_CALL PFNGLBLITFRAMEBUFFERPROC glad_glBlitFramebuffer;
#define glBlitFramebuffer glad_glBlitFramebuffer
GLAD_API_CALL PFNGLBLITNAMEDFRAMEBUFFERPROC glad_glBlitNamedFramebuffer;
#define glBlitNamedFramebuffer glad_glBlitNamedFramebuffer
GLAD_API_CALL PFNGLBUFFERDATAPROC glad_glBufferData;
#define glBufferData glad_glBufferData
GLAD_API_CALL PFNGLBUFFERSTORAGEPROC glad_glBufferStorage;
#define glBufferStorage glad_glBufferStorage
GLAD_API_CALL PFNGLBUFFERSUBDATAPROC glad_glBufferSubData;
#define glBufferSubData glad_glBufferSubData
GLAD_API_CALL PFNGLCALLLISTPROC glad_glCallList;
#define glCallList glad_glCallList
GLAD_API_CALL PFNGLCALLLISTSPROC glad_glCallLists;
#define glCallLists glad_glCallLists
GLAD_API_CALL PFNGLCHECKFRAMEBUFFERSTATUSPROC glad_glCheckFramebufferStatus;
#define glCheckFramebufferStatus glad_glCheckFramebufferStatus
GLAD_API_CALL PFNGLCHECKNAMEDFRAMEBUFFERSTATUSPROC glad_glCheckNamedFramebufferStatus;
#define glCheckNamedFramebufferStatus glad_glCheckNamedFramebufferStatus
GLAD_API_CALL PFNGLCLAMPCOLORPROC glad_glClampColor;
#define glClampColor glad_glClampColor
GLAD_API_CALL PFNGLCLEARPROC glad_glClear;
#define glClear glad_glClear
GLAD_API_CALL PFNGLCLEARACCUMPROC glad_glClearAccum;
#define glClearAccum glad_glClearAccum
GLAD_API_CALL PFNGLCLEARBUFFERDATAPROC glad_glClearBufferData;
#define glClearBufferData glad_glClearBufferData
GLAD_API_CALL PFNGLCLEARBUFFERSUBDATAPROC glad_glClearBufferSubData;
#define glClearBufferSubData glad_glClearBufferSubData
GLAD_API_CALL PFNGLCLEARBUFFERFIPROC glad_glClearBufferfi;
#define glClearBufferfi glad_glClearBufferfi
GLAD_API_CALL PFNGLCLEARBUFFERFVPROC glad_glClearBufferfv;
#define glClearBufferfv glad_glClearBufferfv
GLAD_API_CALL PFNGLCLEARBUFFERIVPROC glad_glClearBufferiv;
#define glClearBufferiv glad_glClearBufferiv
GLAD_API_CALL PFNGLCLEARBUFFERUIVPROC glad_glClearBufferuiv;
#define glClearBufferuiv glad_glClearBufferuiv
GLAD_API_CALL PFNGLCLEARCOLORPROC glad_glClearColor;
#define glClearColor glad_glClearColor
GLAD_API_CALL PFNGLCLEARDEPTHPROC glad_glClearDepth;
#define glClearDepth glad_glClearDepth
GLAD_API_CALL PFNGLCLEARDEPTHFPROC glad_glClearDepthf;
#define glClearDepthf glad_glClearDepthf
GLAD_API_CALL PFNGLCLEARINDEXPROC glad_glClearIndex;
#define glClearIndex glad_glClearIndex
GLAD_API_CALL PFNGLCLEARNAMEDBUFFERDATAPROC glad_glClearNamedBufferData;
#define glClearNamedBufferData glad_glClearNamedBufferData
GLAD_API_CALL PFNGLCLEARNAMEDBUFFERSUBDATAPROC glad_glClearNamedBufferSubData;
#define glClearNamedBufferSubData glad_glClearNamedBufferSubData
GLAD_API_CALL PFNGLCLEARNAMEDFRAMEBUFFERFIPROC glad_glClearNamedFramebufferfi;
#define glClearNamedFramebufferfi glad_glClearNamedFramebufferfi
GLAD_API_CALL PFNGLCLEARNAMEDFRAMEBUFFERFVPROC glad_glClearNamedFramebufferfv;
#define glClearNamedFramebufferfv glad_glClearNamedFramebufferfv
GLAD_API_CALL PFNGLCLEARNAMEDFRAMEBUFFERIVPROC glad_glClearNamedFramebufferiv;
#define glClearNamedFramebufferiv glad_glClearNamedFramebufferiv
GLAD_API_CALL PFNGLCLEARNAMEDFRAMEBUFFERUIVPROC glad_glClearNamedFramebufferuiv;
#define glClearNamedFramebufferuiv glad_glClearNamedFramebufferuiv
GLAD_API_CALL PFNGLCLEARSTENCILPROC glad_glClearStencil;
#define glClearStencil glad_glClearStencil
GLAD_API_CALL PFNGLCLEARTEXIMAGEPROC glad_glClearTexImage;
#define glClearTexImage glad_glClearTexImage
GLAD_API_CALL PFNGLCLEARTEXSUBIMAGEPROC glad_glClearTexSubImage;
#define glClearTexSubImage glad_glClearTexSubImage
GLAD_API_CALL PFNGLCLIENTACTIVETEXTUREPROC glad_glClientActiveTexture;
#define glClientActiveTexture glad_glClientActiveTexture
GLAD_API_CALL PFNGLCLIENTWAITSYNCPROC glad_glClientWaitSync;
#define glClientWaitSync glad_glClientWaitSync
GLAD_API_CALL PFNGLCLIPCONTROLPROC glad_glClipControl;
#define glClipControl glad_glClipControl
GLAD_API_CALL PFNGLCLIPPLANEPROC glad_glClipPlane;
#define glClipPlane glad_glClipPlane
GLAD_API_CALL PFNGLCOLOR3BPROC glad_glColor3b;
#define glColor3b glad_glColor3b
GLAD_API_CALL PFNGLCOLOR3BVPROC glad_glColor3bv;
#define glColor3bv glad_glColor3bv
GLAD_API_CALL PFNGLCOLOR3DPROC glad_glColor3d;
#define glColor3d glad_glColor3d
GLAD_API_CALL PFNGLCOLOR3DVPROC glad_glColor3dv;
#define glColor3dv glad_glColor3dv
GLAD_API_CALL PFNGLCOLOR3FPROC glad_glColor3f;
#define glColor3f glad_glColor3f
GLAD_API_CALL PFNGLCOLOR3FVPROC glad_glColor3fv;
#define glColor3fv glad_glColor3fv
GLAD_API_CALL PFNGLCOLOR3IPROC glad_glColor3i;
#define glColor3i glad_glColor3i
GLAD_API_CALL PFNGLCOLOR3IVPROC glad_glColor3iv;
#define glColor3iv glad_glColor3iv
GLAD_API_CALL PFNGLCOLOR3SPROC glad_glColor3s;
#define glColor3s glad_glColor3s
GLAD_API_CALL PFNGLCOLOR3SVPROC glad_glColor3sv;
#define glColor3sv glad_glColor3sv
GLAD_API_CALL PFNGLCOLOR3UBPROC glad_glColor3ub;
#define glColor3ub glad_glColor3ub
GLAD_API_CALL PFNGLCOLOR3UBVPROC glad_glColor3ubv;
#define glColor3ubv glad_glColor3ubv
GLAD_API_CALL PFNGLCOLOR3UIPROC glad_glColor3ui;
#define glColor3ui glad_glColor3ui
GLAD_API_CALL PFNGLCOLOR3UIVPROC glad_glColor3uiv;
#define glColor3uiv glad_glColor3uiv
GLAD_API_CALL PFNGLCOLOR3USPROC glad_glColor3us;
#define glColor3us glad_glColor3us
GLAD_API_CALL PFNGLCOLOR3USVPROC glad_glColor3usv;
#define glColor3usv glad_glColor3usv
GLAD_API_CALL PFNGLCOLOR4BPROC glad_glColor4b;
#define glColor4b glad_glColor4b
GLAD_API_CALL PFNGLCOLOR4BVPROC glad_glColor4bv;
#define glColor4bv glad_glColor4bv
GLAD_API_CALL PFNGLCOLOR4DPROC glad_glColor4d;
#define glColor4d glad_glColor4d
GLAD_API_CALL PFNGLCOLOR4DVPROC glad_glColor4dv;
#define glColor4dv glad_glColor4dv
GLAD_API_CALL PFNGLCOLOR4FPROC glad_glColor4f;
#define glColor4f glad_glColor4f
GLAD_API_CALL PFNGLCOLOR4FVPROC glad_glColor4fv;
#define glColor4fv glad_glColor4fv
GLAD_API_CALL PFNGLCOLOR4IPROC glad_glColor4i;
#define glColor4i glad_glColor4i
GLAD_API_CALL PFNGLCOLOR4IVPROC glad_glColor4iv;
#define glColor4iv glad_glColor4iv
GLAD_API_CALL PFNGLCOLOR4SPROC glad_glColor4s;
#define glColor4s glad_glColor4s
GLAD_API_CALL PFNGLCOLOR4SVPROC glad_glColor4sv;
#define glColor4sv glad_glColor4sv
GLAD_API_CALL PFNGLCOLOR4UBPROC glad_glColor4ub;
#define glColor4ub glad_glColor4ub
GLAD_API_CALL PFNGLCOLOR4UBVPROC glad_glColor4ubv;
#define glColor4ubv glad_glColor4ubv
GLAD_API_CALL PFNGLCOLOR4UIPROC glad_glColor4ui;
#define glColor4ui glad_glColor4ui
GLAD_API_CALL PFNGLCOLOR4UIVPROC glad_glColor4uiv;
#define glColor4uiv glad_glColor4uiv
GLAD_API_CALL PFNGLCOLOR4USPROC glad_glColor4us;
#define glColor4us glad_glColor4us
GLAD_API_CALL PFNGLCOLOR4USVPROC glad_glColor4usv;
#define glColor4usv glad_glColor4usv
GLAD_API_CALL PFNGLCOLORMASKPROC glad_glColorMask;
#define glColorMask glad_glColorMask
GLAD_API_CALL PFNGLCOLORMASKIPROC glad_glColorMaski;
#define glColorMaski glad_glColorMaski
GLAD_API_CALL PFNGLCOLORMATERIALPROC glad_glColorMaterial;
#define glColorMaterial glad_glColorMaterial
GLAD_API_CALL PFNGLCOLORP3UIPROC glad_glColorP3ui;
#define glColorP3ui glad_glColorP3ui
GLAD_API_CALL PFNGLCOLORP3UIVPROC glad_glColorP3uiv;
#define glColorP3uiv glad_glColorP3uiv
GLAD_API_CALL PFNGLCOLORP4UIPROC glad_glColorP4ui;
#define glColorP4ui glad_glColorP4ui
GLAD_API_CALL PFNGLCOLORP4UIVPROC glad_glColorP4uiv;
#define glColorP4uiv glad_glColorP4uiv
GLAD_API_CALL PFNGLCOLORPOINTERPROC glad_glColorPointer;
#define glColorPointer glad_glColorPointer
GLAD_API_CALL PFNGLCOMPILESHADERPROC glad_glCompileShader;
#define glCompileShader glad_glCompileShader
GLAD_API_CALL PFNGLCOMPRESSEDTEXIMAGE1DPROC glad_glCompressedTexImage1D;
#define glCompressedTexImage1D glad_glCompressedTexImage1D
GLAD_API_CALL PFNGLCOMPRESSEDTEXIMAGE2DPROC glad_glCompressedTexImage2D;
#define glCompressedTexImage2D glad_glCompressedTexImage2D
GLAD_API_CALL PFNGLCOMPRESSEDTEXIMAGE3DPROC glad_glCompressedTexImage3D;
#define glCompressedTexImage3D glad_glCompressedTexImage3D
GLAD_API_CALL PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC glad_glCompressedTexSubImage1D;
#define glCompressedTexSubImage1D glad_glCompressedTexSubImage1D
GLAD_API_CALL PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC glad_glCompressedTexSubImage2D;
#define glCompressedTexSubImage2D glad_glCompressedTexSubImage2D
GLAD_API_CALL PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC glad_glCompressedTexSubImage3D;
#define glCompressedTexSubImage3D glad_glCompressedTexSubImage3D
GLAD_API_CALL PFNGLCOMPRESSEDTEXTURESUBIMAGE1DPROC glad_glCompressedTextureSubImage1D;
#define glCompressedTextureSubImage1D glad_glCompressedTextureSubImage1D
GLAD_API_CALL PFNGLCOMPRESSEDTEXTURESUBIMAGE2DPROC glad_glCompressedTextureSubImage2D;
#define glCompressedTextureSubImage2D glad_glCompressedTextureSubImage2D
GLAD_API_CALL PFNGLCOMPRESSEDTEXTURESUBIMAGE3DPROC glad_glCompressedTextureSubImage3D;
#define glCompressedTextureSubImage3D glad_glCompressedTextureSubImage3D
GLAD_API_CALL PFNGLCOPYBUFFERSUBDATAPROC glad_glCopyBufferSubData;
#define glCopyBufferSubData glad_glCopyBufferSubData
GLAD_API_CALL PFNGLCOPYIMAGESUBDATAPROC glad_glCopyImageSubData;
#define glCopyImageSubData glad_glCopyImageSubData
GLAD_API_CALL PFNGLCOPYNAMEDBUFFERSUBDATAPROC glad_glCopyNamedBufferSubData;
#define glCopyNamedBufferSubData glad_glCopyNamedBufferSubData
GLAD_API_CALL PFNGLCOPYPIXELSPROC glad_glCopyPixels;
#define glCopyPixels glad_glCopyPixels
GLAD_API_CALL PFNGLCOPYTEXIMAGE1DPROC glad_glCopyTexImage1D;
#define glCopyTexImage1D glad_glCopyTexImage1D
GLAD_API_CALL PFNGLCOPYTEXIMAGE2DPROC glad_glCopyTexImage2D;
#define glCopyTexImage2D glad_glCopyTexImage2D
GLAD_API_CALL PFNGLCOPYTEXSUBIMAGE1DPROC glad_glCopyTexSubImage1D;
#define glCopyTexSubImage1D glad_glCopyTexSubImage1D
GLAD_API_CALL PFNGLCOPYTEXSUBIMAGE2DPROC glad_glCopyTexSubImage2D;
#define glCopyTexSubImage2D glad_glCopyTexSubImage2D
GLAD_API_CALL PFNGLCOPYTEXSUBIMAGE3DPROC glad_glCopyTexSubImage3D;
#define glCopyTexSubImage3D glad_glCopyTexSubImage3D
GLAD_API_CALL PFNGLCOPYTEXTURESUBIMAGE1DPROC glad_glCopyTextureSubImage1D;
#define glCopyTextureSubImage1D glad_glCopyTextureSubImage1D
GLAD_API_CALL PFNGLCOPYTEXTURESUBIMAGE2DPROC glad_glCopyTextureSubImage2D;
#define glCopyTextureSubImage2D glad_glCopyTextureSubImage2D
GLAD_API_CALL PFNGLCOPYTEXTURESUBIMAGE3DPROC glad_glCopyTextureSubImage3D;
#define glCopyTextureSubImage3D glad_glCopyTextureSubImage3D
GLAD_API_CALL PFNGLCREATEBUFFERSPROC glad_glCreateBuffers;
#define glCreateBuffers glad_glCreateBuffers
GLAD_API_CALL PFNGLCREATEFRAMEBUFFERSPROC glad_glCreateFramebuffers;
#define glCreateFramebuffers glad_glCreateFramebuffers
GLAD_API_CALL PFNGLCREATEPROGRAMPROC glad_glCreateProgram;
#define glCreateProgram glad_glCreateProgram
GLAD_API_CALL PFNGLCREATEPROGRAMPIPELINESPROC glad_glCreateProgramPipelines;
#define glCreateProgramPipelines glad_glCreateProgramPipelines
GLAD_API_CALL PFNGLCREATEQUERIESPROC glad_glCreateQueries;
#define glCreateQueries glad_glCreateQueries
GLAD_API_CALL PFNGLCREATERENDERBUFFERSPROC glad_glCreateRenderbuffers;
#define glCreateRenderbuffers glad_glCreateRenderbuffers
GLAD_API_CALL PFNGLCREATESAMPLERSPROC glad_glCreateSamplers;
#define glCreateSamplers glad_glCreateSamplers
GLAD_API_CALL PFNGLCREATESHADERPROC glad_glCreateShader;
#define glCreateShader glad_glCreateShader
GLAD_API_CALL PFNGLCREATESHADERPROGRAMVPROC glad_glCreateShaderProgramv;
#define glCreateShaderProgramv glad_glCreateShaderProgramv
GLAD_API_CALL PFNGLCREATETEXTURESPROC glad_glCreateTextures;
#define glCreateTextures glad_glCreateTextures
GLAD_API_CALL PFNGLCREATETRANSFORMFEEDBACKSPROC glad_glCreateTransformFeedbacks;
#define glCreateTransformFeedbacks glad_glCreateTransformFeedbacks
GLAD_API_CALL PFNGLCREATEVERTEXARRAYSPROC glad_glCreateVertexArrays;
#define glCreateVertexArrays glad_glCreateVertexArrays
GLAD_API_CALL PFNGLCULLFACEPROC glad_glCullFace;
#define glCullFace glad_glCullFace
GLAD_API_CALL PFNGLDEBUGMESSAGECALLBACKPROC glad_glDebugMessageCallback;
#define glDebugMessageCallback glad_glDebugMessageCallback
GLAD_API_CALL PFNGLDEBUGMESSAGECONTROLPROC glad_glDebugMessageControl;
#define glDebugMessageControl glad_glDebugMessageControl
GLAD_API_CALL PFNGLDEBUGMESSAGEINSERTPROC glad_glDebugMessageInsert;
#define glDebugMessageInsert glad_glDebugMessageInsert
GLAD_API_CALL PFNGLDELETEBUFFERSPROC glad_glDeleteBuffers;
#define glDeleteBuffers glad_glDeleteBuffers
GLAD_API_CALL PFNGLDELETEFRAMEBUFFERSPROC glad_glDeleteFramebuffers;
#define glDeleteFramebuffers glad_glDeleteFramebuffers
GLAD_API_CALL PFNGLDELETELISTSPROC glad_glDeleteLists;
#define glDeleteLists glad_glDeleteLists
GLAD_API_CALL PFNGLDELETEPROGRAMPROC glad_glDeleteProgram;
#define glDeleteProgram glad_glDeleteProgram
GLAD_API_CALL PFNGLDELETEPROGRAMPIPELINESPROC glad_glDeleteProgramPipelines;
#define glDeleteProgramPipelines glad_glDeleteProgramPipelines
GLAD_API_CALL PFNGLDELETEQUERIESPROC glad_glDeleteQueries;
#define glDeleteQueries glad_glDeleteQueries
GLAD_API_CALL PFNGLDELETERENDERBUFFERSPROC glad_glDeleteRenderbuffers;
#define glDeleteRenderbuffers glad_glDeleteRenderbuffers
GLAD_API_CALL PFNGLDELETESAMPLERSPROC glad_glDeleteSamplers;
#define glDeleteSamplers glad_glDeleteSamplers
GLAD_API_CALL PFNGLDELETESHADERPROC glad_glDeleteShader;
#define glDeleteShader glad_glDeleteShader
GLAD_API_CALL PFNGLDELETESYNCPROC glad_glDeleteSync;
#define glDeleteSync glad_glDeleteSync
GLAD_API_CALL PFNGLDELETETEXTURESPROC glad_glDeleteTextures;
#define glDeleteTextures glad_glDeleteTextures
GLAD_API_CALL PFNGLDELETETRANSFORMFEEDBACKSPROC glad_glDeleteTransformFeedbacks;
#define glDeleteTransformFeedbacks glad_glDeleteTransformFeedbacks
GLAD_API_CALL PFNGLDELETEVERTEXARRAYSPROC glad_glDeleteVertexArrays;
#define glDeleteVertexArrays glad_glDeleteVertexArrays
GLAD_API_CALL PFNGLDEPTHFUNCPROC glad_glDepthFunc;
#define glDepthFunc glad_glDepthFunc
GLAD_API_CALL PFNGLDEPTHMASKPROC glad_glDepthMask;
#define glDepthMask glad_glDepthMask
GLAD_API_CALL PFNGLDEPTHRANGEPROC glad_glDepthRange;
#define glDepthRange glad_glDepthRange
GLAD_API_CALL PFNGLDEPTHRANGEARRAYVPROC glad_glDepthRangeArrayv;
#define glDepthRangeArrayv glad_glDepthRangeArrayv
GLAD_API_CALL PFNGLDEPTHRANGEINDEXEDPROC glad_glDepthRangeIndexed;
#define glDepthRangeIndexed glad_glDepthRangeIndexed
GLAD_API_CALL PFNGLDEPTHRANGEFPROC glad_glDepthRangef;
#define glDepthRangef glad_glDepthRangef
GLAD_API_CALL PFNGLDETACHSHADERPROC glad_glDetachShader;
#define glDetachShader glad_glDetachShader
GLAD_API_CALL PFNGLDISABLEPROC glad_glDisable;
#define glDisable glad_glDisable
GLAD_API_CALL PFNGLDISABLECLIENTSTATEPROC glad_glDisableClientState;
#define glDisableClientState glad_glDisableClientState
GLAD_API_CALL PFNGLDISABLEVERTEXARRAYATTRIBPROC glad_glDisableVertexArrayAttrib;
#define glDisableVertexArrayAttrib glad_glDisableVertexArrayAttrib
GLAD_API_CALL PFNGLDISABLEVERTEXATTRIBARRAYPROC glad_glDisableVertexAttribArray;
#define glDisableVertexAttribArray glad_glDisableVertexAttribArray
GLAD_API_CALL PFNGLDISABLEIPROC glad_glDisablei;
#define glDisablei glad_glDisablei
GLAD_API_CALL PFNGLDISPATCHCOMPUTEPROC glad_glDispatchCompute;
#define glDispatchCompute glad_glDispatchCompute
GLAD_API_CALL PFNGLDISPATCHCOMPUTEINDIRECTPROC glad_glDispatchComputeIndirect;
#define glDispatchComputeIndirect glad_glDispatchComputeIndirect
GLAD_API_CALL PFNGLDRAWARRAYSPROC glad_glDrawArrays;
#define glDrawArrays glad_glDrawArrays
GLAD_API_CALL PFNGLDRAWARRAYSINDIRECTPROC glad_glDrawArraysIndirect;
#define glDrawArraysIndirect glad_glDrawArraysIndirect
GLAD_API_CALL PFNGLDRAWARRAYSINSTANCEDPROC glad_glDrawArraysInstanced;
#define glDrawArraysInstanced glad_glDrawArraysInstanced
GLAD_API_CALL PFNGLDRAWARRAYSINSTANCEDBASEINSTANCEPROC glad_glDrawArraysInstancedBaseInstance;
#define glDrawArraysInstancedBaseInstance glad_glDrawArraysInstancedBaseInstance
GLAD_API_CALL PFNGLDRAWBUFFERPROC glad_glDrawBuffer;
#define glDrawBuffer glad_glDrawBuffer
GLAD_API_CALL PFNGLDRAWBUFFERSPROC glad_glDrawBuffers;
#define glDrawBuffers glad_glDrawBuffers
GLAD_API_CALL PFNGLDRAWELEMENTSPROC glad_glDrawElements;
#define glDrawElements glad_glDrawElements
GLAD_API_CALL PFNGLDRAWELEMENTSBASEVERTEXPROC glad_glDrawElementsBaseVertex;
#define glDrawElementsBaseVertex glad_glDrawElementsBaseVertex
GLAD_API_CALL PFNGLDRAWELEMENTSINDIRECTPROC glad_glDrawElementsIndirect;
#define glDrawElementsIndirect glad_glDrawElementsIndirect
GLAD_API_CALL PFNGLDRAWELEMENTSINSTANCEDPROC glad_glDrawElementsInstanced;
#define glDrawElementsInstanced glad_glDrawElementsInstanced
GLAD_API_CALL PFNGLDRAWELEMENTSINSTANCEDBASEINSTANCEPROC glad_glDrawElementsInstancedBaseInstance;
#define glDrawElementsInstancedBaseInstance glad_glDrawElementsInstancedBaseInstance
GLAD_API_CALL PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC glad_glDrawElementsInstancedBaseVertex;
#define glDrawElementsInstancedBaseVertex glad_glDrawElementsInstancedBaseVertex
GLAD_API_CALL PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCEPROC glad_glDrawElementsInstancedBaseVertexBaseInstance;
#define glDrawElementsInstancedBaseVertexBaseInstance glad_glDrawElementsInstancedBaseVertexBaseInstance
GLAD_API_CALL PFNGLDRAWPIXELSPROC glad_glDrawPixels;
#define glDrawPixels glad_glDrawPixels
GLAD_API_CALL PFNGLDRAWRANGEELEMENTSPROC glad_glDrawRangeElements;
#define glDrawRangeElements glad_glDrawRangeElements
GLAD_API_CALL PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC glad_glDrawRangeElementsBaseVertex;
#define glDrawRangeElementsBaseVertex glad_glDrawRangeElementsBaseVertex
GLAD_API_CALL PFNGLDRAWTRANSFORMFEEDBACKPROC glad_glDrawTransformFeedback;
#define glDrawTransformFeedback glad_glDrawTransformFeedback
GLAD_API_CALL PFNGLDRAWTRANSFORMFEEDBACKINSTANCEDPROC glad_glDrawTransformFeedbackInstanced;
#define glDrawTransformFeedbackInstanced glad_glDrawTransformFeedbackInstanced
GLAD_API_CALL PFNGLDRAWTRANSFORMFEEDBACKSTREAMPROC glad_glDrawTransformFeedbackStream;
#define glDrawTransformFeedbackStream glad_glDrawTransformFeedbackStream
GLAD_API_CALL PFNGLDRAWTRANSFORMFEEDBACKSTREAMINSTANCEDPROC glad_glDrawTransformFeedbackStreamInstanced;
#define glDrawTransformFeedbackStreamInstanced glad_glDrawTransformFeedbackStreamInstanced
GLAD_API_CALL PFNGLEDGEFLAGPROC glad_glEdgeFlag;
#define glEdgeFlag glad_glEdgeFlag
GLAD_API_CALL PFNGLEDGEFLAGPOINTERPROC glad_glEdgeFlagPointer;
#define glEdgeFlagPointer glad_glEdgeFlagPointer
GLAD_API_CALL PFNGLEDGEFLAGVPROC glad_glEdgeFlagv;
#define glEdgeFlagv glad_glEdgeFlagv
GLAD_API_CALL PFNGLENABLEPROC glad_glEnable;
#define glEnable glad_glEnable
GLAD_API_CALL PFNGLENABLECLIENTSTATEPROC glad_glEnableClientState;
#define glEnableClientState glad_glEnableClientState
GLAD_API_CALL PFNGLENABLEVERTEXARRAYATTRIBPROC glad_glEnableVertexArrayAttrib;
#define glEnableVertexArrayAttrib glad_glEnableVertexArrayAttrib
GLAD_API_CALL PFNGLENABLEVERTEXATTRIBARRAYPROC glad_glEnableVertexAttribArray;
#define glEnableVertexAttribArray glad_glEnableVertexAttribArray
GLAD_API_CALL PFNGLENABLEIPROC glad_glEnablei;
#define glEnablei glad_glEnablei
GLAD_API_CALL PFNGLENDPROC glad_glEnd;
#define glEnd glad_glEnd
GLAD_API_CALL PFNGLENDCONDITIONALRENDERPROC glad_glEndConditionalRender;
#define glEndConditionalRender glad_glEndConditionalRender
GLAD_API_CALL PFNGLENDLISTPROC glad_glEndList;
#define glEndList glad_glEndList
GLAD_API_CALL PFNGLENDQUERYPROC glad_glEndQuery;
#define glEndQuery glad_glEndQuery
GLAD_API_CALL PFNGLENDQUERYINDEXEDPROC glad_glEndQueryIndexed;
#define glEndQueryIndexed glad_glEndQueryIndexed
GLAD_API_CALL PFNGLENDTRANSFORMFEEDBACKPROC glad_glEndTransformFeedback;
#define glEndTransformFeedback glad_glEndTransformFeedback
GLAD_API_CALL PFNGLEVALCOORD1DPROC glad_glEvalCoord1d;
#define glEvalCoord1d glad_glEvalCoord1d
GLAD_API_CALL PFNGLEVALCOORD1DVPROC glad_glEvalCoord1dv;
#define glEvalCoord1dv glad_glEvalCoord1dv
GLAD_API_CALL PFNGLEVALCOORD1FPROC glad_glEvalCoord1f;
#define glEvalCoord1f glad_glEvalCoord1f
GLAD_API_CALL PFNGLEVALCOORD1FVPROC glad_glEvalCoord1fv;
#define glEvalCoord1fv glad_glEvalCoord1fv
GLAD_API_CALL PFNGLEVALCOORD2DPROC glad_glEvalCoord2d;
#define glEvalCoord2d glad_glEvalCoord2d
GLAD_API_CALL PFNGLEVALCOORD2DVPROC glad_glEvalCoord2dv;
#define glEvalCoord2dv glad_glEvalCoord2dv
GLAD_API_CALL PFNGLEVALCOORD2FPROC glad_glEvalCoord2f;
#define glEvalCoord2f glad_glEvalCoord2f
GLAD_API_CALL PFNGLEVALCOORD2FVPROC glad_glEvalCoord2fv;
#define glEvalCoord2fv glad_glEvalCoord2fv
GLAD_API_CALL PFNGLEVALMESH1PROC glad_glEvalMesh1;
#define glEvalMesh1 glad_glEvalMesh1
GLAD_API_CALL PFNGLEVALMESH2PROC glad_glEvalMesh2;
#define glEvalMesh2 glad_glEvalMesh2
GLAD_API_CALL PFNGLEVALPOINT1PROC glad_glEvalPoint1;
#define glEvalPoint1 glad_glEvalPoint1
GLAD_API_CALL PFNGLEVALPOINT2PROC glad_glEvalPoint2;
#define glEvalPoint2 glad_glEvalPoint2
GLAD_API_CALL PFNGLFEEDBACKBUFFERPROC glad_glFeedbackBuffer;
#define glFeedbackBuffer glad_glFeedbackBuffer
GLAD_API_CALL PFNGLFENCESYNCPROC glad_glFenceSync;
#define glFenceSync glad_glFenceSync
GLAD_API_CALL PFNGLFINISHPROC glad_glFinish;
#define glFinish glad_glFinish
GLAD_API_CALL PFNGLFLUSHPROC glad_glFlush;
#define glFlush glad_glFlush
GLAD_API_CALL PFNGLFLUSHMAPPEDBUFFERRANGEPROC glad_glFlushMappedBufferRange;
#define glFlushMappedBufferRange glad_glFlushMappedBufferRange
GLAD_API_CALL PFNGLFLUSHMAPPEDNAMEDBUFFERRANGEPROC glad_glFlushMappedNamedBufferRange;
#define glFlushMappedNamedBufferRange glad_glFlushMappedNamedBufferRange
GLAD_API_CALL PFNGLFOGCOORDPOINTERPROC glad_glFogCoordPointer;
#define glFogCoordPointer glad_glFogCoordPointer
GLAD_API_CALL PFNGLFOGCOORDDPROC glad_glFogCoordd;
#define glFogCoordd glad_glFogCoordd
GLAD_API_CALL PFNGLFOGCOORDDVPROC glad_glFogCoorddv;
#define glFogCoorddv glad_glFogCoorddv
GLAD_API_CALL PFNGLFOGCOORDFPROC glad_glFogCoordf;
#define glFogCoordf glad_glFogCoordf
GLAD_API_CALL PFNGLFOGCOORDFVPROC glad_glFogCoordfv;
#define glFogCoordfv glad_glFogCoordfv
GLAD_API_CALL PFNGLFOGFPROC glad_glFogf;
#define glFogf glad_glFogf
GLAD_API_CALL PFNGLFOGFVPROC glad_glFogfv;
#define glFogfv glad_glFogfv
GLAD_API_CALL PFNGLFOGIPROC glad_glFogi;
#define glFogi glad_glFogi
GLAD_API_CALL PFNGLFOGIVPROC glad_glFogiv;
#define glFogiv glad_glFogiv
GLAD_API_CALL PFNGLFRAMEBUFFERPARAMETERIPROC glad_glFramebufferParameteri;
#define glFramebufferParameteri glad_glFramebufferParameteri
GLAD_API_CALL PFNGLFRAMEBUFFERRENDERBUFFERPROC glad_glFramebufferRenderbuffer;
#define glFramebufferRenderbuffer glad_glFramebufferRenderbuffer
GLAD_API_CALL PFNGLFRAMEBUFFERTEXTUREPROC glad_glFramebufferTexture;
#define glFramebufferTexture glad_glFramebufferTexture
GLAD_API_CALL PFNGLFRAMEBUFFERTEXTURE1DPROC glad_glFramebufferTexture1D;
#define glFramebufferTexture1D glad_glFramebufferTexture1D
GLAD_API_CALL PFNGLFRAMEBUFFERTEXTURE2DPROC glad_glFramebufferTexture2D;
#define glFramebufferTexture2D glad_glFramebufferTexture2D
GLAD_API_CALL PFNGLFRAMEBUFFERTEXTURE3DPROC glad_glFramebufferTexture3D;
#define glFramebufferTexture3D glad_glFramebufferTexture3D
GLAD_API_CALL PFNGLFRAMEBUFFERTEXTURELAYERPROC glad_glFramebufferTextureLayer;
#define glFramebufferTextureLayer glad_glFramebufferTextureLayer
GLAD_API_CALL PFNGLFRONTFACEPROC glad_glFrontFace;
#define glFrontFace glad_glFrontFace
GLAD_API_CALL PFNGLFRUSTUMPROC glad_glFrustum;
#define glFrustum glad_glFrustum
GLAD_API_CALL PFNGLGENBUFFERSPROC glad_glGenBuffers;
#define glGenBuffers glad_glGenBuffers
GLAD_API_CALL PFNGLGENFRAMEBUFFERSPROC glad_glGenFramebuffers;
#define glGenFramebuffers glad_glGenFramebuffers
GLAD_API_CALL PFNGLGENLISTSPROC glad_glGenLists;
#define glGenLists glad_glGenLists
GLAD_API_CALL PFNGLGENPROGRAMPIPELINESPROC glad_glGenProgramPipelines;
#define glGenProgramPipelines glad_glGenProgramPipelines
GLAD_API_CALL PFNGLGENQUERIESPROC glad_glGenQueries;
#define glGenQueries glad_glGenQueries
GLAD_API_CALL PFNGLGENRENDERBUFFERSPROC glad_glGenRenderbuffers;
#define glGenRenderbuffers glad_glGenRenderbuffers
GLAD_API_CALL PFNGLGENSAMPLERSPROC glad_glGenSamplers;
#define glGenSamplers glad_glGenSamplers
GLAD_API_CALL PFNGLGENTEXTURESPROC glad_glGenTextures;
#define glGenTextures glad_glGenTextures
GLAD_API_CALL PFNGLGENTRANSFORMFEEDBACKSPROC glad_glGenTransformFeedbacks;
#define glGenTransformFeedbacks glad_glGenTransformFeedbacks
GLAD_API_CALL PFNGLGENVERTEXARRAYSPROC glad_glGenVertexArrays;
#define glGenVertexArrays glad_glGenVertexArrays
GLAD_API_CALL PFNGLGENERATEMIPMAPPROC glad_glGenerateMipmap;
#define glGenerateMipmap glad_glGenerateMipmap
GLAD_API_CALL PFNGLGENERATETEXTUREMIPMAPPROC glad_glGenerateTextureMipmap;
#define glGenerateTextureMipmap glad_glGenerateTextureMipmap
GLAD_API_CALL PFNGLGETACTIVEATOMICCOUNTERBUFFERIVPROC glad_glGetActiveAtomicCounterBufferiv;
#define glGetActiveAtomicCounterBufferiv glad_glGetActiveAtomicCounterBufferiv
GLAD_API_CALL PFNGLGETACTIVEATTRIBPROC glad_glGetActiveAttrib;
#define glGetActiveAttrib glad_glGetActiveAttrib
GLAD_API_CALL PFNGLGETACTIVESUBROUTINENAMEPROC glad_glGetActiveSubroutineName;
#define glGetActiveSubroutineName glad_glGetActiveSubroutineName
GLAD_API_CALL PFNGLGETACTIVESUBROUTINEUNIFORMNAMEPROC glad_glGetActiveSubroutineUniformName;
#define glGetActiveSubroutineUniformName glad_glGetActiveSubroutineUniformName
GLAD_API_CALL PFNGLGETACTIVESUBROUTINEUNIFORMIVPROC glad_glGetActiveSubroutineUniformiv;
#define glGetActiveSubroutineUniformiv glad_glGetActiveSubroutineUniformiv
GLAD_API_CALL PFNGLGETACTIVEUNIFORMPROC glad_glGetActiveUniform;
#define glGetActiveUniform glad_glGetActiveUniform
GLAD_API_CALL PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC glad_glGetActiveUniformBlockName;
#define glGetActiveUniformBlockName glad_glGetActiveUniformBlockName
GLAD_API_CALL PFNGLGETACTIVEUNIFORMBLOCKIVPROC glad_glGetActiveUniformBlockiv;
#define glGetActiveUniformBlockiv glad_glGetActiveUniformBlockiv
GLAD_API_CALL PFNGLGETACTIVEUNIFORMNAMEPROC glad_glGetActiveUniformName;
#define glGetActiveUniformName glad_glGetActiveUniformName
GLAD_API_CALL PFNGLGETACTIVEUNIFORMSIVPROC glad_glGetActiveUniformsiv;
#define glGetActiveUniformsiv glad_glGetActiveUniformsiv
GLAD_API_CALL PFNGLGETATTACHEDSHADERSPROC glad_glGetAttachedShaders;
#define glGetAttachedShaders glad_glGetAttachedShaders
GLAD_API_CALL PFNGLGETATTRIBLOCATIONPROC glad_glGetAttribLocation;
#define glGetAttribLocation glad_glGetAttribLocation
GLAD_API_CALL PFNGLGETBOOLEANI_VPROC glad_glGetBooleani_v;
#define glGetBooleani_v glad_glGetBooleani_v
GLAD_API_CALL PFNGLGETBOOLEANVPROC glad_glGetBooleanv;
#define glGetBooleanv glad_glGetBooleanv
GLAD_API_CALL PFNGLGETBUFFERPARAMETERI64VPROC glad_glGetBufferParameteri64v;
#define glGetBufferParameteri64v glad_glGetBufferParameteri64v
GLAD_API_CALL PFNGLGETBUFFERPARAMETERIVPROC glad_glGetBufferParameteriv;
#define glGetBufferParameteriv glad_glGetBufferParameteriv
GLAD_API_CALL PFNGLGETBUFFERPOINTERVPROC glad_glGetBufferPointerv;
#define glGetBufferPointerv glad_glGetBufferPointerv
GLAD_API_CALL PFNGLGETBUFFERSUBDATAPROC glad_glGetBufferSubData;
#define glGetBufferSubData glad_glGetBufferSubData
GLAD_API_CALL PFNGLGETCLIPPLANEPROC glad_glGetClipPlane;
#define glGetClipPlane glad_glGetClipPlane
GLAD_API_CALL PFNGLGETCOMPRESSEDTEXIMAGEPROC glad_glGetCompressedTexImage;
#define glGetCompressedTexImage glad_glGetCompressedTexImage
GLAD_API_CALL PFNGLGETCOMPRESSEDTEXTUREIMAGEPROC glad_glGetCompressedTextureImage;
#define glGetCompressedTextureImage glad_glGetCompressedTextureImage
GLAD_API_CALL PFNGLGETCOMPRESSEDTEXTURESUBIMAGEPROC glad_glGetCompressedTextureSubImage;
#define glGetCompressedTextureSubImage glad_glGetCompressedTextureSubImage
GLAD_API_CALL PFNGLGETDEBUGMESSAGELOGPROC glad_glGetDebugMessageLog;
#define glGetDebugMessageLog glad_glGetDebugMessageLog
GLAD_API_CALL PFNGLGETDOUBLEI_VPROC glad_glGetDoublei_v;
#define glGetDoublei_v glad_glGetDoublei_v
GLAD_API_CALL PFNGLGETDOUBLEVPROC glad_glGetDoublev;
#define glGetDoublev glad_glGetDoublev
GLAD_API_CALL PFNGLGETERRORPROC glad_glGetError;
#define glGetError glad_glGetError
GLAD_API_CALL PFNGLGETFLOATI_VPROC glad_glGetFloati_v;
#define glGetFloati_v glad_glGetFloati_v
GLAD_API_CALL PFNGLGETFLOATVPROC glad_glGetFloatv;
#define glGetFloatv glad_glGetFloatv
GLAD_API_CALL PFNGLGETFRAGDATAINDEXPROC glad_glGetFragDataIndex;
#define glGetFragDataIndex glad_glGetFragDataIndex
GLAD_API_CALL PFNGLGETFRAGDATALOCATIONPROC glad_glGetFragDataLocation;
#define glGetFragDataLocation glad_glGetFragDataLocation
GLAD_API_CALL PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC glad_glGetFramebufferAttachmentParameteriv;
#define glGetFramebufferAttachmentParameteriv glad_glGetFramebufferAttachmentParameteriv
GLAD_API_CALL PFNGLGETFRAMEBUFFERPARAMETERIVPROC glad_glGetFramebufferParameteriv;
#define glGetFramebufferParameteriv glad_glGetFramebufferParameteriv
GLAD_API_CALL PFNGLGETGRAPHICSRESETSTATUSPROC glad_glGetGraphicsResetStatus;
#define glGetGraphicsResetStatus glad_glGetGraphicsResetStatus
GLAD_API_CALL PFNGLGETGRAPHICSRESETSTATUSARBPROC glad_glGetGraphicsResetStatusARB;
#define glGetGraphicsResetStatusARB glad_glGetGraphicsResetStatusARB
GLAD_API_CALL PFNGLGETINTEGER64I_VPROC glad_glGetInteger64i_v;
#define glGetInteger64i_v glad_glGetInteger64i_v
GLAD_API_CALL PFNGLGETINTEGER64VPROC glad_glGetInteger64v;
#define glGetInteger64v glad_glGetInteger64v
GLAD_API_CALL PFNGLGETINTEGERI_VPROC glad_glGetIntegeri_v;
#define glGetIntegeri_v glad_glGetIntegeri_v
GLAD_API_CALL PFNGLGETINTEGERVPROC glad_glGetIntegerv;
#define glGetIntegerv glad_glGetIntegerv
GLAD_API_CALL PFNGLGETINTERNALFORMATI64VPROC glad_glGetInternalformati64v;
#define glGetInternalformati64v glad_glGetInternalformati64v
GLAD_API_CALL PFNGLGETINTERNALFORMATIVPROC glad_glGetInternalformativ;
#define glGetInternalformativ glad_glGetInternalformativ
GLAD_API_CALL PFNGLGETLIGHTFVPROC glad_glGetLightfv;
#define glGetLightfv glad_glGetLightfv
GLAD_API_CALL PFNGLGETLIGHTIVPROC glad_glGetLightiv;
#define glGetLightiv glad_glGetLightiv
GLAD_API_CALL PFNGLGETMAPDVPROC glad_glGetMapdv;
#define glGetMapdv glad_glGetMapdv
GLAD_API_CALL PFNGLGETMAPFVPROC glad_glGetMapfv;
#define glGetMapfv glad_glGetMapfv
GLAD_API_CALL PFNGLGETMAPIVPROC glad_glGetMapiv;
#define glGetMapiv glad_glGetMapiv
GLAD_API_CALL PFNGLGETMATERIALFVPROC glad_glGetMaterialfv;
#define glGetMaterialfv glad_glGetMaterialfv
GLAD_API_CALL PFNGLGETMATERIALIVPROC glad_glGetMaterialiv;
#define glGetMaterialiv glad_glGetMaterialiv
GLAD_API_CALL PFNGLGETMULTISAMPLEFVPROC glad_glGetMultisamplefv;
#define glGetMultisamplefv glad_glGetMultisamplefv
GLAD_API_CALL PFNGLGETNAMEDBUFFERPARAMETERI64VPROC glad_glGetNamedBufferParameteri64v;
#define glGetNamedBufferParameteri64v glad_glGetNamedBufferParameteri64v
GLAD_API_CALL PFNGLGETNAMEDBUFFERPARAMETERIVPROC glad_glGetNamedBufferParameteriv;
#define glGetNamedBufferParameteriv glad_glGetNamedBufferParameteriv
GLAD_API_CALL PFNGLGETNAMEDBUFFERPOINTERVPROC glad_glGetNamedBufferPointerv;
#define glGetNamedBufferPointerv glad_glGetNamedBufferPointerv
GLAD_API_CALL PFNGLGETNAMEDBUFFERSUBDATAPROC glad_glGetNamedBufferSubData;
#define glGetNamedBufferSubData glad_glGetNamedBufferSubData
GLAD_API_CALL PFNGLGETNAMEDFRAMEBUFFERATTACHMENTPARAMETERIVPROC glad_glGetNamedFramebufferAttachmentParameteriv;
#define glGetNamedFramebufferAttachmentParameteriv glad_glGetNamedFramebufferAttachmentParameteriv
GLAD_API_CALL PFNGLGETNAMEDFRAMEBUFFERPARAMETERIVPROC glad_glGetNamedFramebufferParameteriv;
#define glGetNamedFramebufferParameteriv glad_glGetNamedFramebufferParameteriv
GLAD_API_CALL PFNGLGETNAMEDRENDERBUFFERPARAMETERIVPROC glad_glGetNamedRenderbufferParameteriv;
#define glGetNamedRenderbufferParameteriv glad_glGetNamedRenderbufferParameteriv
GLAD_API_CALL PFNGLGETOBJECTLABELPROC glad_glGetObjectLabel;
#define glGetObjectLabel glad_glGetObjectLabel
GLAD_API_CALL PFNGLGETOBJECTPTRLABELPROC glad_glGetObjectPtrLabel;
#define glGetObjectPtrLabel glad_glGetObjectPtrLabel
GLAD_API_CALL PFNGLGETPIXELMAPFVPROC glad_glGetPixelMapfv;
#define glGetPixelMapfv glad_glGetPixelMapfv
GLAD_API_CALL PFNGLGETPIXELMAPUIVPROC glad_glGetPixelMapuiv;
#define glGetPixelMapuiv glad_glGetPixelMapuiv
GLAD_API_CALL PFNGLGETPIXELMAPUSVPROC glad_glGetPixelMapusv;
#define glGetPixelMapusv glad_glGetPixelMapusv
GLAD_API_CALL PFNGLGETPOINTERVPROC glad_glGetPointerv;
#define glGetPointerv glad_glGetPointerv
GLAD_API_CALL PFNGLGETPOLYGONSTIPPLEPROC glad_glGetPolygonStipple;
#define glGetPolygonStipple glad_glGetPolygonStipple
GLAD_API_CALL PFNGLGETPROGRAMBINARYPROC glad_glGetProgramBinary;
#define glGetProgramBinary glad_glGetProgramBinary
GLAD_API_CALL PFNGLGETPROGRAMINFOLOGPROC glad_glGetProgramInfoLog;
#define glGetProgramInfoLog glad_glGetProgramInfoLog
GLAD_API_CALL PFNGLGETPROGRAMINTERFACEIVPROC glad_glGetProgramInterfaceiv;
#define glGetProgramInterfaceiv glad_glGetProgramInterfaceiv
GLAD_API_CALL PFNGLGETPROGRAMPIPELINEINFOLOGPROC glad_glGetProgramPipelineInfoLog;
#define glGetProgramPipelineInfoLog glad_glGetProgramPipelineInfoLog
GLAD_API_CALL PFNGLGETPROGRAMPIPELINEIVPROC glad_glGetProgramPipelineiv;
#define glGetProgramPipelineiv glad_glGetProgramPipelineiv
GLAD_API_CALL PFNGLGETPROGRAMRESOURCEINDEXPROC glad_glGetProgramResourceIndex;
#define glGetProgramResourceIndex glad_glGetProgramResourceIndex
GLAD_API_CALL PFNGLGETPROGRAMRESOURCELOCATIONPROC glad_glGetProgramResourceLocation;
#define glGetProgramResourceLocation glad_glGetProgramResourceLocation
GLAD_API_CALL PFNGLGETPROGRAMRESOURCELOCATIONINDEXPROC glad_glGetProgramResourceLocationIndex;
#define glGetProgramResourceLocationIndex glad_glGetProgramResourceLocationIndex
GLAD_API_CALL PFNGLGETPROGRAMRESOURCENAMEPROC glad_glGetProgramResourceName;
#define glGetProgramResourceName glad_glGetProgramResourceName
GLAD_API_CALL PFNGLGETPROGRAMRESOURCEIVPROC glad_glGetProgramResourceiv;
#define glGetProgramResourceiv glad_glGetProgramResourceiv
GLAD_API_CALL PFNGLGETPROGRAMSTAGEIVPROC glad_glGetProgramStageiv;
#define glGetProgramStageiv glad_glGetProgramStageiv
GLAD_API_CALL PFNGLGETPROGRAMIVPROC glad_glGetProgramiv;
#define glGetProgramiv glad_glGetProgramiv
GLAD_API_CALL PFNGLGETQUERYBUFFEROBJECTI64VPROC glad_glGetQueryBufferObjecti64v;
#define glGetQueryBufferObjecti64v glad_glGetQueryBufferObjecti64v
GLAD_API_CALL PFNGLGETQUERYBUFFEROBJECTIVPROC glad_glGetQueryBufferObjectiv;
#define glGetQueryBufferObjectiv glad_glGetQueryBufferObjectiv
GLAD_API_CALL PFNGLGETQUERYBUFFEROBJECTUI64VPROC glad_glGetQueryBufferObjectui64v;
#define glGetQueryBufferObjectui64v glad_glGetQueryBufferObjectui64v
GLAD_API_CALL PFNGLGETQUERYBUFFEROBJECTUIVPROC glad_glGetQueryBufferObjectuiv;
#define glGetQueryBufferObjectuiv glad_glGetQueryBufferObjectuiv
GLAD_API_CALL PFNGLGETQUERYINDEXEDIVPROC glad_glGetQueryIndexediv;
#define glGetQueryIndexediv glad_glGetQueryIndexediv
GLAD_API_CALL PFNGLGETQUERYOBJECTI64VPROC glad_glGetQueryObjecti64v;
#define glGetQueryObjecti64v glad_glGetQueryObjecti64v
GLAD_API_CALL PFNGLGETQUERYOBJECTIVPROC glad_glGetQueryObjectiv;
#define glGetQueryObjectiv glad_glGetQueryObjectiv
GLAD_API_CALL PFNGLGETQUERYOBJECTUI64VPROC glad_glGetQueryObjectui64v;
#define glGetQueryObjectui64v glad_glGetQueryObjectui64v
GLAD_API_CALL PFNGLGETQUERYOBJECTUIVPROC glad_glGetQueryObjectuiv;
#define glGetQueryObjectuiv glad_glGetQueryObjectuiv
GLAD_API_CALL PFNGLGETQUERYIVPROC glad_glGetQueryiv;
#define glGetQueryiv glad_glGetQueryiv
GLAD_API_CALL PFNGLGETRENDERBUFFERPARAMETERIVPROC glad_glGetRenderbufferParameteriv;
#define glGetRenderbufferParameteriv glad_glGetRenderbufferParameteriv
GLAD_API_CALL PFNGLGETSAMPLERPARAMETERIIVPROC glad_glGetSamplerParameterIiv;
#define glGetSamplerParameterIiv glad_glGetSamplerParameterIiv
GLAD_API_CALL PFNGLGETSAMPLERPARAMETERIUIVPROC glad_glGetSamplerParameterIuiv;
#define glGetSamplerParameterIuiv glad_glGetSamplerParameterIuiv
GLAD_API_CALL PFNGLGETSAMPLERPARAMETERFVPROC glad_glGetSamplerParameterfv;
#define glGetSamplerParameterfv glad_glGetSamplerParameterfv
GLAD_API_CALL PFNGLGETSAMPLERPARAMETERIVPROC glad_glGetSamplerParameteriv;
#define glGetSamplerParameteriv glad_glGetSamplerParameteriv
GLAD_API_CALL PFNGLGETSHADERINFOLOGPROC glad_glGetShaderInfoLog;
#define glGetShaderInfoLog glad_glGetShaderInfoLog
GLAD_API_CALL PFNGLGETSHADERPRECISIONFORMATPROC glad_glGetShaderPrecisionFormat;
#define glGetShaderPrecisionFormat glad_glGetShaderPrecisionFormat
GLAD_API_CALL PFNGLGETSHADERSOURCEPROC glad_glGetShaderSource;
#define glGetShaderSource glad_glGetShaderSource
GLAD_API_CALL PFNGLGETSHADERIVPROC glad_glGetShaderiv;
#define glGetShaderiv glad_glGetShaderiv
GLAD_API_CALL PFNGLGETSTRINGPROC glad_glGetString;
#define glGetString glad_glGetString
GLAD_API_CALL PFNGLGETSTRINGIPROC glad_glGetStringi;
#define glGetStringi glad_glGetStringi
GLAD_API_CALL PFNGLGETSUBROUTINEINDEXPROC glad_glGetSubroutineIndex;
#define glGetSubroutineIndex glad_glGetSubroutineIndex
GLAD_API_CALL PFNGLGETSUBROUTINEUNIFORMLOCATIONPROC glad_glGetSubroutineUniformLocation;
#define glGetSubroutineUniformLocation glad_glGetSubroutineUniformLocation
GLAD_API_CALL PFNGLGETSYNCIVPROC glad_glGetSynciv;
#define glGetSynciv glad_glGetSynciv
GLAD_API_CALL PFNGLGETTEXENVFVPROC glad_glGetTexEnvfv;
#define glGetTexEnvfv glad_glGetTexEnvfv
GLAD_API_CALL PFNGLGETTEXENVIVPROC glad_glGetTexEnviv;
#define glGetTexEnviv glad_glGetTexEnviv
GLAD_API_CALL PFNGLGETTEXGENDVPROC glad_glGetTexGendv;
#define glGetTexGendv glad_glGetTexGendv
GLAD_API_CALL PFNGLGETTEXGENFVPROC glad_glGetTexGenfv;
#define glGetTexGenfv glad_glGetTexGenfv
GLAD_API_CALL PFNGLGETTEXGENIVPROC glad_glGetTexGeniv;
#define glGetTexGeniv glad_glGetTexGeniv
GLAD_API_CALL PFNGLGETTEXIMAGEPROC glad_glGetTexImage;
#define glGetTexImage glad_glGetTexImage
GLAD_API_CALL PFNGLGETTEXLEVELPARAMETERFVPROC glad_glGetTexLevelParameterfv;
#define glGetTexLevelParameterfv glad_glGetTexLevelParameterfv
GLAD_API_CALL PFNGLGETTEXLEVELPARAMETERIVPROC glad_glGetTexLevelParameteriv;
#define glGetTexLevelParameteriv glad_glGetTexLevelParameteriv
GLAD_API_CALL PFNGLGETTEXPARAMETERIIVPROC glad_glGetTexParameterIiv;
#define glGetTexParameterIiv glad_glGetTexParameterIiv
GLAD_API_CALL PFNGLGETTEXPARAMETERIUIVPROC glad_glGetTexParameterIuiv;
#define glGetTexParameterIuiv glad_glGetTexParameterIuiv
GLAD_API_CALL PFNGLGETTEXPARAMETERFVPROC glad_glGetTexParameterfv;
#define glGetTexParameterfv glad_glGetTexParameterfv
GLAD_API_CALL PFNGLGETTEXPARAMETERIVPROC glad_glGetTexParameteriv;
#define glGetTexParameteriv glad_glGetTexParameteriv
GLAD_API_CALL PFNGLGETTEXTUREIMAGEPROC glad_glGetTextureImage;
#define glGetTextureImage glad_glGetTextureImage
GLAD_API_CALL PFNGLGETTEXTURELEVELPARAMETERFVPROC glad_glGetTextureLevelParameterfv;
#define glGetTextureLevelParameterfv glad_glGetTextureLevelParameterfv
GLAD_API_CALL PFNGLGETTEXTURELEVELPARAMETERIVPROC glad_glGetTextureLevelParameteriv;
#define glGetTextureLevelParameteriv glad_glGetTextureLevelParameteriv
GLAD_API_CALL PFNGLGETTEXTUREPARAMETERIIVPROC glad_glGetTextureParameterIiv;
#define glGetTextureParameterIiv glad_glGetTextureParameterIiv
GLAD_API_CALL PFNGLGETTEXTUREPARAMETERIUIVPROC glad_glGetTextureParameterIuiv;
#define glGetTextureParameterIuiv glad_glGetTextureParameterIuiv
GLAD_API_CALL PFNGLGETTEXTUREPARAMETERFVPROC glad_glGetTextureParameterfv;
#define glGetTextureParameterfv glad_glGetTextureParameterfv
GLAD_API_CALL PFNGLGETTEXTUREPARAMETERIVPROC glad_glGetTextureParameteriv;
#define glGetTextureParameteriv glad_glGetTextureParameteriv
GLAD_API_CALL PFNGLGETTEXTURESUBIMAGEPROC glad_glGetTextureSubImage;
#define glGetTextureSubImage glad_glGetTextureSubImage
GLAD_API_CALL PFNGLGETTRANSFORMFEEDBACKVARYINGPROC glad_glGetTransformFeedbackVarying;
#define glGetTransformFeedbackVarying glad_glGetTransformFeedbackVarying
GLAD_API_CALL PFNGLGETTRANSFORMFEEDBACKI64_VPROC glad_glGetTransformFeedbacki64_v;
#define glGetTransformFeedbacki64_v glad_glGetTransformFeedbacki64_v
GLAD_API_CALL PFNGLGETTRANSFORMFEEDBACKI_VPROC glad_glGetTransformFeedbacki_v;
#define glGetTransformFeedbacki_v glad_glGetTransformFeedbacki_v
GLAD_API_CALL PFNGLGETTRANSFORMFEEDBACKIVPROC glad_glGetTransformFeedbackiv;
#define glGetTransformFeedbackiv glad_glGetTransformFeedbackiv
GLAD_API_CALL PFNGLGETUNIFORMBLOCKINDEXPROC glad_glGetUniformBlockIndex;
#define glGetUniformBlockIndex glad_glGetUniformBlockIndex
GLAD_API_CALL PFNGLGETUNIFORMINDICESPROC glad_glGetUniformIndices;
#define glGetUniformIndices glad_glGetUniformIndices
GLAD_API_CALL PFNGLGETUNIFORMLOCATIONPROC glad_glGetUniformLocation;
#define glGetUniformLocation glad_glGetUniformLocation
GLAD_API_CALL PFNGLGETUNIFORMSUBROUTINEUIVPROC glad_glGetUniformSubroutineuiv;
#define glGetUniformSubroutineuiv glad_glGetUniformSubroutineuiv
GLAD_API_CALL PFNGLGETUNIFORMDVPROC glad_glGetUniformdv;
#define glGetUniformdv glad_glGetUniformdv
GLAD_API_CALL PFNGLGETUNIFORMFVPROC glad_glGetUniformfv;
#define glGetUniformfv glad_glGetUniformfv
GLAD_API_CALL PFNGLGETUNIFORMIVPROC glad_glGetUniformiv;
#define glGetUniformiv glad_glGetUniformiv
GLAD_API_CALL PFNGLGETUNIFORMUIVPROC glad_glGetUniformuiv;
#define glGetUniformuiv glad_glGetUniformuiv
GLAD_API_CALL PFNGLGETVERTEXARRAYINDEXED64IVPROC glad_glGetVertexArrayIndexed64iv;
#define glGetVertexArrayIndexed64iv glad_glGetVertexArrayIndexed64iv
GLAD_API_CALL PFNGLGETVERTEXARRAYINDEXEDIVPROC glad_glGetVertexArrayIndexediv;
#define glGetVertexArrayIndexediv glad_glGetVertexArrayIndexediv
GLAD_API_CALL PFNGLGETVERTEXARRAYIVPROC glad_glGetVertexArrayiv;
#define glGetVertexArrayiv glad_glGetVertexArrayiv
GLAD_API_CALL PFNGLGETVERTEXATTRIBIIVPROC glad_glGetVertexAttribIiv;
#define glGetVertexAttribIiv glad_glGetVertexAttribIiv
GLAD_API_CALL PFNGLGETVERTEXATTRIBIUIVPROC glad_glGetVertexAttribIuiv;
#define glGetVertexAttribIuiv glad_glGetVertexAttribIuiv
GLAD_API_CALL PFNGLGETVERTEXATTRIBLDVPROC glad_glGetVertexAttribLdv;
#define glGetVertexAttribLdv glad_glGetVertexAttribLdv
GLAD_API_CALL PFNGLGETVERTEXATTRIBPOINTERVPROC glad_glGetVertexAttribPointerv;
#define glGetVertexAttribPointerv glad_glGetVertexAttribPointerv
GLAD_API_CALL PFNGLGETVERTEXATTRIBDVPROC glad_glGetVertexAttribdv;
#define glGetVertexAttribdv glad_glGetVertexAttribdv
GLAD_API_CALL PFNGLGETVERTEXATTRIBFVPROC glad_glGetVertexAttribfv;
#define glGetVertexAttribfv glad_glGetVertexAttribfv
GLAD_API_CALL PFNGLGETVERTEXATTRIBIVPROC glad_glGetVertexAttribiv;
#define glGetVertexAttribiv glad_glGetVertexAttribiv
GLAD_API_CALL PFNGLGETNCOLORTABLEPROC glad_glGetnColorTable;
#define glGetnColorTable glad_glGetnColorTable
GLAD_API_CALL PFNGLGETNCOLORTABLEARBPROC glad_glGetnColorTableARB;
#define glGetnColorTableARB glad_glGetnColorTableARB
GLAD_API_CALL PFNGLGETNCOMPRESSEDTEXIMAGEPROC glad_glGetnCompressedTexImage;
#define glGetnCompressedTexImage glad_glGetnCompressedTexImage
GLAD_API_CALL PFNGLGETNCOMPRESSEDTEXIMAGEARBPROC glad_glGetnCompressedTexImageARB;
#define glGetnCompressedTexImageARB glad_glGetnCompressedTexImageARB
GLAD_API_CALL PFNGLGETNCONVOLUTIONFILTERPROC glad_glGetnConvolutionFilter;
#define glGetnConvolutionFilter glad_glGetnConvolutionFilter
GLAD_API_CALL PFNGLGETNCONVOLUTIONFILTERARBPROC glad_glGetnConvolutionFilterARB;
#define glGetnConvolutionFilterARB glad_glGetnConvolutionFilterARB
GLAD_API_CALL PFNGLGETNHISTOGRAMPROC glad_glGetnHistogram;
#define glGetnHistogram glad_glGetnHistogram
GLAD_API_CALL PFNGLGETNHISTOGRAMARBPROC glad_glGetnHistogramARB;
#define glGetnHistogramARB glad_glGetnHistogramARB
GLAD_API_CALL PFNGLGETNMAPDVPROC glad_glGetnMapdv;
#define glGetnMapdv glad_glGetnMapdv
GLAD_API_CALL PFNGLGETNMAPDVARBPROC glad_glGetnMapdvARB;
#define glGetnMapdvARB glad_glGetnMapdvARB
GLAD_API_CALL PFNGLGETNMAPFVPROC glad_glGetnMapfv;
#define glGetnMapfv glad_glGetnMapfv
GLAD_API_CALL PFNGLGETNMAPFVARBPROC glad_glGetnMapfvARB;
#define glGetnMapfvARB glad_glGetnMapfvARB
GLAD_API_CALL PFNGLGETNMAPIVPROC glad_glGetnMapiv;
#define glGetnMapiv glad_glGetnMapiv
GLAD_API_CALL PFNGLGETNMAPIVARBPROC glad_glGetnMapivARB;
#define glGetnMapivARB glad_glGetnMapivARB
GLAD_API_CALL PFNGLGETNMINMAXPROC glad_glGetnMinmax;
#define glGetnMinmax glad_glGetnMinmax
GLAD_API_CALL PFNGLGETNMINMAXARBPROC glad_glGetnMinmaxARB;
#define glGetnMinmaxARB glad_glGetnMinmaxARB
GLAD_API_CALL PFNGLGETNPIXELMAPFVPROC glad_glGetnPixelMapfv;
#define glGetnPixelMapfv glad_glGetnPixelMapfv
GLAD_API_CALL PFNGLGETNPIXELMAPFVARBPROC glad_glGetnPixelMapfvARB;
#define glGetnPixelMapfvARB glad_glGetnPixelMapfvARB
GLAD_API_CALL PFNGLGETNPIXELMAPUIVPROC glad_glGetnPixelMapuiv;
#define glGetnPixelMapuiv glad_glGetnPixelMapuiv
GLAD_API_CALL PFNGLGETNPIXELMAPUIVARBPROC glad_glGetnPixelMapuivARB;
#define glGetnPixelMapuivARB glad_glGetnPixelMapuivARB
GLAD_API_CALL PFNGLGETNPIXELMAPUSVPROC glad_glGetnPixelMapusv;
#define glGetnPixelMapusv glad_glGetnPixelMapusv
GLAD_API_CALL PFNGLGETNPIXELMAPUSVARBPROC glad_glGetnPixelMapusvARB;
#define glGetnPixelMapusvARB glad_glGetnPixelMapusvARB
GLAD_API_CALL PFNGLGETNPOLYGONSTIPPLEPROC glad_glGetnPolygonStipple;
#define glGetnPolygonStipple glad_glGetnPolygonStipple
GLAD_API_CALL PFNGLGETNPOLYGONSTIPPLEARBPROC glad_glGetnPolygonStippleARB;
#define glGetnPolygonStippleARB glad_glGetnPolygonStippleARB
GLAD_API_CALL PFNGLGETNSEPARABLEFILTERPROC glad_glGetnSeparableFilter;
#define glGetnSeparableFilter glad_glGetnSeparableFilter
GLAD_API_CALL PFNGLGETNSEPARABLEFILTERARBPROC glad_glGetnSeparableFilterARB;
#define glGetnSeparableFilterARB glad_glGetnSeparableFilterARB
GLAD_API_CALL PFNGLGETNTEXIMAGEPROC glad_glGetnTexImage;
#define glGetnTexImage glad_glGetnTexImage
GLAD_API_CALL PFNGLGETNTEXIMAGEARBPROC glad_glGetnTexImageARB;
#define glGetnTexImageARB glad_glGetnTexImageARB
GLAD_API_CALL PFNGLGETNUNIFORMDVPROC glad_glGetnUniformdv;
#define glGetnUniformdv glad_glGetnUniformdv
GLAD_API_CALL PFNGLGETNUNIFORMDVARBPROC glad_glGetnUniformdvARB;
#define glGetnUniformdvARB glad_glGetnUniformdvARB
GLAD_API_CALL PFNGLGETNUNIFORMFVPROC glad_glGetnUniformfv;
#define glGetnUniformfv glad_glGetnUniformfv
GLAD_API_CALL PFNGLGETNUNIFORMFVARBPROC glad_glGetnUniformfvARB;
#define glGetnUniformfvARB glad_glGetnUniformfvARB
GLAD_API_CALL PFNGLGETNUNIFORMIVPROC glad_glGetnUniformiv;
#define glGetnUniformiv glad_glGetnUniformiv
GLAD_API_CALL PFNGLGETNUNIFORMIVARBPROC glad_glGetnUniformivARB;
#define glGetnUniformivARB glad_glGetnUniformivARB
GLAD_API_CALL PFNGLGETNUNIFORMUIVPROC glad_glGetnUniformuiv;
#define glGetnUniformuiv glad_glGetnUniformuiv
GLAD_API_CALL PFNGLGETNUNIFORMUIVARBPROC glad_glGetnUniformuivARB;
#define glGetnUniformuivARB glad_glGetnUniformuivARB
GLAD_API_CALL PFNGLHINTPROC glad_glHint;
#define glHint glad_glHint
GLAD_API_CALL PFNGLINDEXMASKPROC glad_glIndexMask;
#define glIndexMask glad_glIndexMask
GLAD_API_CALL PFNGLINDEXPOINTERPROC glad_glIndexPointer;
#define glIndexPointer glad_glIndexPointer
GLAD_API_CALL PFNGLINDEXDPROC glad_glIndexd;
#define glIndexd glad_glIndexd
GLAD_API_CALL PFNGLINDEXDVPROC glad_glIndexdv;
#define glIndexdv glad_glIndexdv
GLAD_API_CALL PFNGLINDEXFPROC glad_glIndexf;
#define glIndexf glad_glIndexf
GLAD_API_CALL PFNGLINDEXFVPROC glad_glIndexfv;
#define glIndexfv glad_glIndexfv
GLAD_API_CALL PFNGLINDEXIPROC glad_glIndexi;
#define glIndexi glad_glIndexi
GLAD_API_CALL PFNGLINDEXIVPROC glad_glIndexiv;
#define glIndexiv glad_glIndexiv
GLAD_API_CALL PFNGLINDEXSPROC glad_glIndexs;
#define glIndexs glad_glIndexs
GLAD_API_CALL PFNGLINDEXSVPROC glad_glIndexsv;
#define glIndexsv glad_glIndexsv
GLAD_API_CALL PFNGLINDEXUBPROC glad_glIndexub;
#define glIndexub glad_glIndexub
GLAD_API_CALL PFNGLINDEXUBVPROC glad_glIndexubv;
#define glIndexubv glad_glIndexubv
GLAD_API_CALL PFNGLINITNAMESPROC glad_glInitNames;
#define glInitNames glad_glInitNames
GLAD_API_CALL PFNGLINTERLEAVEDARRAYSPROC glad_glInterleavedArrays;
#define glInterleavedArrays glad_glInterleavedArrays
GLAD_API_CALL PFNGLINVALIDATEBUFFERDATAPROC glad_glInvalidateBufferData;
#define glInvalidateBufferData glad_glInvalidateBufferData
GLAD_API_CALL PFNGLINVALIDATEBUFFERSUBDATAPROC glad_glInvalidateBufferSubData;
#define glInvalidateBufferSubData glad_glInvalidateBufferSubData
GLAD_API_CALL PFNGLINVALIDATEFRAMEBUFFERPROC glad_glInvalidateFramebuffer;
#define glInvalidateFramebuffer glad_glInvalidateFramebuffer
GLAD_API_CALL PFNGLINVALIDATENAMEDFRAMEBUFFERDATAPROC glad_glInvalidateNamedFramebufferData;
#define glInvalidateNamedFramebufferData glad_glInvalidateNamedFramebufferData
GLAD_API_CALL PFNGLINVALIDATENAMEDFRAMEBUFFERSUBDATAPROC glad_glInvalidateNamedFramebufferSubData;
#define glInvalidateNamedFramebufferSubData glad_glInvalidateNamedFramebufferSubData
GLAD_API_CALL PFNGLINVALIDATESUBFRAMEBUFFERPROC glad_glInvalidateSubFramebuffer;
#define glInvalidateSubFramebuffer glad_glInvalidateSubFramebuffer
GLAD_API_CALL PFNGLINVALIDATETEXIMAGEPROC glad_glInvalidateTexImage;
#define glInvalidateTexImage glad_glInvalidateTexImage
GLAD_API_CALL PFNGLINVALIDATETEXSUBIMAGEPROC glad_glInvalidateTexSubImage;
#define glInvalidateTexSubImage glad_glInvalidateTexSubImage
GLAD_API_CALL PFNGLISBUFFERPROC glad_glIsBuffer;
#define glIsBuffer glad_glIsBuffer
GLAD_API_CALL PFNGLISENABLEDPROC glad_glIsEnabled;
#define glIsEnabled glad_glIsEnabled
GLAD_API_CALL PFNGLISENABLEDIPROC glad_glIsEnabledi;
#define glIsEnabledi glad_glIsEnabledi
GLAD_API_CALL PFNGLISFRAMEBUFFERPROC glad_glIsFramebuffer;
#define glIsFramebuffer glad_glIsFramebuffer
GLAD_API_CALL PFNGLISLISTPROC glad_glIsList;
#define glIsList glad_glIsList
GLAD_API_CALL PFNGLISPROGRAMPROC glad_glIsProgram;
#define glIsProgram glad_glIsProgram
GLAD_API_CALL PFNGLISPROGRAMPIPELINEPROC glad_glIsProgramPipeline;
#define glIsProgramPipeline glad_glIsProgramPipeline
GLAD_API_CALL PFNGLISQUERYPROC glad_glIsQuery;
#define glIsQuery glad_glIsQuery
GLAD_API_CALL PFNGLISRENDERBUFFERPROC glad_glIsRenderbuffer;
#define glIsRenderbuffer glad_glIsRenderbuffer
GLAD_API_CALL PFNGLISSAMPLERPROC glad_glIsSampler;
#define glIsSampler glad_glIsSampler
GLAD_API_CALL PFNGLISSHADERPROC glad_glIsShader;
#define glIsShader glad_glIsShader
GLAD_API_CALL PFNGLISSYNCPROC glad_glIsSync;
#define glIsSync glad_glIsSync
GLAD_API_CALL PFNGLISTEXTUREPROC glad_glIsTexture;
#define glIsTexture glad_glIsTexture
GLAD_API_CALL PFNGLISTRANSFORMFEEDBACKPROC glad_glIsTransformFeedback;
#define glIsTransformFeedback glad_glIsTransformFeedback
GLAD_API_CALL PFNGLISVERTEXARRAYPROC glad_glIsVertexArray;
#define glIsVertexArray glad_glIsVertexArray
GLAD_API_CALL PFNGLLIGHTMODELFPROC glad_glLightModelf;
#define glLightModelf glad_glLightModelf
GLAD_API_CALL PFNGLLIGHTMODELFVPROC glad_glLightModelfv;
#define glLightModelfv glad_glLightModelfv
GLAD_API_CALL PFNGLLIGHTMODELIPROC glad_glLightModeli;
#define glLightModeli glad_glLightModeli
GLAD_API_CALL PFNGLLIGHTMODELIVPROC glad_glLightModeliv;
#define glLightModeliv glad_glLightModeliv
GLAD_API_CALL PFNGLLIGHTFPROC glad_glLightf;
#define glLightf glad_glLightf
GLAD_API_CALL PFNGLLIGHTFVPROC glad_glLightfv;
#define glLightfv glad_glLightfv
GLAD_API_CALL PFNGLLIGHTIPROC glad_glLighti;
#define glLighti glad_glLighti
GLAD_API_CALL PFNGLLIGHTIVPROC glad_glLightiv;
#define glLightiv glad_glLightiv
GLAD_API_CALL PFNGLLINESTIPPLEPROC glad_glLineStipple;
#define glLineStipple glad_glLineStipple
GLAD_API_CALL PFNGLLINEWIDTHPROC glad_glLineWidth;
#define glLineWidth glad_glLineWidth
GLAD_API_CALL PFNGLLINKPROGRAMPROC glad_glLinkProgram;
#define glLinkProgram glad_glLinkProgram
GLAD_API_CALL PFNGLLISTBASEPROC glad_glListBase;
#define glListBase glad_glListBase
GLAD_API_CALL PFNGLLOADIDENTITYPROC glad_glLoadIdentity;
#define glLoadIdentity glad_glLoadIdentity
GLAD_API_CALL PFNGLLOADMATRIXDPROC glad_glLoadMatrixd;
#define glLoadMatrixd glad_glLoadMatrixd
GLAD_API_CALL PFNGLLOADMATRIXFPROC glad_glLoadMatrixf;
#define glLoadMatrixf glad_glLoadMatrixf
GLAD_API_CALL PFNGLLOADNAMEPROC glad_glLoadName;
#define glLoadName glad_glLoadName
GLAD_API_CALL PFNGLLOADTRANSPOSEMATRIXDPROC glad_glLoadTransposeMatrixd;
#define glLoadTransposeMatrixd glad_glLoadTransposeMatrixd
GLAD_API_CALL PFNGLLOADTRANSPOSEMATRIXFPROC glad_glLoadTransposeMatrixf;
#define glLoadTransposeMatrixf glad_glLoadTransposeMatrixf
GLAD_API_CALL PFNGLLOGICOPPROC glad_glLogicOp;
#define glLogicOp glad_glLogicOp
GLAD_API_CALL PFNGLMAP1DPROC glad_glMap1d;
#define glMap1d glad_glMap1d
GLAD_API_CALL PFNGLMAP1FPROC glad_glMap1f;
#define glMap1f glad_glMap1f
GLAD_API_CALL PFNGLMAP2DPROC glad_glMap2d;
#define glMap2d glad_glMap2d
GLAD_API_CALL PFNGLMAP2FPROC glad_glMap2f;
#define glMap2f glad_glMap2f
GLAD_API_CALL PFNGLMAPBUFFERPROC glad_glMapBuffer;
#define glMapBuffer glad_glMapBuffer
GLAD_API_CALL PFNGLMAPBUFFERRANGEPROC glad_glMapBufferRange;
#define glMapBufferRange glad_glMapBufferRange
GLAD_API_CALL PFNGLMAPGRID1DPROC glad_glMapGrid1d;
#define glMapGrid1d glad_glMapGrid1d
GLAD_API_CALL PFNGLMAPGRID1FPROC glad_glMapGrid1f;
#define glMapGrid1f glad_glMapGrid1f
GLAD_API_CALL PFNGLMAPGRID2DPROC glad_glMapGrid2d;
#define glMapGrid2d glad_glMapGrid2d
GLAD_API_CALL PFNGLMAPGRID2FPROC glad_glMapGrid2f;
#define glMapGrid2f glad_glMapGrid2f
GLAD_API_CALL PFNGLMAPNAMEDBUFFERPROC glad_glMapNamedBuffer;
#define glMapNamedBuffer glad_glMapNamedBuffer
GLAD_API_CALL PFNGLMAPNAMEDBUFFERRANGEPROC glad_glMapNamedBufferRange;
#define glMapNamedBufferRange glad_glMapNamedBufferRange
GLAD_API_CALL PFNGLMATERIALFPROC glad_glMaterialf;
#define glMaterialf glad_glMaterialf
GLAD_API_CALL PFNGLMATERIALFVPROC glad_glMaterialfv;
#define glMaterialfv glad_glMaterialfv
GLAD_API_CALL PFNGLMATERIALIPROC glad_glMateriali;
#define glMateriali glad_glMateriali
GLAD_API_CALL PFNGLMATERIALIVPROC glad_glMaterialiv;
#define glMaterialiv glad_glMaterialiv
GLAD_API_CALL PFNGLMATRIXMODEPROC glad_glMatrixMode;
#define glMatrixMode glad_glMatrixMode
GLAD_API_CALL PFNGLMEMORYBARRIERPROC glad_glMemoryBarrier;
#define glMemoryBarrier glad_glMemoryBarrier
GLAD_API_CALL PFNGLMEMORYBARRIERBYREGIONPROC glad_glMemoryBarrierByRegion;
#define glMemoryBarrierByRegion glad_glMemoryBarrierByRegion
GLAD_API_CALL PFNGLMINSAMPLESHADINGPROC glad_glMinSampleShading;
#define glMinSampleShading glad_glMinSampleShading
GLAD_API_CALL PFNGLMULTMATRIXDPROC glad_glMultMatrixd;
#define glMultMatrixd glad_glMultMatrixd
GLAD_API_CALL PFNGLMULTMATRIXFPROC glad_glMultMatrixf;
#define glMultMatrixf glad_glMultMatrixf
GLAD_API_CALL PFNGLMULTTRANSPOSEMATRIXDPROC glad_glMultTransposeMatrixd;
#define glMultTransposeMatrixd glad_glMultTransposeMatrixd
GLAD_API_CALL PFNGLMULTTRANSPOSEMATRIXFPROC glad_glMultTransposeMatrixf;
#define glMultTransposeMatrixf glad_glMultTransposeMatrixf
GLAD_API_CALL PFNGLMULTIDRAWARRAYSPROC glad_glMultiDrawArrays;
#define glMultiDrawArrays glad_glMultiDrawArrays
GLAD_API_CALL PFNGLMULTIDRAWARRAYSINDIRECTPROC glad_glMultiDrawArraysIndirect;
#define glMultiDrawArraysIndirect glad_glMultiDrawArraysIndirect
GLAD_API_CALL PFNGLMULTIDRAWARRAYSINDIRECTCOUNTPROC glad_glMultiDrawArraysIndirectCount;
#define glMultiDrawArraysIndirectCount glad_glMultiDrawArraysIndirectCount
GLAD_API_CALL PFNGLMULTIDRAWELEMENTSPROC glad_glMultiDrawElements;
#define glMultiDrawElements glad_glMultiDrawElements
GLAD_API_CALL PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC glad_glMultiDrawElementsBaseVertex;
#define glMultiDrawElementsBaseVertex glad_glMultiDrawElementsBaseVertex
GLAD_API_CALL PFNGLMULTIDRAWELEMENTSINDIRECTPROC glad_glMultiDrawElementsIndirect;
#define glMultiDrawElementsIndirect glad_glMultiDrawElementsIndirect
GLAD_API_CALL PFNGLMULTIDRAWELEMENTSINDIRECTCOUNTPROC glad_glMultiDrawElementsIndirectCount;
#define glMultiDrawElementsIndirectCount glad_glMultiDrawElementsIndirectCount
GLAD_API_CALL PFNGLMULTITEXCOORD1DPROC glad_glMultiTexCoord1d;
#define glMultiTexCoord1d glad_glMultiTexCoord1d
GLAD_API_CALL PFNGLMULTITEXCOORD1DVPROC glad_glMultiTexCoord1dv;
#define glMultiTexCoord1dv glad_glMultiTexCoord1dv
GLAD_API_CALL PFNGLMULTITEXCOORD1FPROC glad_glMultiTexCoord1f;
#define glMultiTexCoord1f glad_glMultiTexCoord1f
GLAD_API_CALL PFNGLMULTITEXCOORD1FVPROC glad_glMultiTexCoord1fv;
#define glMultiTexCoord1fv glad_glMultiTexCoord1fv
GLAD_API_CALL PFNGLMULTITEXCOORD1IPROC glad_glMultiTexCoord1i;
#define glMultiTexCoord1i glad_glMultiTexCoord1i
GLAD_API_CALL PFNGLMULTITEXCOORD1IVPROC glad_glMultiTexCoord1iv;
#define glMultiTexCoord1iv glad_glMultiTexCoord1iv
GLAD_API_CALL PFNGLMULTITEXCOORD1SPROC glad_glMultiTexCoord1s;
#define glMultiTexCoord1s glad_glMultiTexCoord1s
GLAD_API_CALL PFNGLMULTITEXCOORD1SVPROC glad_glMultiTexCoord1sv;
#define glMultiTexCoord1sv glad_glMultiTexCoord1sv
GLAD_API_CALL PFNGLMULTITEXCOORD2DPROC glad_glMultiTexCoord2d;
#define glMultiTexCoord2d glad_glMultiTexCoord2d
GLAD_API_CALL PFNGLMULTITEXCOORD2DVPROC glad_glMultiTexCoord2dv;
#define glMultiTexCoord2dv glad_glMultiTexCoord2dv
GLAD_API_CALL PFNGLMULTITEXCOORD2FPROC glad_glMultiTexCoord2f;
#define glMultiTexCoord2f glad_glMultiTexCoord2f
GLAD_API_CALL PFNGLMULTITEXCOORD2FVPROC glad_glMultiTexCoord2fv;
#define glMultiTexCoord2fv glad_glMultiTexCoord2fv
GLAD_API_CALL PFNGLMULTITEXCOORD2IPROC glad_glMultiTexCoord2i;
#define glMultiTexCoord2i glad_glMultiTexCoord2i
GLAD_API_CALL PFNGLMULTITEXCOORD2IVPROC glad_glMultiTexCoord2iv;
#define glMultiTexCoord2iv glad_glMultiTexCoord2iv
GLAD_API_CALL PFNGLMULTITEXCOORD2SPROC glad_glMultiTexCoord2s;
#define glMultiTexCoord2s glad_glMultiTexCoord2s
GLAD_API_CALL PFNGLMULTITEXCOORD2SVPROC glad_glMultiTexCoord2sv;
#define glMultiTexCoord2sv glad_glMultiTexCoord2sv
GLAD_API_CALL PFNGLMULTITEXCOORD3DPROC glad_glMultiTexCoord3d;
#define glMultiTexCoord3d glad_glMultiTexCoord3d
GLAD_API_CALL PFNGLMULTITEXCOORD3DVPROC glad_glMultiTexCoord3dv;
#define glMultiTexCoord3dv glad_glMultiTexCoord3dv
GLAD_API_CALL PFNGLMULTITEXCOORD3FPROC glad_glMultiTexCoord3f;
#define glMultiTexCoord3f glad_glMultiTexCoord3f
GLAD_API_CALL PFNGLMULTITEXCOORD3FVPROC glad_glMultiTexCoord3fv;
#define glMultiTexCoord3fv glad_glMultiTexCoord3fv
GLAD_API_CALL PFNGLMULTITEXCOORD3IPROC glad_glMultiTexCoord3i;
#define glMultiTexCoord3i glad_glMultiTexCoord3i
GLAD_API_CALL PFNGLMULTITEXCOORD3IVPROC glad_glMultiTexCoord3iv;
#define glMultiTexCoord3iv glad_glMultiTexCoord3iv
GLAD_API_CALL PFNGLMULTITEXCOORD3SPROC glad_glMultiTexCoord3s;
#define glMultiTexCoord3s glad_glMultiTexCoord3s
GLAD_API_CALL PFNGLMULTITEXCOORD3SVPROC glad_glMultiTexCoord3sv;
#define glMultiTexCoord3sv glad_glMultiTexCoord3sv
GLAD_API_CALL PFNGLMULTITEXCOORD4DPROC glad_glMultiTexCoord4d;
#define glMultiTexCoord4d glad_glMultiTexCoord4d
GLAD_API_CALL PFNGLMULTITEXCOORD4DVPROC glad_glMultiTexCoord4dv;
#define glMultiTexCoord4dv glad_glMultiTexCoord4dv
GLAD_API_CALL PFNGLMULTITEXCOORD4FPROC glad_glMultiTexCoord4f;
#define glMultiTexCoord4f glad_glMultiTexCoord4f
GLAD_API_CALL PFNGLMULTITEXCOORD4FVPROC glad_glMultiTexCoord4fv;
#define glMultiTexCoord4fv glad_glMultiTexCoord4fv
GLAD_API_CALL PFNGLMULTITEXCOORD4IPROC glad_glMultiTexCoord4i;
#define glMultiTexCoord4i glad_glMultiTexCoord4i
GLAD_API_CALL PFNGLMULTITEXCOORD4IVPROC glad_glMultiTexCoord4iv;
#define glMultiTexCoord4iv glad_glMultiTexCoord4iv
GLAD_API_CALL PFNGLMULTITEXCOORD4SPROC glad_glMultiTexCoord4s;
#define glMultiTexCoord4s glad_glMultiTexCoord4s
GLAD_API_CALL PFNGLMULTITEXCOORD4SVPROC glad_glMultiTexCoord4sv;
#define glMultiTexCoord4sv glad_glMultiTexCoord4sv
GLAD_API_CALL PFNGLMULTITEXCOORDP1UIPROC glad_glMultiTexCoordP1ui;
#define glMultiTexCoordP1ui glad_glMultiTexCoordP1ui
GLAD_API_CALL PFNGLMULTITEXCOORDP1UIVPROC glad_glMultiTexCoordP1uiv;
#define glMultiTexCoordP1uiv glad_glMultiTexCoordP1uiv
GLAD_API_CALL PFNGLMULTITEXCOORDP2UIPROC glad_glMultiTexCoordP2ui;
#define glMultiTexCoordP2ui glad_glMultiTexCoordP2ui
GLAD_API_CALL PFNGLMULTITEXCOORDP2UIVPROC glad_glMultiTexCoordP2uiv;
#define glMultiTexCoordP2uiv glad_glMultiTexCoordP2uiv
GLAD_API_CALL PFNGLMULTITEXCOORDP3UIPROC glad_glMultiTexCoordP3ui;
#define glMultiTexCoordP3ui glad_glMultiTexCoordP3ui
GLAD_API_CALL PFNGLMULTITEXCOORDP3UIVPROC glad_glMultiTexCoordP3uiv;
#define glMultiTexCoordP3uiv glad_glMultiTexCoordP3uiv
GLAD_API_CALL PFNGLMULTITEXCOORDP4UIPROC glad_glMultiTexCoordP4ui;
#define glMultiTexCoordP4ui glad_glMultiTexCoordP4ui
GLAD_API_CALL PFNGLMULTITEXCOORDP4UIVPROC glad_glMultiTexCoordP4uiv;
#define glMultiTexCoordP4uiv glad_glMultiTexCoordP4uiv
GLAD_API_CALL PFNGLNAMEDBUFFERDATAPROC glad_glNamedBufferData;
#define glNamedBufferData glad_glNamedBufferData
GLAD_API_CALL PFNGLNAMEDBUFFERSTORAGEPROC glad_glNamedBufferStorage;
#define glNamedBufferStorage glad_glNamedBufferStorage
GLAD_API_CALL PFNGLNAMEDBUFFERSUBDATAPROC glad_glNamedBufferSubData;
#define glNamedBufferSubData glad_glNamedBufferSubData
GLAD_API_CALL PFNGLNAMEDFRAMEBUFFERDRAWBUFFERPROC glad_glNamedFramebufferDrawBuffer;
#define glNamedFramebufferDrawBuffer glad_glNamedFramebufferDrawBuffer
GLAD_API_CALL PFNGLNAMEDFRAMEBUFFERDRAWBUFFERSPROC glad_glNamedFramebufferDrawBuffers;
#define glNamedFramebufferDrawBuffers glad_glNamedFramebufferDrawBuffers
GLAD_API_CALL PFNGLNAMEDFRAMEBUFFERPARAMETERIPROC glad_glNamedFramebufferParameteri;
#define glNamedFramebufferParameteri glad_glNamedFramebufferParameteri
GLAD_API_CALL PFNGLNAMEDFRAMEBUFFERREADBUFFERPROC glad_glNamedFramebufferReadBuffer;
#define glNamedFramebufferReadBuffer glad_glNamedFramebufferReadBuffer
GLAD_API_CALL PFNGLNAMEDFRAMEBUFFERRENDERBUFFERPROC glad_glNamedFramebufferRenderbuffer;
#define glNamedFramebufferRenderbuffer glad_glNamedFramebufferRenderbuffer
GLAD_API_CALL PFNGLNAMEDFRAMEBUFFERTEXTUREPROC glad_glNamedFramebufferTexture;
#define glNamedFramebufferTexture glad_glNamedFramebufferTexture
GLAD_API_CALL PFNGLNAMEDFRAMEBUFFERTEXTURELAYERPROC glad_glNamedFramebufferTextureLayer;
#define glNamedFramebufferTextureLayer glad_glNamedFramebufferTextureLayer
GLAD_API_CALL PFNGLNAMEDRENDERBUFFERSTORAGEPROC glad_glNamedRenderbufferStorage;
#define glNamedRenderbufferStorage glad_glNamedRenderbufferStorage
GLAD_API_CALL PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLEPROC glad_glNamedRenderbufferStorageMultisample;
#define glNamedRenderbufferStorageMultisample glad_glNamedRenderbufferStorageMultisample
GLAD_API_CALL PFNGLNEWLISTPROC glad_glNewList;
#define glNewList glad_glNewList
GLAD_API_CALL PFNGLNORMAL3BPROC glad_glNormal3b;
#define glNormal3b glad_glNormal3b
GLAD_API_CALL PFNGLNORMAL3BVPROC glad_glNormal3bv;
#define glNormal3bv glad_glNormal3bv
GLAD_API_CALL PFNGLNORMAL3DPROC glad_glNormal3d;
#define glNormal3d glad_glNormal3d
GLAD_API_CALL PFNGLNORMAL3DVPROC glad_glNormal3dv;
#define glNormal3dv glad_glNormal3dv
GLAD_API_CALL PFNGLNORMAL3FPROC glad_glNormal3f;
#define glNormal3f glad_glNormal3f
GLAD_API_CALL PFNGLNORMAL3FVPROC glad_glNormal3fv;
#define glNormal3fv glad_glNormal3fv
GLAD_API_CALL PFNGLNORMAL3IPROC glad_glNormal3i;
#define glNormal3i glad_glNormal3i
GLAD_API_CALL PFNGLNORMAL3IVPROC glad_glNormal3iv;
#define glNormal3iv glad_glNormal3iv
GLAD_API_CALL PFNGLNORMAL3SPROC glad_glNormal3s;
#define glNormal3s glad_glNormal3s
GLAD_API_CALL PFNGLNORMAL3SVPROC glad_glNormal3sv;
#define glNormal3sv glad_glNormal3sv
GLAD_API_CALL PFNGLNORMALP3UIPROC glad_glNormalP3ui;
#define glNormalP3ui glad_glNormalP3ui
GLAD_API_CALL PFNGLNORMALP3UIVPROC glad_glNormalP3uiv;
#define glNormalP3uiv glad_glNormalP3uiv
GLAD_API_CALL PFNGLNORMALPOINTERPROC glad_glNormalPointer;
#define glNormalPointer glad_glNormalPointer
GLAD_API_CALL PFNGLOBJECTLABELPROC glad_glObjectLabel;
#define glObjectLabel glad_glObjectLabel
GLAD_API_CALL PFNGLOBJECTPTRLABELPROC glad_glObjectPtrLabel;
#define glObjectPtrLabel glad_glObjectPtrLabel
GLAD_API_CALL PFNGLORTHOPROC glad_glOrtho;
#define glOrtho glad_glOrtho
GLAD_API_CALL PFNGLPASSTHROUGHPROC glad_glPassThrough;
#define glPassThrough glad_glPassThrough
GLAD_API_CALL PFNGLPATCHPARAMETERFVPROC glad_glPatchParameterfv;
#define glPatchParameterfv glad_glPatchParameterfv
GLAD_API_CALL PFNGLPATCHPARAMETERIPROC glad_glPatchParameteri;
#define glPatchParameteri glad_glPatchParameteri
GLAD_API_CALL PFNGLPAUSETRANSFORMFEEDBACKPROC glad_glPauseTransformFeedback;
#define glPauseTransformFeedback glad_glPauseTransformFeedback
GLAD_API_CALL PFNGLPIXELMAPFVPROC glad_glPixelMapfv;
#define glPixelMapfv glad_glPixelMapfv
GLAD_API_CALL PFNGLPIXELMAPUIVPROC glad_glPixelMapuiv;
#define glPixelMapuiv glad_glPixelMapuiv
GLAD_API_CALL PFNGLPIXELMAPUSVPROC glad_glPixelMapusv;
#define glPixelMapusv glad_glPixelMapusv
GLAD_API_CALL PFNGLPIXELSTOREFPROC glad_glPixelStoref;
#define glPixelStoref glad_glPixelStoref
GLAD_API_CALL PFNGLPIXELSTOREIPROC glad_glPixelStorei;
#define glPixelStorei glad_glPixelStorei
GLAD_API_CALL PFNGLPIXELTRANSFERFPROC glad_glPixelTransferf;
#define glPixelTransferf glad_glPixelTransferf
GLAD_API_CALL PFNGLPIXELTRANSFERIPROC glad_glPixelTransferi;
#define glPixelTransferi glad_glPixelTransferi
GLAD_API_CALL PFNGLPIXELZOOMPROC glad_glPixelZoom;
#define glPixelZoom glad_glPixelZoom
GLAD_API_CALL PFNGLPOINTPARAMETERFPROC glad_glPointParameterf;
#define glPointParameterf glad_glPointParameterf
GLAD_API_CALL PFNGLPOINTPARAMETERFVPROC glad_glPointParameterfv;
#define glPointParameterfv glad_glPointParameterfv
GLAD_API_CALL PFNGLPOINTPARAMETERIPROC glad_glPointParameteri;
#define glPointParameteri glad_glPointParameteri
GLAD_API_CALL PFNGLPOINTPARAMETERIVPROC glad_glPointParameteriv;
#define glPointParameteriv glad_glPointParameteriv
GLAD_API_CALL PFNGLPOINTSIZEPROC glad_glPointSize;
#define glPointSize glad_glPointSize
GLAD_API_CALL PFNGLPOLYGONMODEPROC glad_glPolygonMode;
#define glPolygonMode glad_glPolygonMode
GLAD_API_CALL PFNGLPOLYGONOFFSETPROC glad_glPolygonOffset;
#define glPolygonOffset glad_glPolygonOffset
GLAD_API_CALL PFNGLPOLYGONOFFSETCLAMPPROC glad_glPolygonOffsetClamp;
#define glPolygonOffsetClamp glad_glPolygonOffsetClamp
GLAD_API_CALL PFNGLPOLYGONSTIPPLEPROC glad_glPolygonStipple;
#define glPolygonStipple glad_glPolygonStipple
GLAD_API_CALL PFNGLPOPATTRIBPROC glad_glPopAttrib;
#define glPopAttrib glad_glPopAttrib
GLAD_API_CALL PFNGLPOPCLIENTATTRIBPROC glad_glPopClientAttrib;
#define glPopClientAttrib glad_glPopClientAttrib
GLAD_API_CALL PFNGLPOPDEBUGGROUPPROC glad_glPopDebugGroup;
#define glPopDebugGroup glad_glPopDebugGroup
GLAD_API_CALL PFNGLPOPMATRIXPROC glad_glPopMatrix;
#define glPopMatrix glad_glPopMatrix
GLAD_API_CALL PFNGLPOPNAMEPROC glad_glPopName;
#define glPopName glad_glPopName
GLAD_API_CALL PFNGLPRIMITIVERESTARTINDEXPROC glad_glPrimitiveRestartIndex;
#define glPrimitiveRestartIndex glad_glPrimitiveRestartIndex
GLAD_API_CALL PFNGLPRIORITIZETEXTURESPROC glad_glPrioritizeTextures;
#define glPrioritizeTextures glad_glPrioritizeTextures
GLAD_API_CALL PFNGLPROGRAMBINARYPROC glad_glProgramBinary;
#define glProgramBinary glad_glProgramBinary
GLAD_API_CALL PFNGLPROGRAMPARAMETERIPROC glad_glProgramParameteri;
#define glProgramParameteri glad_glProgramParameteri
GLAD_API_CALL PFNGLPROGRAMUNIFORM1DPROC glad_glProgramUniform1d;
#define glProgramUniform1d glad_glProgramUniform1d
GLAD_API_CALL PFNGLPROGRAMUNIFORM1DVPROC glad_glProgramUniform1dv;
#define glProgramUniform1dv glad_glProgramUniform1dv
GLAD_API_CALL PFNGLPROGRAMUNIFORM1FPROC glad_glProgramUniform1f;
#define glProgramUniform1f glad_glProgramUniform1f
GLAD_API_CALL PFNGLPROGRAMUNIFORM1FVPROC glad_glProgramUniform1fv;
#define glProgramUniform1fv glad_glProgramUniform1fv
GLAD_API_CALL PFNGLPROGRAMUNIFORM1IPROC glad_glProgramUniform1i;
#define glProgramUniform1i glad_glProgramUniform1i
GLAD_API_CALL PFNGLPROGRAMUNIFORM1IVPROC glad_glProgramUniform1iv;
#define glProgramUniform1iv glad_glProgramUniform1iv
GLAD_API_CALL PFNGLPROGRAMUNIFORM1UIPROC glad_glProgramUniform1ui;
#define glProgramUniform1ui glad_glProgramUniform1ui
GLAD_API_CALL PFNGLPROGRAMUNIFORM1UIVPROC glad_glProgramUniform1uiv;
#define glProgramUniform1uiv glad_glProgramUniform1uiv
GLAD_API_CALL PFNGLPROGRAMUNIFORM2DPROC glad_glProgramUniform2d;
#define glProgramUniform2d glad_glProgramUniform2d
GLAD_API_CALL PFNGLPROGRAMUNIFORM2DVPROC glad_glProgramUniform2dv;
#define glProgramUniform2dv glad_glProgramUniform2dv
GLAD_API_CALL PFNGLPROGRAMUNIFORM2FPROC glad_glProgramUniform2f;
#define glProgramUniform2f glad_glProgramUniform2f
GLAD_API_CALL PFNGLPROGRAMUNIFORM2FVPROC glad_glProgramUniform2fv;
#define glProgramUniform2fv glad_glProgramUniform2fv
GLAD_API_CALL PFNGLPROGRAMUNIFORM2IPROC glad_glProgramUniform2i;
#define glProgramUniform2i glad_glProgramUniform2i
GLAD_API_CALL PFNGLPROGRAMUNIFORM2IVPROC glad_glProgramUniform2iv;
#define glProgramUniform2iv glad_glProgramUniform2iv
GLAD_API_CALL PFNGLPROGRAMUNIFORM2UIPROC glad_glProgramUniform2ui;
#define glProgramUniform2ui glad_glProgramUniform2ui
GLAD_API_CALL PFNGLPROGRAMUNIFORM2UIVPROC glad_glProgramUniform2uiv;
#define glProgramUniform2uiv glad_glProgramUniform2uiv
GLAD_API_CALL PFNGLPROGRAMUNIFORM3DPROC glad_glProgramUniform3d;
#define glProgramUniform3d glad_glProgramUniform3d
GLAD_API_CALL PFNGLPROGRAMUNIFORM3DVPROC glad_glProgramUniform3dv;
#define glProgramUniform3dv glad_glProgramUniform3dv
GLAD_API_CALL PFNGLPROGRAMUNIFORM3FPROC glad_glProgramUniform3f;
#define glProgramUniform3f glad_glProgramUniform3f
GLAD_API_CALL PFNGLPROGRAMUNIFORM3FVPROC glad_glProgramUniform3fv;
#define glProgramUniform3fv glad_glProgramUniform3fv
GLAD_API_CALL PFNGLPROGRAMUNIFORM3IPROC glad_glProgramUniform3i;
#define glProgramUniform3i glad_glProgramUniform3i
GLAD_API_CALL PFNGLPROGRAMUNIFORM3IVPROC glad_glProgramUniform3iv;
#define glProgramUniform3iv glad_glProgramUniform3iv
GLAD_API_CALL PFNGLPROGRAMUNIFORM3UIPROC glad_glProgramUniform3ui;
#define glProgramUniform3ui glad_glProgramUniform3ui
GLAD_API_CALL PFNGLPROGRAMUNIFORM3UIVPROC glad_glProgramUniform3uiv;
#define glProgramUniform3uiv glad_glProgramUniform3uiv
GLAD_API_CALL PFNGLPROGRAMUNIFORM4DPROC glad_glProgramUniform4d;
#define glProgramUniform4d glad_glProgramUniform4d
GLAD_API_CALL PFNGLPROGRAMUNIFORM4DVPROC glad_glProgramUniform4dv;
#define glProgramUniform4dv glad_glProgramUniform4dv
GLAD_API_CALL PFNGLPROGRAMUNIFORM4FPROC glad_glProgramUniform4f;
#define glProgramUniform4f glad_glProgramUniform4f
GLAD_API_CALL PFNGLPROGRAMUNIFORM4FVPROC glad_glProgramUniform4fv;
#define glProgramUniform4fv glad_glProgramUniform4fv
GLAD_API_CALL PFNGLPROGRAMUNIFORM4IPROC glad_glProgramUniform4i;
#define glProgramUniform4i glad_glProgramUniform4i
GLAD_API_CALL PFNGLPROGRAMUNIFORM4IVPROC glad_glProgramUniform4iv;
#define glProgramUniform4iv glad_glProgramUniform4iv
GLAD_API_CALL PFNGLPROGRAMUNIFORM4UIPROC glad_glProgramUniform4ui;
#define glProgramUniform4ui glad_glProgramUniform4ui
GLAD_API_CALL PFNGLPROGRAMUNIFORM4UIVPROC glad_glProgramUniform4uiv;
#define glProgramUniform4uiv glad_glProgramUniform4uiv
GLAD_API_CALL PFNGLPROGRAMUNIFORMMATRIX2DVPROC glad_glProgramUniformMatrix2dv;
#define glProgramUniformMatrix2dv glad_glProgramUniformMatrix2dv
GLAD_API_CALL PFNGLPROGRAMUNIFORMMATRIX2FVPROC glad_glProgramUniformMatrix2fv;
#define glProgramUniformMatrix2fv glad_glProgramUniformMatrix2fv
GLAD_API_CALL PFNGLPROGRAMUNIFORMMATRIX2X3DVPROC glad_glProgramUniformMatrix2x3dv;
#define glProgramUniformMatrix2x3dv glad_glProgramUniformMatrix2x3dv
GLAD_API_CALL PFNGLPROGRAMUNIFORMMATRIX2X3FVPROC glad_glProgramUniformMatrix2x3fv;
#define glProgramUniformMatrix2x3fv glad_glProgramUniformMatrix2x3fv
GLAD_API_CALL PFNGLPROGRAMUNIFORMMATRIX2X4DVPROC glad_glProgramUniformMatrix2x4dv;
#define glProgramUniformMatrix2x4dv glad_glProgramUniformMatrix2x4dv
GLAD_API_CALL PFNGLPROGRAMUNIFORMMATRIX2X4FVPROC glad_glProgramUniformMatrix2x4fv;
#define glProgramUniformMatrix2x4fv glad_glProgramUniformMatrix2x4fv
GLAD_API_CALL PFNGLPROGRAMUNIFORMMATRIX3DVPROC glad_glProgramUniformMatrix3dv;
#define glProgramUniformMatrix3dv glad_glProgramUniformMatrix3dv
GLAD_API_CALL PFNGLPROGRAMUNIFORMMATRIX3FVPROC glad_glProgramUniformMatrix3fv;
#define glProgramUniformMatrix3fv glad_glProgramUniformMatrix3fv
GLAD_API_CALL PFNGLPROGRAMUNIFORMMATRIX3X2DVPROC glad_glProgramUniformMatrix3x2dv;
#define glProgramUniformMatrix3x2dv glad_glProgramUniformMatrix3x2dv
GLAD_API_CALL PFNGLPROGRAMUNIFORMMATRIX3X2FVPROC glad_glProgramUniformMatrix3x2fv;
#define glProgramUniformMatrix3x2fv glad_glProgramUniformMatrix3x2fv
GLAD_API_CALL PFNGLPROGRAMUNIFORMMATRIX3X4DVPROC glad_glProgramUniformMatrix3x4dv;
#define glProgramUniformMatrix3x4dv glad_glProgramUniformMatrix3x4dv
GLAD_API_CALL PFNGLPROGRAMUNIFORMMATRIX3X4FVPROC glad_glProgramUniformMatrix3x4fv;
#define glProgramUniformMatrix3x4fv glad_glProgramUniformMatrix3x4fv
GLAD_API_CALL PFNGLPROGRAMUNIFORMMATRIX4DVPROC glad_glProgramUniformMatrix4dv;
#define glProgramUniformMatrix4dv glad_glProgramUniformMatrix4dv
GLAD_API_CALL PFNGLPROGRAMUNIFORMMATRIX4FVPROC glad_glProgramUniformMatrix4fv;
#define glProgramUniformMatrix4fv glad_glProgramUniformMatrix4fv
GLAD_API_CALL PFNGLPROGRAMUNIFORMMATRIX4X2DVPROC glad_glProgramUniformMatrix4x2dv;
#define glProgramUniformMatrix4x2dv glad_glProgramUniformMatrix4x2dv
GLAD_API_CALL PFNGLPROGRAMUNIFORMMATRIX4X2FVPROC glad_glProgramUniformMatrix4x2fv;
#define glProgramUniformMatrix4x2fv glad_glProgramUniformMatrix4x2fv
GLAD_API_CALL PFNGLPROGRAMUNIFORMMATRIX4X3DVPROC glad_glProgramUniformMatrix4x3dv;
#define glProgramUniformMatrix4x3dv glad_glProgramUniformMatrix4x3dv
GLAD_API_CALL PFNGLPROGRAMUNIFORMMATRIX4X3FVPROC glad_glProgramUniformMatrix4x3fv;
#define glProgramUniformMatrix4x3fv glad_glProgramUniformMatrix4x3fv
GLAD_API_CALL PFNGLPROVOKINGVERTEXPROC glad_glProvokingVertex;
#define glProvokingVertex glad_glProvokingVertex
GLAD_API_CALL PFNGLPUSHATTRIBPROC glad_glPushAttrib;
#define glPushAttrib glad_glPushAttrib
GLAD_API_CALL PFNGLPUSHCLIENTATTRIBPROC glad_glPushClientAttrib;
#define glPushClientAttrib glad_glPushClientAttrib
GLAD_API_CALL PFNGLPUSHDEBUGGROUPPROC glad_glPushDebugGroup;
#define glPushDebugGroup glad_glPushDebugGroup
GLAD_API_CALL PFNGLPUSHMATRIXPROC glad_glPushMatrix;
#define glPushMatrix glad_glPushMatrix
GLAD_API_CALL PFNGLPUSHNAMEPROC glad_glPushName;
#define glPushName glad_glPushName
GLAD_API_CALL PFNGLQUERYCOUNTERPROC glad_glQueryCounter;
#define glQueryCounter glad_glQueryCounter
GLAD_API_CALL PFNGLRASTERPOS2DPROC glad_glRasterPos2d;
#define glRasterPos2d glad_glRasterPos2d
GLAD_API_CALL PFNGLRASTERPOS2DVPROC glad_glRasterPos2dv;
#define glRasterPos2dv glad_glRasterPos2dv
GLAD_API_CALL PFNGLRASTERPOS2FPROC glad_glRasterPos2f;
#define glRasterPos2f glad_glRasterPos2f
GLAD_API_CALL PFNGLRASTERPOS2FVPROC glad_glRasterPos2fv;
#define glRasterPos2fv glad_glRasterPos2fv
GLAD_API_CALL PFNGLRASTERPOS2IPROC glad_glRasterPos2i;
#define glRasterPos2i glad_glRasterPos2i
GLAD_API_CALL PFNGLRASTERPOS2IVPROC glad_glRasterPos2iv;
#define glRasterPos2iv glad_glRasterPos2iv
GLAD_API_CALL PFNGLRASTERPOS2SPROC glad_glRasterPos2s;
#define glRasterPos2s glad_glRasterPos2s
GLAD_API_CALL PFNGLRASTERPOS2SVPROC glad_glRasterPos2sv;
#define glRasterPos2sv glad_glRasterPos2sv
GLAD_API_CALL PFNGLRASTERPOS3DPROC glad_glRasterPos3d;
#define glRasterPos3d glad_glRasterPos3d
GLAD_API_CALL PFNGLRASTERPOS3DVPROC glad_glRasterPos3dv;
#define glRasterPos3dv glad_glRasterPos3dv
GLAD_API_CALL PFNGLRASTERPOS3FPROC glad_glRasterPos3f;
#define glRasterPos3f glad_glRasterPos3f
GLAD_API_CALL PFNGLRASTERPOS3FVPROC glad_glRasterPos3fv;
#define glRasterPos3fv glad_glRasterPos3fv
GLAD_API_CALL PFNGLRASTERPOS3IPROC glad_glRasterPos3i;
#define glRasterPos3i glad_glRasterPos3i
GLAD_API_CALL PFNGLRASTERPOS3IVPROC glad_glRasterPos3iv;
#define glRasterPos3iv glad_glRasterPos3iv
GLAD_API_CALL PFNGLRASTERPOS3SPROC glad_glRasterPos3s;
#define glRasterPos3s glad_glRasterPos3s
GLAD_API_CALL PFNGLRASTERPOS3SVPROC glad_glRasterPos3sv;
#define glRasterPos3sv glad_glRasterPos3sv
GLAD_API_CALL PFNGLRASTERPOS4DPROC glad_glRasterPos4d;
#define glRasterPos4d glad_glRasterPos4d
GLAD_API_CALL PFNGLRASTERPOS4DVPROC glad_glRasterPos4dv;
#define glRasterPos4dv glad_glRasterPos4dv
GLAD_API_CALL PFNGLRASTERPOS4FPROC glad_glRasterPos4f;
#define glRasterPos4f glad_glRasterPos4f
GLAD_API_CALL PFNGLRASTERPOS4FVPROC glad_glRasterPos4fv;
#define glRasterPos4fv glad_glRasterPos4fv
GLAD_API_CALL PFNGLRASTERPOS4IPROC glad_glRasterPos4i;
#define glRasterPos4i glad_glRasterPos4i
GLAD_API_CALL PFNGLRASTERPOS4IVPROC glad_glRasterPos4iv;
#define glRasterPos4iv glad_glRasterPos4iv
GLAD_API_CALL PFNGLRASTERPOS4SPROC glad_glRasterPos4s;
#define glRasterPos4s glad_glRasterPos4s
GLAD_API_CALL PFNGLRASTERPOS4SVPROC glad_glRasterPos4sv;
#define glRasterPos4sv glad_glRasterPos4sv
GLAD_API_CALL PFNGLREADBUFFERPROC glad_glReadBuffer;
#define glReadBuffer glad_glReadBuffer
GLAD_API_CALL PFNGLREADPIXELSPROC glad_glReadPixels;
#define glReadPixels glad_glReadPixels
GLAD_API_CALL PFNGLREADNPIXELSPROC glad_glReadnPixels;
#define glReadnPixels glad_glReadnPixels
GLAD_API_CALL PFNGLREADNPIXELSARBPROC glad_glReadnPixelsARB;
#define glReadnPixelsARB glad_glReadnPixelsARB
GLAD_API_CALL PFNGLRECTDPROC glad_glRectd;
#define glRectd glad_glRectd
GLAD_API_CALL PFNGLRECTDVPROC glad_glRectdv;
#define glRectdv glad_glRectdv
GLAD_API_CALL PFNGLRECTFPROC glad_glRectf;
#define glRectf glad_glRectf
GLAD_API_CALL PFNGLRECTFVPROC glad_glRectfv;
#define glRectfv glad_glRectfv
GLAD_API_CALL PFNGLRECTIPROC glad_glRecti;
#define glRecti glad_glRecti
GLAD_API_CALL PFNGLRECTIVPROC glad_glRectiv;
#define glRectiv glad_glRectiv
GLAD_API_CALL PFNGLRECTSPROC glad_glRects;
#define glRects glad_glRects
GLAD_API_CALL PFNGLRECTSVPROC glad_glRectsv;
#define glRectsv glad_glRectsv
GLAD_API_CALL PFNGLRELEASESHADERCOMPILERPROC glad_glReleaseShaderCompiler;
#define glReleaseShaderCompiler glad_glReleaseShaderCompiler
GLAD_API_CALL PFNGLRENDERMODEPROC glad_glRenderMode;
#define glRenderMode glad_glRenderMode
GLAD_API_CALL PFNGLRENDERBUFFERSTORAGEPROC glad_glRenderbufferStorage;
#define glRenderbufferStorage glad_glRenderbufferStorage
GLAD_API_CALL PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC glad_glRenderbufferStorageMultisample;
#define glRenderbufferStorageMultisample glad_glRenderbufferStorageMultisample
GLAD_API_CALL PFNGLRESUMETRANSFORMFEEDBACKPROC glad_glResumeTransformFeedback;
#define glResumeTransformFeedback glad_glResumeTransformFeedback
GLAD_API_CALL PFNGLROTATEDPROC glad_glRotated;
#define glRotated glad_glRotated
GLAD_API_CALL PFNGLROTATEFPROC glad_glRotatef;
#define glRotatef glad_glRotatef
GLAD_API_CALL PFNGLSAMPLECOVERAGEPROC glad_glSampleCoverage;
#define glSampleCoverage glad_glSampleCoverage
GLAD_API_CALL PFNGLSAMPLECOVERAGEARBPROC glad_glSampleCoverageARB;
#define glSampleCoverageARB glad_glSampleCoverageARB
GLAD_API_CALL PFNGLSAMPLEMASKIPROC glad_glSampleMaski;
#define glSampleMaski glad_glSampleMaski
GLAD_API_CALL PFNGLSAMPLERPARAMETERIIVPROC glad_glSamplerParameterIiv;
#define glSamplerParameterIiv glad_glSamplerParameterIiv
GLAD_API_CALL PFNGLSAMPLERPARAMETERIUIVPROC glad_glSamplerParameterIuiv;
#define glSamplerParameterIuiv glad_glSamplerParameterIuiv
GLAD_API_CALL PFNGLSAMPLERPARAMETERFPROC glad_glSamplerParameterf;
#define glSamplerParameterf glad_glSamplerParameterf
GLAD_API_CALL PFNGLSAMPLERPARAMETERFVPROC glad_glSamplerParameterfv;
#define glSamplerParameterfv glad_glSamplerParameterfv
GLAD_API_CALL PFNGLSAMPLERPARAMETERIPROC glad_glSamplerParameteri;
#define glSamplerParameteri glad_glSamplerParameteri
GLAD_API_CALL PFNGLSAMPLERPARAMETERIVPROC glad_glSamplerParameteriv;
#define glSamplerParameteriv glad_glSamplerParameteriv
GLAD_API_CALL PFNGLSCALEDPROC glad_glScaled;
#define glScaled glad_glScaled
GLAD_API_CALL PFNGLSCALEFPROC glad_glScalef;
#define glScalef glad_glScalef
GLAD_API_CALL PFNGLSCISSORPROC glad_glScissor;
#define glScissor glad_glScissor
GLAD_API_CALL PFNGLSCISSORARRAYVPROC glad_glScissorArrayv;
#define glScissorArrayv glad_glScissorArrayv
GLAD_API_CALL PFNGLSCISSORINDEXEDPROC glad_glScissorIndexed;
#define glScissorIndexed glad_glScissorIndexed
GLAD_API_CALL PFNGLSCISSORINDEXEDVPROC glad_glScissorIndexedv;
#define glScissorIndexedv glad_glScissorIndexedv
GLAD_API_CALL PFNGLSECONDARYCOLOR3BPROC glad_glSecondaryColor3b;
#define glSecondaryColor3b glad_glSecondaryColor3b
GLAD_API_CALL PFNGLSECONDARYCOLOR3BVPROC glad_glSecondaryColor3bv;
#define glSecondaryColor3bv glad_glSecondaryColor3bv
GLAD_API_CALL PFNGLSECONDARYCOLOR3DPROC glad_glSecondaryColor3d;
#define glSecondaryColor3d glad_glSecondaryColor3d
GLAD_API_CALL PFNGLSECONDARYCOLOR3DVPROC glad_glSecondaryColor3dv;
#define glSecondaryColor3dv glad_glSecondaryColor3dv
GLAD_API_CALL PFNGLSECONDARYCOLOR3FPROC glad_glSecondaryColor3f;
#define glSecondaryColor3f glad_glSecondaryColor3f
GLAD_API_CALL PFNGLSECONDARYCOLOR3FVPROC glad_glSecondaryColor3fv;
#define glSecondaryColor3fv glad_glSecondaryColor3fv
GLAD_API_CALL PFNGLSECONDARYCOLOR3IPROC glad_glSecondaryColor3i;
#define glSecondaryColor3i glad_glSecondaryColor3i
GLAD_API_CALL PFNGLSECONDARYCOLOR3IVPROC glad_glSecondaryColor3iv;
#define glSecondaryColor3iv glad_glSecondaryColor3iv
GLAD_API_CALL PFNGLSECONDARYCOLOR3SPROC glad_glSecondaryColor3s;
#define glSecondaryColor3s glad_glSecondaryColor3s
GLAD_API_CALL PFNGLSECONDARYCOLOR3SVPROC glad_glSecondaryColor3sv;
#define glSecondaryColor3sv glad_glSecondaryColor3sv
GLAD_API_CALL PFNGLSECONDARYCOLOR3UBPROC glad_glSecondaryColor3ub;
#define glSecondaryColor3ub glad_glSecondaryColor3ub
GLAD_API_CALL PFNGLSECONDARYCOLOR3UBVPROC glad_glSecondaryColor3ubv;
#define glSecondaryColor3ubv glad_glSecondaryColor3ubv
GLAD_API_CALL PFNGLSECONDARYCOLOR3UIPROC glad_glSecondaryColor3ui;
#define glSecondaryColor3ui glad_glSecondaryColor3ui
GLAD_API_CALL PFNGLSECONDARYCOLOR3UIVPROC glad_glSecondaryColor3uiv;
#define glSecondaryColor3uiv glad_glSecondaryColor3uiv
GLAD_API_CALL PFNGLSECONDARYCOLOR3USPROC glad_glSecondaryColor3us;
#define glSecondaryColor3us glad_glSecondaryColor3us
GLAD_API_CALL PFNGLSECONDARYCOLOR3USVPROC glad_glSecondaryColor3usv;
#define glSecondaryColor3usv glad_glSecondaryColor3usv
GLAD_API_CALL PFNGLSECONDARYCOLORP3UIPROC glad_glSecondaryColorP3ui;
#define glSecondaryColorP3ui glad_glSecondaryColorP3ui
GLAD_API_CALL PFNGLSECONDARYCOLORP3UIVPROC glad_glSecondaryColorP3uiv;
#define glSecondaryColorP3uiv glad_glSecondaryColorP3uiv
GLAD_API_CALL PFNGLSECONDARYCOLORPOINTERPROC glad_glSecondaryColorPointer;
#define glSecondaryColorPointer glad_glSecondaryColorPointer
GLAD_API_CALL PFNGLSELECTBUFFERPROC glad_glSelectBuffer;
#define glSelectBuffer glad_glSelectBuffer
GLAD_API_CALL PFNGLSHADEMODELPROC glad_glShadeModel;
#define glShadeModel glad_glShadeModel
GLAD_API_CALL PFNGLSHADERBINARYPROC glad_glShaderBinary;
#define glShaderBinary glad_glShaderBinary
GLAD_API_CALL PFNGLSHADERSOURCEPROC glad_glShaderSource;
#define glShaderSource glad_glShaderSource
GLAD_API_CALL PFNGLSHADERSTORAGEBLOCKBINDINGPROC glad_glShaderStorageBlockBinding;
#define glShaderStorageBlockBinding glad_glShaderStorageBlockBinding
GLAD_API_CALL PFNGLSPECIALIZESHADERPROC glad_glSpecializeShader;
#define glSpecializeShader glad_glSpecializeShader
GLAD_API_CALL PFNGLSTENCILFUNCPROC glad_glStencilFunc;
#define glStencilFunc glad_glStencilFunc
GLAD_API_CALL PFNGLSTENCILFUNCSEPARATEPROC glad_glStencilFuncSeparate;
#define glStencilFuncSeparate glad_glStencilFuncSeparate
GLAD_API_CALL PFNGLSTENCILMASKPROC glad_glStencilMask;
#define glStencilMask glad_glStencilMask
GLAD_API_CALL PFNGLSTENCILMASKSEPARATEPROC glad_glStencilMaskSeparate;
#define glStencilMaskSeparate glad_glStencilMaskSeparate
GLAD_API_CALL PFNGLSTENCILOPPROC glad_glStencilOp;
#define glStencilOp glad_glStencilOp
GLAD_API_CALL PFNGLSTENCILOPSEPARATEPROC glad_glStencilOpSeparate;
#define glStencilOpSeparate glad_glStencilOpSeparate
GLAD_API_CALL PFNGLTEXBUFFERPROC glad_glTexBuffer;
#define glTexBuffer glad_glTexBuffer
GLAD_API_CALL PFNGLTEXBUFFERRANGEPROC glad_glTexBufferRange;
#define glTexBufferRange glad_glTexBufferRange
GLAD_API_CALL PFNGLTEXCOORD1DPROC glad_glTexCoord1d;
#define glTexCoord1d glad_glTexCoord1d
GLAD_API_CALL PFNGLTEXCOORD1DVPROC glad_glTexCoord1dv;
#define glTexCoord1dv glad_glTexCoord1dv
GLAD_API_CALL PFNGLTEXCOORD1FPROC glad_glTexCoord1f;
#define glTexCoord1f glad_glTexCoord1f
GLAD_API_CALL PFNGLTEXCOORD1FVPROC glad_glTexCoord1fv;
#define glTexCoord1fv glad_glTexCoord1fv
GLAD_API_CALL PFNGLTEXCOORD1IPROC glad_glTexCoord1i;
#define glTexCoord1i glad_glTexCoord1i
GLAD_API_CALL PFNGLTEXCOORD1IVPROC glad_glTexCoord1iv;
#define glTexCoord1iv glad_glTexCoord1iv
GLAD_API_CALL PFNGLTEXCOORD1SPROC glad_glTexCoord1s;
#define glTexCoord1s glad_glTexCoord1s
GLAD_API_CALL PFNGLTEXCOORD1SVPROC glad_glTexCoord1sv;
#define glTexCoord1sv glad_glTexCoord1sv
GLAD_API_CALL PFNGLTEXCOORD2DPROC glad_glTexCoord2d;
#define glTexCoord2d glad_glTexCoord2d
GLAD_API_CALL PFNGLTEXCOORD2DVPROC glad_glTexCoord2dv;
#define glTexCoord2dv glad_glTexCoord2dv
GLAD_API_CALL PFNGLTEXCOORD2FPROC glad_glTexCoord2f;
#define glTexCoord2f glad_glTexCoord2f
GLAD_API_CALL PFNGLTEXCOORD2FVPROC glad_glTexCoord2fv;
#define glTexCoord2fv glad_glTexCoord2fv
GLAD_API_CALL PFNGLTEXCOORD2IPROC glad_glTexCoord2i;
#define glTexCoord2i glad_glTexCoord2i
GLAD_API_CALL PFNGLTEXCOORD2IVPROC glad_glTexCoord2iv;
#define glTexCoord2iv glad_glTexCoord2iv
GLAD_API_CALL PFNGLTEXCOORD2SPROC glad_glTexCoord2s;
#define glTexCoord2s glad_glTexCoord2s
GLAD_API_CALL PFNGLTEXCOORD2SVPROC glad_glTexCoord2sv;
#define glTexCoord2sv glad_glTexCoord2sv
GLAD_API_CALL PFNGLTEXCOORD3DPROC glad_glTexCoord3d;
#define glTexCoord3d glad_glTexCoord3d
GLAD_API_CALL PFNGLTEXCOORD3DVPROC glad_glTexCoord3dv;
#define glTexCoord3dv glad_glTexCoord3dv
GLAD_API_CALL PFNGLTEXCOORD3FPROC glad_glTexCoord3f;
#define glTexCoord3f glad_glTexCoord3f
GLAD_API_CALL PFNGLTEXCOORD3FVPROC glad_glTexCoord3fv;
#define glTexCoord3fv glad_glTexCoord3fv
GLAD_API_CALL PFNGLTEXCOORD3IPROC glad_glTexCoord3i;
#define glTexCoord3i glad_glTexCoord3i
GLAD_API_CALL PFNGLTEXCOORD3IVPROC glad_glTexCoord3iv;
#define glTexCoord3iv glad_glTexCoord3iv
GLAD_API_CALL PFNGLTEXCOORD3SPROC glad_glTexCoord3s;
#define glTexCoord3s glad_glTexCoord3s
GLAD_API_CALL PFNGLTEXCOORD3SVPROC glad_glTexCoord3sv;
#define glTexCoord3sv glad_glTexCoord3sv
GLAD_API_CALL PFNGLTEXCOORD4DPROC glad_glTexCoord4d;
#define glTexCoord4d glad_glTexCoord4d
GLAD_API_CALL PFNGLTEXCOORD4DVPROC glad_glTexCoord4dv;
#define glTexCoord4dv glad_glTexCoord4dv
GLAD_API_CALL PFNGLTEXCOORD4FPROC glad_glTexCoord4f;
#define glTexCoord4f glad_glTexCoord4f
GLAD_API_CALL PFNGLTEXCOORD4FVPROC glad_glTexCoord4fv;
#define glTexCoord4fv glad_glTexCoord4fv
GLAD_API_CALL PFNGLTEXCOORD4IPROC glad_glTexCoord4i;
#define glTexCoord4i glad_glTexCoord4i
GLAD_API_CALL PFNGLTEXCOORD4IVPROC glad_glTexCoord4iv;
#define glTexCoord4iv glad_glTexCoord4iv
GLAD_API_CALL PFNGLTEXCOORD4SPROC glad_glTexCoord4s;
#define glTexCoord4s glad_glTexCoord4s
GLAD_API_CALL PFNGLTEXCOORD4SVPROC glad_glTexCoord4sv;
#define glTexCoord4sv glad_glTexCoord4sv
GLAD_API_CALL PFNGLTEXCOORDP1UIPROC glad_glTexCoordP1ui;
#define glTexCoordP1ui glad_glTexCoordP1ui
GLAD_API_CALL PFNGLTEXCOORDP1UIVPROC glad_glTexCoordP1uiv;
#define glTexCoordP1uiv glad_glTexCoordP1uiv
GLAD_API_CALL PFNGLTEXCOORDP2UIPROC glad_glTexCoordP2ui;
#define glTexCoordP2ui glad_glTexCoordP2ui
GLAD_API_CALL PFNGLTEXCOORDP2UIVPROC glad_glTexCoordP2uiv;
#define glTexCoordP2uiv glad_glTexCoordP2uiv
GLAD_API_CALL PFNGLTEXCOORDP3UIPROC glad_glTexCoordP3ui;
#define glTexCoordP3ui glad_glTexCoordP3ui
GLAD_API_CALL PFNGLTEXCOORDP3UIVPROC glad_glTexCoordP3uiv;
#define glTexCoordP3uiv glad_glTexCoordP3uiv
GLAD_API_CALL PFNGLTEXCOORDP4UIPROC glad_glTexCoordP4ui;
#define glTexCoordP4ui glad_glTexCoordP4ui
GLAD_API_CALL PFNGLTEXCOORDP4UIVPROC glad_glTexCoordP4uiv;
#define glTexCoordP4uiv glad_glTexCoordP4uiv
GLAD_API_CALL PFNGLTEXCOORDPOINTERPROC glad_glTexCoordPointer;
#define glTexCoordPointer glad_glTexCoordPointer
GLAD_API_CALL PFNGLTEXENVFPROC glad_glTexEnvf;
#define glTexEnvf glad_glTexEnvf
GLAD_API_CALL PFNGLTEXENVFVPROC glad_glTexEnvfv;
#define glTexEnvfv glad_glTexEnvfv
GLAD_API_CALL PFNGLTEXENVIPROC glad_glTexEnvi;
#define glTexEnvi glad_glTexEnvi
GLAD_API_CALL PFNGLTEXENVIVPROC glad_glTexEnviv;
#define glTexEnviv glad_glTexEnviv
GLAD_API_CALL PFNGLTEXGENDPROC glad_glTexGend;
#define glTexGend glad_glTexGend
GLAD_API_CALL PFNGLTEXGENDVPROC glad_glTexGendv;
#define glTexGendv glad_glTexGendv
GLAD_API_CALL PFNGLTEXGENFPROC glad_glTexGenf;
#define glTexGenf glad_glTexGenf
GLAD_API_CALL PFNGLTEXGENFVPROC glad_glTexGenfv;
#define glTexGenfv glad_glTexGenfv
GLAD_API_CALL PFNGLTEXGENIPROC glad_glTexGeni;
#define glTexGeni glad_glTexGeni
GLAD_API_CALL PFNGLTEXGENIVPROC glad_glTexGeniv;
#define glTexGeniv glad_glTexGeniv
GLAD_API_CALL PFNGLTEXIMAGE1DPROC glad_glTexImage1D;
#define glTexImage1D glad_glTexImage1D
GLAD_API_CALL PFNGLTEXIMAGE2DPROC glad_glTexImage2D;
#define glTexImage2D glad_glTexImage2D
GLAD_API_CALL PFNGLTEXIMAGE2DMULTISAMPLEPROC glad_glTexImage2DMultisample;
#define glTexImage2DMultisample glad_glTexImage2DMultisample
GLAD_API_CALL PFNGLTEXIMAGE3DPROC glad_glTexImage3D;
#define glTexImage3D glad_glTexImage3D
GLAD_API_CALL PFNGLTEXIMAGE3DMULTISAMPLEPROC glad_glTexImage3DMultisample;
#define glTexImage3DMultisample glad_glTexImage3DMultisample
GLAD_API_CALL PFNGLTEXPARAMETERIIVPROC glad_glTexParameterIiv;
#define glTexParameterIiv glad_glTexParameterIiv
GLAD_API_CALL PFNGLTEXPARAMETERIUIVPROC glad_glTexParameterIuiv;
#define glTexParameterIuiv glad_glTexParameterIuiv
GLAD_API_CALL PFNGLTEXPARAMETERFPROC glad_glTexParameterf;
#define glTexParameterf glad_glTexParameterf
GLAD_API_CALL PFNGLTEXPARAMETERFVPROC glad_glTexParameterfv;
#define glTexParameterfv glad_glTexParameterfv
GLAD_API_CALL PFNGLTEXPARAMETERIPROC glad_glTexParameteri;
#define glTexParameteri glad_glTexParameteri
GLAD_API_CALL PFNGLTEXPARAMETERIVPROC glad_glTexParameteriv;
#define glTexParameteriv glad_glTexParameteriv
GLAD_API_CALL PFNGLTEXSTORAGE1DPROC glad_glTexStorage1D;
#define glTexStorage1D glad_glTexStorage1D
GLAD_API_CALL PFNGLTEXSTORAGE2DPROC glad_glTexStorage2D;
#define glTexStorage2D glad_glTexStorage2D
GLAD_API_CALL PFNGLTEXSTORAGE2DMULTISAMPLEPROC glad_glTexStorage2DMultisample;
#define glTexStorage2DMultisample glad_glTexStorage2DMultisample
GLAD_API_CALL PFNGLTEXSTORAGE3DPROC glad_glTexStorage3D;
#define glTexStorage3D glad_glTexStorage3D
GLAD_API_CALL PFNGLTEXSTORAGE3DMULTISAMPLEPROC glad_glTexStorage3DMultisample;
#define glTexStorage3DMultisample glad_glTexStorage3DMultisample
GLAD_API_CALL PFNGLTEXSUBIMAGE1DPROC glad_glTexSubImage1D;
#define glTexSubImage1D glad_glTexSubImage1D
GLAD_API_CALL PFNGLTEXSUBIMAGE2DPROC glad_glTexSubImage2D;
#define glTexSubImage2D glad_glTexSubImage2D
GLAD_API_CALL PFNGLTEXSUBIMAGE3DPROC glad_glTexSubImage3D;
#define glTexSubImage3D glad_glTexSubImage3D
GLAD_API_CALL PFNGLTEXTUREBARRIERPROC glad_glTextureBarrier;
#define glTextureBarrier glad_glTextureBarrier
GLAD_API_CALL PFNGLTEXTUREBUFFERPROC glad_glTextureBuffer;
#define glTextureBuffer glad_glTextureBuffer
GLAD_API_CALL PFNGLTEXTUREBUFFERRANGEPROC glad_glTextureBufferRange;
#define glTextureBufferRange glad_glTextureBufferRange
GLAD_API_CALL PFNGLTEXTUREPARAMETERIIVPROC glad_glTextureParameterIiv;
#define glTextureParameterIiv glad_glTextureParameterIiv
GLAD_API_CALL PFNGLTEXTUREPARAMETERIUIVPROC glad_glTextureParameterIuiv;
#define glTextureParameterIuiv glad_glTextureParameterIuiv
GLAD_API_CALL PFNGLTEXTUREPARAMETERFPROC glad_glTextureParameterf;
#define glTextureParameterf glad_glTextureParameterf
GLAD_API_CALL PFNGLTEXTUREPARAMETERFVPROC glad_glTextureParameterfv;
#define glTextureParameterfv glad_glTextureParameterfv
GLAD_API_CALL PFNGLTEXTUREPARAMETERIPROC glad_glTextureParameteri;
#define glTextureParameteri glad_glTextureParameteri
GLAD_API_CALL PFNGLTEXTUREPARAMETERIVPROC glad_glTextureParameteriv;
#define glTextureParameteriv glad_glTextureParameteriv
GLAD_API_CALL PFNGLTEXTURESTORAGE1DPROC glad_glTextureStorage1D;
#define glTextureStorage1D glad_glTextureStorage1D
GLAD_API_CALL PFNGLTEXTURESTORAGE2DPROC glad_glTextureStorage2D;
#define glTextureStorage2D glad_glTextureStorage2D
GLAD_API_CALL PFNGLTEXTURESTORAGE2DMULTISAMPLEPROC glad_glTextureStorage2DMultisample;
#define glTextureStorage2DMultisample glad_glTextureStorage2DMultisample
GLAD_API_CALL PFNGLTEXTURESTORAGE3DPROC glad_glTextureStorage3D;
#define glTextureStorage3D glad_glTextureStorage3D
GLAD_API_CALL PFNGLTEXTURESTORAGE3DMULTISAMPLEPROC glad_glTextureStorage3DMultisample;
#define glTextureStorage3DMultisample glad_glTextureStorage3DMultisample
GLAD_API_CALL PFNGLTEXTURESUBIMAGE1DPROC glad_glTextureSubImage1D;
#define glTextureSubImage1D glad_glTextureSubImage1D
GLAD_API_CALL PFNGLTEXTURESUBIMAGE2DPROC glad_glTextureSubImage2D;
#define glTextureSubImage2D glad_glTextureSubImage2D
GLAD_API_CALL PFNGLTEXTURESUBIMAGE3DPROC glad_glTextureSubImage3D;
#define glTextureSubImage3D glad_glTextureSubImage3D
GLAD_API_CALL PFNGLTEXTUREVIEWPROC glad_glTextureView;
#define glTextureView glad_glTextureView
GLAD_API_CALL PFNGLTRANSFORMFEEDBACKBUFFERBASEPROC glad_glTransformFeedbackBufferBase;
#define glTransformFeedbackBufferBase glad_glTransformFeedbackBufferBase
GLAD_API_CALL PFNGLTRANSFORMFEEDBACKBUFFERRANGEPROC glad_glTransformFeedbackBufferRange;
#define glTransformFeedbackBufferRange glad_glTransformFeedbackBufferRange
GLAD_API_CALL PFNGLTRANSFORMFEEDBACKVARYINGSPROC glad_glTransformFeedbackVaryings;
#define glTransformFeedbackVaryings glad_glTransformFeedbackVaryings
GLAD_API_CALL PFNGLTRANSLATEDPROC glad_glTranslated;
#define glTranslated glad_glTranslated
GLAD_API_CALL PFNGLTRANSLATEFPROC glad_glTranslatef;
#define glTranslatef glad_glTranslatef
GLAD_API_CALL PFNGLUNIFORM1DPROC glad_glUniform1d;
#define glUniform1d glad_glUniform1d
GLAD_API_CALL PFNGLUNIFORM1DVPROC glad_glUniform1dv;
#define glUniform1dv glad_glUniform1dv
GLAD_API_CALL PFNGLUNIFORM1FPROC glad_glUniform1f;
#define glUniform1f glad_glUniform1f
GLAD_API_CALL PFNGLUNIFORM1FVPROC glad_glUniform1fv;
#define glUniform1fv glad_glUniform1fv
GLAD_API_CALL PFNGLUNIFORM1IPROC glad_glUniform1i;
#define glUniform1i glad_glUniform1i
GLAD_API_CALL PFNGLUNIFORM1IVPROC glad_glUniform1iv;
#define glUniform1iv glad_glUniform1iv
GLAD_API_CALL PFNGLUNIFORM1UIPROC glad_glUniform1ui;
#define glUniform1ui glad_glUniform1ui
GLAD_API_CALL PFNGLUNIFORM1UIVPROC glad_glUniform1uiv;
#define glUniform1uiv glad_glUniform1uiv
GLAD_API_CALL PFNGLUNIFORM2DPROC glad_glUniform2d;
#define glUniform2d glad_glUniform2d
GLAD_API_CALL PFNGLUNIFORM2DVPROC glad_glUniform2dv;
#define glUniform2dv glad_glUniform2dv
GLAD_API_CALL PFNGLUNIFORM2FPROC glad_glUniform2f;
#define glUniform2f glad_glUniform2f
GLAD_API_CALL PFNGLUNIFORM2FVPROC glad_glUniform2fv;
#define glUniform2fv glad_glUniform2fv
GLAD_API_CALL PFNGLUNIFORM2IPROC glad_glUniform2i;
#define glUniform2i glad_glUniform2i
GLAD_API_CALL PFNGLUNIFORM2IVPROC glad_glUniform2iv;
#define glUniform2iv glad_glUniform2iv
GLAD_API_CALL PFNGLUNIFORM2UIPROC glad_glUniform2ui;
#define glUniform2ui glad_glUniform2ui
GLAD_API_CALL PFNGLUNIFORM2UIVPROC glad_glUniform2uiv;
#define glUniform2uiv glad_glUniform2uiv
GLAD_API_CALL PFNGLUNIFORM3DPROC glad_glUniform3d;
#define glUniform3d glad_glUniform3d
GLAD_API_CALL PFNGLUNIFORM3DVPROC glad_glUniform3dv;
#define glUniform3dv glad_glUniform3dv
GLAD_API_CALL PFNGLUNIFORM3FPROC glad_glUniform3f;
#define glUniform3f glad_glUniform3f
GLAD_API_CALL PFNGLUNIFORM3FVPROC glad_glUniform3fv;
#define glUniform3fv glad_glUniform3fv
GLAD_API_CALL PFNGLUNIFORM3IPROC glad_glUniform3i;
#define glUniform3i glad_glUniform3i
GLAD_API_CALL PFNGLUNIFORM3IVPROC glad_glUniform3iv;
#define glUniform3iv glad_glUniform3iv
GLAD_API_CALL PFNGLUNIFORM3UIPROC glad_glUniform3ui;
#define glUniform3ui glad_glUniform3ui
GLAD_API_CALL PFNGLUNIFORM3UIVPROC glad_glUniform3uiv;
#define glUniform3uiv glad_glUniform3uiv
GLAD_API_CALL PFNGLUNIFORM4DPROC glad_glUniform4d;
#define glUniform4d glad_glUniform4d
GLAD_API_CALL PFNGLUNIFORM4DVPROC glad_glUniform4dv;
#define glUniform4dv glad_glUniform4dv
GLAD_API_CALL PFNGLUNIFORM4FPROC glad_glUniform4f;
#define glUniform4f glad_glUniform4f
GLAD_API_CALL PFNGLUNIFORM4FVPROC glad_glUniform4fv;
#define glUniform4fv glad_glUniform4fv
GLAD_API_CALL PFNGLUNIFORM4IPROC glad_glUniform4i;
#define glUniform4i glad_glUniform4i
GLAD_API_CALL PFNGLUNIFORM4IVPROC glad_glUniform4iv;
#define glUniform4iv glad_glUniform4iv
GLAD_API_CALL PFNGLUNIFORM4UIPROC glad_glUniform4ui;
#define glUniform4ui glad_glUniform4ui
GLAD_API_CALL PFNGLUNIFORM4UIVPROC glad_glUniform4uiv;
#define glUniform4uiv glad_glUniform4uiv
GLAD_API_CALL PFNGLUNIFORMBLOCKBINDINGPROC glad_glUniformBlockBinding;
#define glUniformBlockBinding glad_glUniformBlockBinding
GLAD_API_CALL PFNGLUNIFORMMATRIX2DVPROC glad_glUniformMatrix2dv;
#define glUniformMatrix2dv glad_glUniformMatrix2dv
GLAD_API_CALL PFNGLUNIFORMMATRIX2FVPROC glad_glUniformMatrix2fv;
#define glUniformMatrix2fv glad_glUniformMatrix2fv
GLAD_API_CALL PFNGLUNIFORMMATRIX2X3DVPROC glad_glUniformMatrix2x3dv;
#define glUniformMatrix2x3dv glad_glUniformMatrix2x3dv
GLAD_API_CALL PFNGLUNIFORMMATRIX2X3FVPROC glad_glUniformMatrix2x3fv;
#define glUniformMatrix2x3fv glad_glUniformMatrix2x3fv
GLAD_API_CALL PFNGLUNIFORMMATRIX2X4DVPROC glad_glUniformMatrix2x4dv;
#define glUniformMatrix2x4dv glad_glUniformMatrix2x4dv
GLAD_API_CALL PFNGLUNIFORMMATRIX2X4FVPROC glad_glUniformMatrix2x4fv;
#define glUniformMatrix2x4fv glad_glUniformMatrix2x4fv
GLAD_API_CALL PFNGLUNIFORMMATRIX3DVPROC glad_glUniformMatrix3dv;
#define glUniformMatrix3dv glad_glUniformMatrix3dv
GLAD_API_CALL PFNGLUNIFORMMATRIX3FVPROC glad_glUniformMatrix3fv;
#define glUniformMatrix3fv glad_glUniformMatrix3fv
GLAD_API_CALL PFNGLUNIFORMMATRIX3X2DVPROC glad_glUniformMatrix3x2dv;
#define glUniformMatrix3x2dv glad_glUniformMatrix3x2dv
GLAD_API_CALL PFNGLUNIFORMMATRIX3X2FVPROC glad_glUniformMatrix3x2fv;
#define glUniformMatrix3x2fv glad_glUniformMatrix3x2fv
GLAD_API_CALL PFNGLUNIFORMMATRIX3X4DVPROC glad_glUniformMatrix3x4dv;
#define glUniformMatrix3x4dv glad_glUniformMatrix3x4dv
GLAD_API_CALL PFNGLUNIFORMMATRIX3X4FVPROC glad_glUniformMatrix3x4fv;
#define glUniformMatrix3x4fv glad_glUniformMatrix3x4fv
GLAD_API_CALL PFNGLUNIFORMMATRIX4DVPROC glad_glUniformMatrix4dv;
#define glUniformMatrix4dv glad_glUniformMatrix4dv
GLAD_API_CALL PFNGLUNIFORMMATRIX4FVPROC glad_glUniformMatrix4fv;
#define glUniformMatrix4fv glad_glUniformMatrix4fv
GLAD_API_CALL PFNGLUNIFORMMATRIX4X2DVPROC glad_glUniformMatrix4x2dv;
#define glUniformMatrix4x2dv glad_glUniformMatrix4x2dv
GLAD_API_CALL PFNGLUNIFORMMATRIX4X2FVPROC glad_glUniformMatrix4x2fv;
#define glUniformMatrix4x2fv glad_glUniformMatrix4x2fv
GLAD_API_CALL PFNGLUNIFORMMATRIX4X3DVPROC glad_glUniformMatrix4x3dv;
#define glUniformMatrix4x3dv glad_glUniformMatrix4x3dv
GLAD_API_CALL PFNGLUNIFORMMATRIX4X3FVPROC glad_glUniformMatrix4x3fv;
#define glUniformMatrix4x3fv glad_glUniformMatrix4x3fv
GLAD_API_CALL PFNGLUNIFORMSUBROUTINESUIVPROC glad_glUniformSubroutinesuiv;
#define glUniformSubroutinesuiv glad_glUniformSubroutinesuiv
GLAD_API_CALL PFNGLUNMAPBUFFERPROC glad_glUnmapBuffer;
#define glUnmapBuffer glad_glUnmapBuffer
GLAD_API_CALL PFNGLUNMAPNAMEDBUFFERPROC glad_glUnmapNamedBuffer;
#define glUnmapNamedBuffer glad_glUnmapNamedBuffer
GLAD_API_CALL PFNGLUSEPROGRAMPROC glad_glUseProgram;
#define glUseProgram glad_glUseProgram
GLAD_API_CALL PFNGLUSEPROGRAMSTAGESPROC glad_glUseProgramStages;
#define glUseProgramStages glad_glUseProgramStages
GLAD_API_CALL PFNGLVALIDATEPROGRAMPROC glad_glValidateProgram;
#define glValidateProgram glad_glValidateProgram
GLAD_API_CALL PFNGLVALIDATEPROGRAMPIPELINEPROC glad_glValidateProgramPipeline;
#define glValidateProgramPipeline glad_glValidateProgramPipeline
GLAD_API_CALL PFNGLVERTEX2DPROC glad_glVertex2d;
#define glVertex2d glad_glVertex2d
GLAD_API_CALL PFNGLVERTEX2DVPROC glad_glVertex2dv;
#define glVertex2dv glad_glVertex2dv
GLAD_API_CALL PFNGLVERTEX2FPROC glad_glVertex2f;
#define glVertex2f glad_glVertex2f
GLAD_API_CALL PFNGLVERTEX2FVPROC glad_glVertex2fv;
#define glVertex2fv glad_glVertex2fv
GLAD_API_CALL PFNGLVERTEX2IPROC glad_glVertex2i;
#define glVertex2i glad_glVertex2i
GLAD_API_CALL PFNGLVERTEX2IVPROC glad_glVertex2iv;
#define glVertex2iv glad_glVertex2iv
GLAD_API_CALL PFNGLVERTEX2SPROC glad_glVertex2s;
#define glVertex2s glad_glVertex2s
GLAD_API_CALL PFNGLVERTEX2SVPROC glad_glVertex2sv;
#define glVertex2sv glad_glVertex2sv
GLAD_API_CALL PFNGLVERTEX3DPROC glad_glVertex3d;
#define glVertex3d glad_glVertex3d
GLAD_API_CALL PFNGLVERTEX3DVPROC glad_glVertex3dv;
#define glVertex3dv glad_glVertex3dv
GLAD_API_CALL PFNGLVERTEX3FPROC glad_glVertex3f;
#define glVertex3f glad_glVertex3f
GLAD_API_CALL PFNGLVERTEX3FVPROC glad_glVertex3fv;
#define glVertex3fv glad_glVertex3fv
GLAD_API_CALL PFNGLVERTEX3IPROC glad_glVertex3i;
#define glVertex3i glad_glVertex3i
GLAD_API_CALL PFNGLVERTEX3IVPROC glad_glVertex3iv;
#define glVertex3iv glad_glVertex3iv
GLAD_API_CALL PFNGLVERTEX3SPROC glad_glVertex3s;
#define glVertex3s glad_glVertex3s
GLAD_API_CALL PFNGLVERTEX3SVPROC glad_glVertex3sv;
#define glVertex3sv glad_glVertex3sv
GLAD_API_CALL PFNGLVERTEX4DPROC glad_glVertex4d;
#define glVertex4d glad_glVertex4d
GLAD_API_CALL PFNGLVERTEX4DVPROC glad_glVertex4dv;
#define glVertex4dv glad_glVertex4dv
GLAD_API_CALL PFNGLVERTEX4FPROC glad_glVertex4f;
#define glVertex4f glad_glVertex4f
GLAD_API_CALL PFNGLVERTEX4FVPROC glad_glVertex4fv;
#define glVertex4fv glad_glVertex4fv
GLAD_API_CALL PFNGLVERTEX4IPROC glad_glVertex4i;
#define glVertex4i glad_glVertex4i
GLAD_API_CALL PFNGLVERTEX4IVPROC glad_glVertex4iv;
#define glVertex4iv glad_glVertex4iv
GLAD_API_CALL PFNGLVERTEX4SPROC glad_glVertex4s;
#define glVertex4s glad_glVertex4s
GLAD_API_CALL PFNGLVERTEX4SVPROC glad_glVertex4sv;
#define glVertex4sv glad_glVertex4sv
GLAD_API_CALL PFNGLVERTEXARRAYATTRIBBINDINGPROC glad_glVertexArrayAttribBinding;
#define glVertexArrayAttribBinding glad_glVertexArrayAttribBinding
GLAD_API_CALL PFNGLVERTEXARRAYATTRIBFORMATPROC glad_glVertexArrayAttribFormat;
#define glVertexArrayAttribFormat glad_glVertexArrayAttribFormat
GLAD_API_CALL PFNGLVERTEXARRAYATTRIBIFORMATPROC glad_glVertexArrayAttribIFormat;
#define glVertexArrayAttribIFormat glad_glVertexArrayAttribIFormat
GLAD_API_CALL PFNGLVERTEXARRAYATTRIBLFORMATPROC glad_glVertexArrayAttribLFormat;
#define glVertexArrayAttribLFormat glad_glVertexArrayAttribLFormat
GLAD_API_CALL PFNGLVERTEXARRAYBINDINGDIVISORPROC glad_glVertexArrayBindingDivisor;
#define glVertexArrayBindingDivisor glad_glVertexArrayBindingDivisor
GLAD_API_CALL PFNGLVERTEXARRAYELEMENTBUFFERPROC glad_glVertexArrayElementBuffer;
#define glVertexArrayElementBuffer glad_glVertexArrayElementBuffer
GLAD_API_CALL PFNGLVERTEXARRAYVERTEXBUFFERPROC glad_glVertexArrayVertexBuffer;
#define glVertexArrayVertexBuffer glad_glVertexArrayVertexBuffer
GLAD_API_CALL PFNGLVERTEXARRAYVERTEXBUFFERSPROC glad_glVertexArrayVertexBuffers;
#define glVertexArrayVertexBuffers glad_glVertexArrayVertexBuffers
GLAD_API_CALL PFNGLVERTEXATTRIB1DPROC glad_glVertexAttrib1d;
#define glVertexAttrib1d glad_glVertexAttrib1d
GLAD_API_CALL PFNGLVERTEXATTRIB1DVPROC glad_glVertexAttrib1dv;
#define glVertexAttrib1dv glad_glVertexAttrib1dv
GLAD_API_CALL PFNGLVERTEXATTRIB1FPROC glad_glVertexAttrib1f;
#define glVertexAttrib1f glad_glVertexAttrib1f
GLAD_API_CALL PFNGLVERTEXATTRIB1FVPROC glad_glVertexAttrib1fv;
#define glVertexAttrib1fv glad_glVertexAttrib1fv
GLAD_API_CALL PFNGLVERTEXATTRIB1SPROC glad_glVertexAttrib1s;
#define glVertexAttrib1s glad_glVertexAttrib1s
GLAD_API_CALL PFNGLVERTEXATTRIB1SVPROC glad_glVertexAttrib1sv;
#define glVertexAttrib1sv glad_glVertexAttrib1sv
GLAD_API_CALL PFNGLVERTEXATTRIB2DPROC glad_glVertexAttrib2d;
#define glVertexAttrib2d glad_glVertexAttrib2d
GLAD_API_CALL PFNGLVERTEXATTRIB2DVPROC glad_glVertexAttrib2dv;
#define glVertexAttrib2dv glad_glVertexAttrib2dv
GLAD_API_CALL PFNGLVERTEXATTRIB2FPROC glad_glVertexAttrib2f;
#define glVertexAttrib2f glad_glVertexAttrib2f
GLAD_API_CALL PFNGLVERTEXATTRIB2FVPROC glad_glVertexAttrib2fv;
#define glVertexAttrib2fv glad_glVertexAttrib2fv
GLAD_API_CALL PFNGLVERTEXATTRIB2SPROC glad_glVertexAttrib2s;
#define glVertexAttrib2s glad_glVertexAttrib2s
GLAD_API_CALL PFNGLVERTEXATTRIB2SVPROC glad_glVertexAttrib2sv;
#define glVertexAttrib2sv glad_glVertexAttrib2sv
GLAD_API_CALL PFNGLVERTEXATTRIB3DPROC glad_glVertexAttrib3d;
#define glVertexAttrib3d glad_glVertexAttrib3d
GLAD_API_CALL PFNGLVERTEXATTRIB3DVPROC glad_glVertexAttrib3dv;
#define glVertexAttrib3dv glad_glVertexAttrib3dv
GLAD_API_CALL PFNGLVERTEXATTRIB3FPROC glad_glVertexAttrib3f;
#define glVertexAttrib3f glad_glVertexAttrib3f
GLAD_API_CALL PFNGLVERTEXATTRIB3FVPROC glad_glVertexAttrib3fv;
#define glVertexAttrib3fv glad_glVertexAttrib3fv
GLAD_API_CALL PFNGLVERTEXATTRIB3SPROC glad_glVertexAttrib3s;
#define glVertexAttrib3s glad_glVertexAttrib3s
GLAD_API_CALL PFNGLVERTEXATTRIB3SVPROC glad_glVertexAttrib3sv;
#define glVertexAttrib3sv glad_glVertexAttrib3sv
GLAD_API_CALL PFNGLVERTEXATTRIB4NBVPROC glad_glVertexAttrib4Nbv;
#define glVertexAttrib4Nbv glad_glVertexAttrib4Nbv
GLAD_API_CALL PFNGLVERTEXATTRIB4NIVPROC glad_glVertexAttrib4Niv;
#define glVertexAttrib4Niv glad_glVertexAttrib4Niv
GLAD_API_CALL PFNGLVERTEXATTRIB4NSVPROC glad_glVertexAttrib4Nsv;
#define glVertexAttrib4Nsv glad_glVertexAttrib4Nsv
GLAD_API_CALL PFNGLVERTEXATTRIB4NUBPROC glad_glVertexAttrib4Nub;
#define glVertexAttrib4Nub glad_glVertexAttrib4Nub
GLAD_API_CALL PFNGLVERTEXATTRIB4NUBVPROC glad_glVertexAttrib4Nubv;
#define glVertexAttrib4Nubv glad_glVertexAttrib4Nubv
GLAD_API_CALL PFNGLVERTEXATTRIB4NUIVPROC glad_glVertexAttrib4Nuiv;
#define glVertexAttrib4Nuiv glad_glVertexAttrib4Nuiv
GLAD_API_CALL PFNGLVERTEXATTRIB4NUSVPROC glad_glVertexAttrib4Nusv;
#define glVertexAttrib4Nusv glad_glVertexAttrib4Nusv
GLAD_API_CALL PFNGLVERTEXATTRIB4BVPROC glad_glVertexAttrib4bv;
#define glVertexAttrib4bv glad_glVertexAttrib4bv
GLAD_API_CALL PFNGLVERTEXATTRIB4DPROC glad_glVertexAttrib4d;
#define glVertexAttrib4d glad_glVertexAttrib4d
GLAD_API_CALL PFNGLVERTEXATTRIB4DVPROC glad_glVertexAttrib4dv;
#define glVertexAttrib4dv glad_glVertexAttrib4dv
GLAD_API_CALL PFNGLVERTEXATTRIB4FPROC glad_glVertexAttrib4f;
#define glVertexAttrib4f glad_glVertexAttrib4f
GLAD_API_CALL PFNGLVERTEXATTRIB4FVPROC glad_glVertexAttrib4fv;
#define glVertexAttrib4fv glad_glVertexAttrib4fv
GLAD_API_CALL PFNGLVERTEXATTRIB4IVPROC glad_glVertexAttrib4iv;
#define glVertexAttrib4iv glad_glVertexAttrib4iv
GLAD_API_CALL PFNGLVERTEXATTRIB4SPROC glad_glVertexAttrib4s;
#define glVertexAttrib4s glad_glVertexAttrib4s
GLAD_API_CALL PFNGLVERTEXATTRIB4SVPROC glad_glVertexAttrib4sv;
#define glVertexAttrib4sv glad_glVertexAttrib4sv
GLAD_API_CALL PFNGLVERTEXATTRIB4UBVPROC glad_glVertexAttrib4ubv;
#define glVertexAttrib4ubv glad_glVertexAttrib4ubv
GLAD_API_CALL PFNGLVERTEXATTRIB4UIVPROC glad_glVertexAttrib4uiv;
#define glVertexAttrib4uiv glad_glVertexAttrib4uiv
GLAD_API_CALL PFNGLVERTEXATTRIB4USVPROC glad_glVertexAttrib4usv;
#define glVertexAttrib4usv glad_glVertexAttrib4usv
GLAD_API_CALL PFNGLVERTEXATTRIBBINDINGPROC glad_glVertexAttribBinding;
#define glVertexAttribBinding glad_glVertexAttribBinding
GLAD_API_CALL PFNGLVERTEXATTRIBDIVISORPROC glad_glVertexAttribDivisor;
#define glVertexAttribDivisor glad_glVertexAttribDivisor
GLAD_API_CALL PFNGLVERTEXATTRIBFORMATPROC glad_glVertexAttribFormat;
#define glVertexAttribFormat glad_glVertexAttribFormat
GLAD_API_CALL PFNGLVERTEXATTRIBI1IPROC glad_glVertexAttribI1i;
#define glVertexAttribI1i glad_glVertexAttribI1i
GLAD_API_CALL PFNGLVERTEXATTRIBI1IVPROC glad_glVertexAttribI1iv;
#define glVertexAttribI1iv glad_glVertexAttribI1iv
GLAD_API_CALL PFNGLVERTEXATTRIBI1UIPROC glad_glVertexAttribI1ui;
#define glVertexAttribI1ui glad_glVertexAttribI1ui
GLAD_API_CALL PFNGLVERTEXATTRIBI1UIVPROC glad_glVertexAttribI1uiv;
#define glVertexAttribI1uiv glad_glVertexAttribI1uiv
GLAD_API_CALL PFNGLVERTEXATTRIBI2IPROC glad_glVertexAttribI2i;
#define glVertexAttribI2i glad_glVertexAttribI2i
GLAD_API_CALL PFNGLVERTEXATTRIBI2IVPROC glad_glVertexAttribI2iv;
#define glVertexAttribI2iv glad_glVertexAttribI2iv
GLAD_API_CALL PFNGLVERTEXATTRIBI2UIPROC glad_glVertexAttribI2ui;
#define glVertexAttribI2ui glad_glVertexAttribI2ui
GLAD_API_CALL PFNGLVERTEXATTRIBI2UIVPROC glad_glVertexAttribI2uiv;
#define glVertexAttribI2uiv glad_glVertexAttribI2uiv
GLAD_API_CALL PFNGLVERTEXATTRIBI3IPROC glad_glVertexAttribI3i;
#define glVertexAttribI3i glad_glVertexAttribI3i
GLAD_API_CALL PFNGLVERTEXATTRIBI3IVPROC glad_glVertexAttribI3iv;
#define glVertexAttribI3iv glad_glVertexAttribI3iv
GLAD_API_CALL PFNGLVERTEXATTRIBI3UIPROC glad_glVertexAttribI3ui;
#define glVertexAttribI3ui glad_glVertexAttribI3ui
GLAD_API_CALL PFNGLVERTEXATTRIBI3UIVPROC glad_glVertexAttribI3uiv;
#define glVertexAttribI3uiv glad_glVertexAttribI3uiv
GLAD_API_CALL PFNGLVERTEXATTRIBI4BVPROC glad_glVertexAttribI4bv;
#define glVertexAttribI4bv glad_glVertexAttribI4bv
GLAD_API_CALL PFNGLVERTEXATTRIBI4IPROC glad_glVertexAttribI4i;
#define glVertexAttribI4i glad_glVertexAttribI4i
GLAD_API_CALL PFNGLVERTEXATTRIBI4IVPROC glad_glVertexAttribI4iv;
#define glVertexAttribI4iv glad_glVertexAttribI4iv
GLAD_API_CALL PFNGLVERTEXATTRIBI4SVPROC glad_glVertexAttribI4sv;
#define glVertexAttribI4sv glad_glVertexAttribI4sv
GLAD_API_CALL PFNGLVERTEXATTRIBI4UBVPROC glad_glVertexAttribI4ubv;
#define glVertexAttribI4ubv glad_glVertexAttribI4ubv
GLAD_API_CALL PFNGLVERTEXATTRIBI4UIPROC glad_glVertexAttribI4ui;
#define glVertexAttribI4ui glad_glVertexAttribI4ui
GLAD_API_CALL PFNGLVERTEXATTRIBI4UIVPROC glad_glVertexAttribI4uiv;
#define glVertexAttribI4uiv glad_glVertexAttribI4uiv
GLAD_API_CALL PFNGLVERTEXATTRIBI4USVPROC glad_glVertexAttribI4usv;
#define glVertexAttribI4usv glad_glVertexAttribI4usv
GLAD_API_CALL PFNGLVERTEXATTRIBIFORMATPROC glad_glVertexAttribIFormat;
#define glVertexAttribIFormat glad_glVertexAttribIFormat
GLAD_API_CALL PFNGLVERTEXATTRIBIPOINTERPROC glad_glVertexAttribIPointer;
#define glVertexAttribIPointer glad_glVertexAttribIPointer
GLAD_API_CALL PFNGLVERTEXATTRIBL1DPROC glad_glVertexAttribL1d;
#define glVertexAttribL1d glad_glVertexAttribL1d
GLAD_API_CALL PFNGLVERTEXATTRIBL1DVPROC glad_glVertexAttribL1dv;
#define glVertexAttribL1dv glad_glVertexAttribL1dv
GLAD_API_CALL PFNGLVERTEXATTRIBL2DPROC glad_glVertexAttribL2d;
#define glVertexAttribL2d glad_glVertexAttribL2d
GLAD_API_CALL PFNGLVERTEXATTRIBL2DVPROC glad_glVertexAttribL2dv;
#define glVertexAttribL2dv glad_glVertexAttribL2dv
GLAD_API_CALL PFNGLVERTEXATTRIBL3DPROC glad_glVertexAttribL3d;
#define glVertexAttribL3d glad_glVertexAttribL3d
GLAD_API_CALL PFNGLVERTEXATTRIBL3DVPROC glad_glVertexAttribL3dv;
#define glVertexAttribL3dv glad_glVertexAttribL3dv
GLAD_API_CALL PFNGLVERTEXATTRIBL4DPROC glad_glVertexAttribL4d;
#define glVertexAttribL4d glad_glVertexAttribL4d
GLAD_API_CALL PFNGLVERTEXATTRIBL4DVPROC glad_glVertexAttribL4dv;
#define glVertexAttribL4dv glad_glVertexAttribL4dv
GLAD_API_CALL PFNGLVERTEXATTRIBLFORMATPROC glad_glVertexAttribLFormat;
#define glVertexAttribLFormat glad_glVertexAttribLFormat
GLAD_API_CALL PFNGLVERTEXATTRIBLPOINTERPROC glad_glVertexAttribLPointer;
#define glVertexAttribLPointer glad_glVertexAttribLPointer
GLAD_API_CALL PFNGLVERTEXATTRIBP1UIPROC glad_glVertexAttribP1ui;
#define glVertexAttribP1ui glad_glVertexAttribP1ui
GLAD_API_CALL PFNGLVERTEXATTRIBP1UIVPROC glad_glVertexAttribP1uiv;
#define glVertexAttribP1uiv glad_glVertexAttribP1uiv
GLAD_API_CALL PFNGLVERTEXATTRIBP2UIPROC glad_glVertexAttribP2ui;
#define glVertexAttribP2ui glad_glVertexAttribP2ui
GLAD_API_CALL PFNGLVERTEXATTRIBP2UIVPROC glad_glVertexAttribP2uiv;
#define glVertexAttribP2uiv glad_glVertexAttribP2uiv
GLAD_API_CALL PFNGLVERTEXATTRIBP3UIPROC glad_glVertexAttribP3ui;
#define glVertexAttribP3ui glad_glVertexAttribP3ui
GLAD_API_CALL PFNGLVERTEXATTRIBP3UIVPROC glad_glVertexAttribP3uiv;
#define glVertexAttribP3uiv glad_glVertexAttribP3uiv
GLAD_API_CALL PFNGLVERTEXATTRIBP4UIPROC glad_glVertexAttribP4ui;
#define glVertexAttribP4ui glad_glVertexAttribP4ui
GLAD_API_CALL PFNGLVERTEXATTRIBP4UIVPROC glad_glVertexAttribP4uiv;
#define glVertexAttribP4uiv glad_glVertexAttribP4uiv
GLAD_API_CALL PFNGLVERTEXATTRIBPOINTERPROC glad_glVertexAttribPointer;
#define glVertexAttribPointer glad_glVertexAttribPointer
GLAD_API_CALL PFNGLVERTEXBINDINGDIVISORPROC glad_glVertexBindingDivisor;
#define glVertexBindingDivisor glad_glVertexBindingDivisor
GLAD_API_CALL PFNGLVERTEXP2UIPROC glad_glVertexP2ui;
#define glVertexP2ui glad_glVertexP2ui
GLAD_API_CALL PFNGLVERTEXP2UIVPROC glad_glVertexP2uiv;
#define glVertexP2uiv glad_glVertexP2uiv
GLAD_API_CALL PFNGLVERTEXP3UIPROC glad_glVertexP3ui;
#define glVertexP3ui glad_glVertexP3ui
GLAD_API_CALL PFNGLVERTEXP3UIVPROC glad_glVertexP3uiv;
#define glVertexP3uiv glad_glVertexP3uiv
GLAD_API_CALL PFNGLVERTEXP4UIPROC glad_glVertexP4ui;
#define glVertexP4ui glad_glVertexP4ui
GLAD_API_CALL PFNGLVERTEXP4UIVPROC glad_glVertexP4uiv;
#define glVertexP4uiv glad_glVertexP4uiv
GLAD_API_CALL PFNGLVERTEXPOINTERPROC glad_glVertexPointer;
#define glVertexPointer glad_glVertexPointer
GLAD_API_CALL PFNGLVIEWPORTPROC glad_glViewport;
#define glViewport glad_glViewport
GLAD_API_CALL PFNGLVIEWPORTARRAYVPROC glad_glViewportArrayv;
#define glViewportArrayv glad_glViewportArrayv
GLAD_API_CALL PFNGLVIEWPORTINDEXEDFPROC glad_glViewportIndexedf;
#define glViewportIndexedf glad_glViewportIndexedf
GLAD_API_CALL PFNGLVIEWPORTINDEXEDFVPROC glad_glViewportIndexedfv;
#define glViewportIndexedfv glad_glViewportIndexedfv
GLAD_API_CALL PFNGLWAITSYNCPROC glad_glWaitSync;
#define glWaitSync glad_glWaitSync
GLAD_API_CALL PFNGLWINDOWPOS2DPROC glad_glWindowPos2d;
#define glWindowPos2d glad_glWindowPos2d
GLAD_API_CALL PFNGLWINDOWPOS2DVPROC glad_glWindowPos2dv;
#define glWindowPos2dv glad_glWindowPos2dv
GLAD_API_CALL PFNGLWINDOWPOS2FPROC glad_glWindowPos2f;
#define glWindowPos2f glad_glWindowPos2f
GLAD_API_CALL PFNGLWINDOWPOS2FVPROC glad_glWindowPos2fv;
#define glWindowPos2fv glad_glWindowPos2fv
GLAD_API_CALL PFNGLWINDOWPOS2IPROC glad_glWindowPos2i;
#define glWindowPos2i glad_glWindowPos2i
GLAD_API_CALL PFNGLWINDOWPOS2IVPROC glad_glWindowPos2iv;
#define glWindowPos2iv glad_glWindowPos2iv
GLAD_API_CALL PFNGLWINDOWPOS2SPROC glad_glWindowPos2s;
#define glWindowPos2s glad_glWindowPos2s
GLAD_API_CALL PFNGLWINDOWPOS2SVPROC glad_glWindowPos2sv;
#define glWindowPos2sv glad_glWindowPos2sv
GLAD_API_CALL PFNGLWINDOWPOS3DPROC glad_glWindowPos3d;
#define glWindowPos3d glad_glWindowPos3d
GLAD_API_CALL PFNGLWINDOWPOS3DVPROC glad_glWindowPos3dv;
#define glWindowPos3dv glad_glWindowPos3dv
GLAD_API_CALL PFNGLWINDOWPOS3FPROC glad_glWindowPos3f;
#define glWindowPos3f glad_glWindowPos3f
GLAD_API_CALL PFNGLWINDOWPOS3FVPROC glad_glWindowPos3fv;
#define glWindowPos3fv glad_glWindowPos3fv
GLAD_API_CALL PFNGLWINDOWPOS3IPROC glad_glWindowPos3i;
#define glWindowPos3i glad_glWindowPos3i
GLAD_API_CALL PFNGLWINDOWPOS3IVPROC glad_glWindowPos3iv;
#define glWindowPos3iv glad_glWindowPos3iv
GLAD_API_CALL PFNGLWINDOWPOS3SPROC glad_glWindowPos3s;
#define glWindowPos3s glad_glWindowPos3s
GLAD_API_CALL PFNGLWINDOWPOS3SVPROC glad_glWindowPos3sv;
#define glWindowPos3sv glad_glWindowPos3sv
GLAD_API_CALL int gladLoadGLUserPtr( GLADuserptrloadfunc load, void *userptr);
GLAD_API_CALL int gladLoadGL( GLADloadfunc load);
#ifdef __cplusplus
}
#endif
#endif
/* Source */
#ifdef GLAD_GL_IMPLEMENTATION
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#ifndef GLAD_IMPL_UTIL_C_
#define GLAD_IMPL_UTIL_C_
#ifdef _MSC_VER
#define GLAD_IMPL_UTIL_SSCANF sscanf_s
#else
#define GLAD_IMPL_UTIL_SSCANF sscanf
#endif
#endif /* GLAD_IMPL_UTIL_C_ */
#ifdef __cplusplus
extern "C" {
#endif
int GLAD_GL_VERSION_1_0 = 0;
int GLAD_GL_VERSION_1_1 = 0;
int GLAD_GL_VERSION_1_2 = 0;
int GLAD_GL_VERSION_1_3 = 0;
int GLAD_GL_VERSION_1_4 = 0;
int GLAD_GL_VERSION_1_5 = 0;
int GLAD_GL_VERSION_2_0 = 0;
int GLAD_GL_VERSION_2_1 = 0;
int GLAD_GL_VERSION_3_0 = 0;
int GLAD_GL_VERSION_3_1 = 0;
int GLAD_GL_VERSION_3_2 = 0;
int GLAD_GL_VERSION_3_3 = 0;
int GLAD_GL_VERSION_4_0 = 0;
int GLAD_GL_VERSION_4_1 = 0;
int GLAD_GL_VERSION_4_2 = 0;
int GLAD_GL_VERSION_4_3 = 0;
int GLAD_GL_VERSION_4_4 = 0;
int GLAD_GL_VERSION_4_5 = 0;
int GLAD_GL_VERSION_4_6 = 0;
int GLAD_GL_ARB_multisample = 0;
int GLAD_GL_ARB_robustness = 0;
int GLAD_GL_KHR_debug = 0;
PFNGLACCUMPROC glad_glAccum = NULL;
PFNGLACTIVESHADERPROGRAMPROC glad_glActiveShaderProgram = NULL;
PFNGLACTIVETEXTUREPROC glad_glActiveTexture = NULL;
PFNGLALPHAFUNCPROC glad_glAlphaFunc = NULL;
PFNGLARETEXTURESRESIDENTPROC glad_glAreTexturesResident = NULL;
PFNGLARRAYELEMENTPROC glad_glArrayElement = NULL;
PFNGLATTACHSHADERPROC glad_glAttachShader = NULL;
PFNGLBEGINPROC glad_glBegin = NULL;
PFNGLBEGINCONDITIONALRENDERPROC glad_glBeginConditionalRender = NULL;
PFNGLBEGINQUERYPROC glad_glBeginQuery = NULL;
PFNGLBEGINQUERYINDEXEDPROC glad_glBeginQueryIndexed = NULL;
PFNGLBEGINTRANSFORMFEEDBACKPROC glad_glBeginTransformFeedback = NULL;
PFNGLBINDATTRIBLOCATIONPROC glad_glBindAttribLocation = NULL;
PFNGLBINDBUFFERPROC glad_glBindBuffer = NULL;
PFNGLBINDBUFFERBASEPROC glad_glBindBufferBase = NULL;
PFNGLBINDBUFFERRANGEPROC glad_glBindBufferRange = NULL;
PFNGLBINDBUFFERSBASEPROC glad_glBindBuffersBase = NULL;
PFNGLBINDBUFFERSRANGEPROC glad_glBindBuffersRange = NULL;
PFNGLBINDFRAGDATALOCATIONPROC glad_glBindFragDataLocation = NULL;
PFNGLBINDFRAGDATALOCATIONINDEXEDPROC glad_glBindFragDataLocationIndexed = NULL;
PFNGLBINDFRAMEBUFFERPROC glad_glBindFramebuffer = NULL;
PFNGLBINDIMAGETEXTUREPROC glad_glBindImageTexture = NULL;
PFNGLBINDIMAGETEXTURESPROC glad_glBindImageTextures = NULL;
PFNGLBINDPROGRAMPIPELINEPROC glad_glBindProgramPipeline = NULL;
PFNGLBINDRENDERBUFFERPROC glad_glBindRenderbuffer = NULL;
PFNGLBINDSAMPLERPROC glad_glBindSampler = NULL;
PFNGLBINDSAMPLERSPROC glad_glBindSamplers = NULL;
PFNGLBINDTEXTUREPROC glad_glBindTexture = NULL;
PFNGLBINDTEXTUREUNITPROC glad_glBindTextureUnit = NULL;
PFNGLBINDTEXTURESPROC glad_glBindTextures = NULL;
PFNGLBINDTRANSFORMFEEDBACKPROC glad_glBindTransformFeedback = NULL;
PFNGLBINDVERTEXARRAYPROC glad_glBindVertexArray = NULL;
PFNGLBINDVERTEXBUFFERPROC glad_glBindVertexBuffer = NULL;
PFNGLBINDVERTEXBUFFERSPROC glad_glBindVertexBuffers = NULL;
PFNGLBITMAPPROC glad_glBitmap = NULL;
PFNGLBLENDCOLORPROC glad_glBlendColor = NULL;
PFNGLBLENDEQUATIONPROC glad_glBlendEquation = NULL;
PFNGLBLENDEQUATIONSEPARATEPROC glad_glBlendEquationSeparate = NULL;
PFNGLBLENDEQUATIONSEPARATEIPROC glad_glBlendEquationSeparatei = NULL;
PFNGLBLENDEQUATIONIPROC glad_glBlendEquationi = NULL;
PFNGLBLENDFUNCPROC glad_glBlendFunc = NULL;
PFNGLBLENDFUNCSEPARATEPROC glad_glBlendFuncSeparate = NULL;
PFNGLBLENDFUNCSEPARATEIPROC glad_glBlendFuncSeparatei = NULL;
PFNGLBLENDFUNCIPROC glad_glBlendFunci = NULL;
PFNGLBLITFRAMEBUFFERPROC glad_glBlitFramebuffer = NULL;
PFNGLBLITNAMEDFRAMEBUFFERPROC glad_glBlitNamedFramebuffer = NULL;
PFNGLBUFFERDATAPROC glad_glBufferData = NULL;
PFNGLBUFFERSTORAGEPROC glad_glBufferStorage = NULL;
PFNGLBUFFERSUBDATAPROC glad_glBufferSubData = NULL;
PFNGLCALLLISTPROC glad_glCallList = NULL;
PFNGLCALLLISTSPROC glad_glCallLists = NULL;
PFNGLCHECKFRAMEBUFFERSTATUSPROC glad_glCheckFramebufferStatus = NULL;
PFNGLCHECKNAMEDFRAMEBUFFERSTATUSPROC glad_glCheckNamedFramebufferStatus = NULL;
PFNGLCLAMPCOLORPROC glad_glClampColor = NULL;
PFNGLCLEARPROC glad_glClear = NULL;
PFNGLCLEARACCUMPROC glad_glClearAccum = NULL;
PFNGLCLEARBUFFERDATAPROC glad_glClearBufferData = NULL;
PFNGLCLEARBUFFERSUBDATAPROC glad_glClearBufferSubData = NULL;
PFNGLCLEARBUFFERFIPROC glad_glClearBufferfi = NULL;
PFNGLCLEARBUFFERFVPROC glad_glClearBufferfv = NULL;
PFNGLCLEARBUFFERIVPROC glad_glClearBufferiv = NULL;
PFNGLCLEARBUFFERUIVPROC glad_glClearBufferuiv = NULL;
PFNGLCLEARCOLORPROC glad_glClearColor = NULL;
PFNGLCLEARDEPTHPROC glad_glClearDepth = NULL;
PFNGLCLEARDEPTHFPROC glad_glClearDepthf = NULL;
PFNGLCLEARINDEXPROC glad_glClearIndex = NULL;
PFNGLCLEARNAMEDBUFFERDATAPROC glad_glClearNamedBufferData = NULL;
PFNGLCLEARNAMEDBUFFERSUBDATAPROC glad_glClearNamedBufferSubData = NULL;
PFNGLCLEARNAMEDFRAMEBUFFERFIPROC glad_glClearNamedFramebufferfi = NULL;
PFNGLCLEARNAMEDFRAMEBUFFERFVPROC glad_glClearNamedFramebufferfv = NULL;
PFNGLCLEARNAMEDFRAMEBUFFERIVPROC glad_glClearNamedFramebufferiv = NULL;
PFNGLCLEARNAMEDFRAMEBUFFERUIVPROC glad_glClearNamedFramebufferuiv = NULL;
PFNGLCLEARSTENCILPROC glad_glClearStencil = NULL;
PFNGLCLEARTEXIMAGEPROC glad_glClearTexImage = NULL;
PFNGLCLEARTEXSUBIMAGEPROC glad_glClearTexSubImage = NULL;
PFNGLCLIENTACTIVETEXTUREPROC glad_glClientActiveTexture = NULL;
PFNGLCLIENTWAITSYNCPROC glad_glClientWaitSync = NULL;
PFNGLCLIPCONTROLPROC glad_glClipControl = NULL;
PFNGLCLIPPLANEPROC glad_glClipPlane = NULL;
PFNGLCOLOR3BPROC glad_glColor3b = NULL;
PFNGLCOLOR3BVPROC glad_glColor3bv = NULL;
PFNGLCOLOR3DPROC glad_glColor3d = NULL;
PFNGLCOLOR3DVPROC glad_glColor3dv = NULL;
PFNGLCOLOR3FPROC glad_glColor3f = NULL;
PFNGLCOLOR3FVPROC glad_glColor3fv = NULL;
PFNGLCOLOR3IPROC glad_glColor3i = NULL;
PFNGLCOLOR3IVPROC glad_glColor3iv = NULL;
PFNGLCOLOR3SPROC glad_glColor3s = NULL;
PFNGLCOLOR3SVPROC glad_glColor3sv = NULL;
PFNGLCOLOR3UBPROC glad_glColor3ub = NULL;
PFNGLCOLOR3UBVPROC glad_glColor3ubv = NULL;
PFNGLCOLOR3UIPROC glad_glColor3ui = NULL;
PFNGLCOLOR3UIVPROC glad_glColor3uiv = NULL;
PFNGLCOLOR3USPROC glad_glColor3us = NULL;
PFNGLCOLOR3USVPROC glad_glColor3usv = NULL;
PFNGLCOLOR4BPROC glad_glColor4b = NULL;
PFNGLCOLOR4BVPROC glad_glColor4bv = NULL;
PFNGLCOLOR4DPROC glad_glColor4d = NULL;
PFNGLCOLOR4DVPROC glad_glColor4dv = NULL;
PFNGLCOLOR4FPROC glad_glColor4f = NULL;
PFNGLCOLOR4FVPROC glad_glColor4fv = NULL;
PFNGLCOLOR4IPROC glad_glColor4i = NULL;
PFNGLCOLOR4IVPROC glad_glColor4iv = NULL;
PFNGLCOLOR4SPROC glad_glColor4s = NULL;
PFNGLCOLOR4SVPROC glad_glColor4sv = NULL;
PFNGLCOLOR4UBPROC glad_glColor4ub = NULL;
PFNGLCOLOR4UBVPROC glad_glColor4ubv = NULL;
PFNGLCOLOR4UIPROC glad_glColor4ui = NULL;
PFNGLCOLOR4UIVPROC glad_glColor4uiv = NULL;
PFNGLCOLOR4USPROC glad_glColor4us = NULL;
PFNGLCOLOR4USVPROC glad_glColor4usv = NULL;
PFNGLCOLORMASKPROC glad_glColorMask = NULL;
PFNGLCOLORMASKIPROC glad_glColorMaski = NULL;
PFNGLCOLORMATERIALPROC glad_glColorMaterial = NULL;
PFNGLCOLORP3UIPROC glad_glColorP3ui = NULL;
PFNGLCOLORP3UIVPROC glad_glColorP3uiv = NULL;
PFNGLCOLORP4UIPROC glad_glColorP4ui = NULL;
PFNGLCOLORP4UIVPROC glad_glColorP4uiv = NULL;
PFNGLCOLORPOINTERPROC glad_glColorPointer = NULL;
PFNGLCOMPILESHADERPROC glad_glCompileShader = NULL;
PFNGLCOMPRESSEDTEXIMAGE1DPROC glad_glCompressedTexImage1D = NULL;
PFNGLCOMPRESSEDTEXIMAGE2DPROC glad_glCompressedTexImage2D = NULL;
PFNGLCOMPRESSEDTEXIMAGE3DPROC glad_glCompressedTexImage3D = NULL;
PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC glad_glCompressedTexSubImage1D = NULL;
PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC glad_glCompressedTexSubImage2D = NULL;
PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC glad_glCompressedTexSubImage3D = NULL;
PFNGLCOMPRESSEDTEXTURESUBIMAGE1DPROC glad_glCompressedTextureSubImage1D = NULL;
PFNGLCOMPRESSEDTEXTURESUBIMAGE2DPROC glad_glCompressedTextureSubImage2D = NULL;
PFNGLCOMPRESSEDTEXTURESUBIMAGE3DPROC glad_glCompressedTextureSubImage3D = NULL;
PFNGLCOPYBUFFERSUBDATAPROC glad_glCopyBufferSubData = NULL;
PFNGLCOPYIMAGESUBDATAPROC glad_glCopyImageSubData = NULL;
PFNGLCOPYNAMEDBUFFERSUBDATAPROC glad_glCopyNamedBufferSubData = NULL;
PFNGLCOPYPIXELSPROC glad_glCopyPixels = NULL;
PFNGLCOPYTEXIMAGE1DPROC glad_glCopyTexImage1D = NULL;
PFNGLCOPYTEXIMAGE2DPROC glad_glCopyTexImage2D = NULL;
PFNGLCOPYTEXSUBIMAGE1DPROC glad_glCopyTexSubImage1D = NULL;
PFNGLCOPYTEXSUBIMAGE2DPROC glad_glCopyTexSubImage2D = NULL;
PFNGLCOPYTEXSUBIMAGE3DPROC glad_glCopyTexSubImage3D = NULL;
PFNGLCOPYTEXTURESUBIMAGE1DPROC glad_glCopyTextureSubImage1D = NULL;
PFNGLCOPYTEXTURESUBIMAGE2DPROC glad_glCopyTextureSubImage2D = NULL;
PFNGLCOPYTEXTURESUBIMAGE3DPROC glad_glCopyTextureSubImage3D = NULL;
PFNGLCREATEBUFFERSPROC glad_glCreateBuffers = NULL;
PFNGLCREATEFRAMEBUFFERSPROC glad_glCreateFramebuffers = NULL;
PFNGLCREATEPROGRAMPROC glad_glCreateProgram = NULL;
PFNGLCREATEPROGRAMPIPELINESPROC glad_glCreateProgramPipelines = NULL;
PFNGLCREATEQUERIESPROC glad_glCreateQueries = NULL;
PFNGLCREATERENDERBUFFERSPROC glad_glCreateRenderbuffers = NULL;
PFNGLCREATESAMPLERSPROC glad_glCreateSamplers = NULL;
PFNGLCREATESHADERPROC glad_glCreateShader = NULL;
PFNGLCREATESHADERPROGRAMVPROC glad_glCreateShaderProgramv = NULL;
PFNGLCREATETEXTURESPROC glad_glCreateTextures = NULL;
PFNGLCREATETRANSFORMFEEDBACKSPROC glad_glCreateTransformFeedbacks = NULL;
PFNGLCREATEVERTEXARRAYSPROC glad_glCreateVertexArrays = NULL;
PFNGLCULLFACEPROC glad_glCullFace = NULL;
PFNGLDEBUGMESSAGECALLBACKPROC glad_glDebugMessageCallback = NULL;
PFNGLDEBUGMESSAGECONTROLPROC glad_glDebugMessageControl = NULL;
PFNGLDEBUGMESSAGEINSERTPROC glad_glDebugMessageInsert = NULL;
PFNGLDELETEBUFFERSPROC glad_glDeleteBuffers = NULL;
PFNGLDELETEFRAMEBUFFERSPROC glad_glDeleteFramebuffers = NULL;
PFNGLDELETELISTSPROC glad_glDeleteLists = NULL;
PFNGLDELETEPROGRAMPROC glad_glDeleteProgram = NULL;
PFNGLDELETEPROGRAMPIPELINESPROC glad_glDeleteProgramPipelines = NULL;
PFNGLDELETEQUERIESPROC glad_glDeleteQueries = NULL;
PFNGLDELETERENDERBUFFERSPROC glad_glDeleteRenderbuffers = NULL;
PFNGLDELETESAMPLERSPROC glad_glDeleteSamplers = NULL;
PFNGLDELETESHADERPROC glad_glDeleteShader = NULL;
PFNGLDELETESYNCPROC glad_glDeleteSync = NULL;
PFNGLDELETETEXTURESPROC glad_glDeleteTextures = NULL;
PFNGLDELETETRANSFORMFEEDBACKSPROC glad_glDeleteTransformFeedbacks = NULL;
PFNGLDELETEVERTEXARRAYSPROC glad_glDeleteVertexArrays = NULL;
PFNGLDEPTHFUNCPROC glad_glDepthFunc = NULL;
PFNGLDEPTHMASKPROC glad_glDepthMask = NULL;
PFNGLDEPTHRANGEPROC glad_glDepthRange = NULL;
PFNGLDEPTHRANGEARRAYVPROC glad_glDepthRangeArrayv = NULL;
PFNGLDEPTHRANGEINDEXEDPROC glad_glDepthRangeIndexed = NULL;
PFNGLDEPTHRANGEFPROC glad_glDepthRangef = NULL;
PFNGLDETACHSHADERPROC glad_glDetachShader = NULL;
PFNGLDISABLEPROC glad_glDisable = NULL;
PFNGLDISABLECLIENTSTATEPROC glad_glDisableClientState = NULL;
PFNGLDISABLEVERTEXARRAYATTRIBPROC glad_glDisableVertexArrayAttrib = NULL;
PFNGLDISABLEVERTEXATTRIBARRAYPROC glad_glDisableVertexAttribArray = NULL;
PFNGLDISABLEIPROC glad_glDisablei = NULL;
PFNGLDISPATCHCOMPUTEPROC glad_glDispatchCompute = NULL;
PFNGLDISPATCHCOMPUTEINDIRECTPROC glad_glDispatchComputeIndirect = NULL;
PFNGLDRAWARRAYSPROC glad_glDrawArrays = NULL;
PFNGLDRAWARRAYSINDIRECTPROC glad_glDrawArraysIndirect = NULL;
PFNGLDRAWARRAYSINSTANCEDPROC glad_glDrawArraysInstanced = NULL;
PFNGLDRAWARRAYSINSTANCEDBASEINSTANCEPROC glad_glDrawArraysInstancedBaseInstance = NULL;
PFNGLDRAWBUFFERPROC glad_glDrawBuffer = NULL;
PFNGLDRAWBUFFERSPROC glad_glDrawBuffers = NULL;
PFNGLDRAWELEMENTSPROC glad_glDrawElements = NULL;
PFNGLDRAWELEMENTSBASEVERTEXPROC glad_glDrawElementsBaseVertex = NULL;
PFNGLDRAWELEMENTSINDIRECTPROC glad_glDrawElementsIndirect = NULL;
PFNGLDRAWELEMENTSINSTANCEDPROC glad_glDrawElementsInstanced = NULL;
PFNGLDRAWELEMENTSINSTANCEDBASEINSTANCEPROC glad_glDrawElementsInstancedBaseInstance = NULL;
PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC glad_glDrawElementsInstancedBaseVertex = NULL;
PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCEPROC glad_glDrawElementsInstancedBaseVertexBaseInstance = NULL;
PFNGLDRAWPIXELSPROC glad_glDrawPixels = NULL;
PFNGLDRAWRANGEELEMENTSPROC glad_glDrawRangeElements = NULL;
PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC glad_glDrawRangeElementsBaseVertex = NULL;
PFNGLDRAWTRANSFORMFEEDBACKPROC glad_glDrawTransformFeedback = NULL;
PFNGLDRAWTRANSFORMFEEDBACKINSTANCEDPROC glad_glDrawTransformFeedbackInstanced = NULL;
PFNGLDRAWTRANSFORMFEEDBACKSTREAMPROC glad_glDrawTransformFeedbackStream = NULL;
PFNGLDRAWTRANSFORMFEEDBACKSTREAMINSTANCEDPROC glad_glDrawTransformFeedbackStreamInstanced = NULL;
PFNGLEDGEFLAGPROC glad_glEdgeFlag = NULL;
PFNGLEDGEFLAGPOINTERPROC glad_glEdgeFlagPointer = NULL;
PFNGLEDGEFLAGVPROC glad_glEdgeFlagv = NULL;
PFNGLENABLEPROC glad_glEnable = NULL;
PFNGLENABLECLIENTSTATEPROC glad_glEnableClientState = NULL;
PFNGLENABLEVERTEXARRAYATTRIBPROC glad_glEnableVertexArrayAttrib = NULL;
PFNGLENABLEVERTEXATTRIBARRAYPROC glad_glEnableVertexAttribArray = NULL;
PFNGLENABLEIPROC glad_glEnablei = NULL;
PFNGLENDPROC glad_glEnd = NULL;
PFNGLENDCONDITIONALRENDERPROC glad_glEndConditionalRender = NULL;
PFNGLENDLISTPROC glad_glEndList = NULL;
PFNGLENDQUERYPROC glad_glEndQuery = NULL;
PFNGLENDQUERYINDEXEDPROC glad_glEndQueryIndexed = NULL;
PFNGLENDTRANSFORMFEEDBACKPROC glad_glEndTransformFeedback = NULL;
PFNGLEVALCOORD1DPROC glad_glEvalCoord1d = NULL;
PFNGLEVALCOORD1DVPROC glad_glEvalCoord1dv = NULL;
PFNGLEVALCOORD1FPROC glad_glEvalCoord1f = NULL;
PFNGLEVALCOORD1FVPROC glad_glEvalCoord1fv = NULL;
PFNGLEVALCOORD2DPROC glad_glEvalCoord2d = NULL;
PFNGLEVALCOORD2DVPROC glad_glEvalCoord2dv = NULL;
PFNGLEVALCOORD2FPROC glad_glEvalCoord2f = NULL;
PFNGLEVALCOORD2FVPROC glad_glEvalCoord2fv = NULL;
PFNGLEVALMESH1PROC glad_glEvalMesh1 = NULL;
PFNGLEVALMESH2PROC glad_glEvalMesh2 = NULL;
PFNGLEVALPOINT1PROC glad_glEvalPoint1 = NULL;
PFNGLEVALPOINT2PROC glad_glEvalPoint2 = NULL;
PFNGLFEEDBACKBUFFERPROC glad_glFeedbackBuffer = NULL;
PFNGLFENCESYNCPROC glad_glFenceSync = NULL;
PFNGLFINISHPROC glad_glFinish = NULL;
PFNGLFLUSHPROC glad_glFlush = NULL;
PFNGLFLUSHMAPPEDBUFFERRANGEPROC glad_glFlushMappedBufferRange = NULL;
PFNGLFLUSHMAPPEDNAMEDBUFFERRANGEPROC glad_glFlushMappedNamedBufferRange = NULL;
PFNGLFOGCOORDPOINTERPROC glad_glFogCoordPointer = NULL;
PFNGLFOGCOORDDPROC glad_glFogCoordd = NULL;
PFNGLFOGCOORDDVPROC glad_glFogCoorddv = NULL;
PFNGLFOGCOORDFPROC glad_glFogCoordf = NULL;
PFNGLFOGCOORDFVPROC glad_glFogCoordfv = NULL;
PFNGLFOGFPROC glad_glFogf = NULL;
PFNGLFOGFVPROC glad_glFogfv = NULL;
PFNGLFOGIPROC glad_glFogi = NULL;
PFNGLFOGIVPROC glad_glFogiv = NULL;
PFNGLFRAMEBUFFERPARAMETERIPROC glad_glFramebufferParameteri = NULL;
PFNGLFRAMEBUFFERRENDERBUFFERPROC glad_glFramebufferRenderbuffer = NULL;
PFNGLFRAMEBUFFERTEXTUREPROC glad_glFramebufferTexture = NULL;
PFNGLFRAMEBUFFERTEXTURE1DPROC glad_glFramebufferTexture1D = NULL;
PFNGLFRAMEBUFFERTEXTURE2DPROC glad_glFramebufferTexture2D = NULL;
PFNGLFRAMEBUFFERTEXTURE3DPROC glad_glFramebufferTexture3D = NULL;
PFNGLFRAMEBUFFERTEXTURELAYERPROC glad_glFramebufferTextureLayer = NULL;
PFNGLFRONTFACEPROC glad_glFrontFace = NULL;
PFNGLFRUSTUMPROC glad_glFrustum = NULL;
PFNGLGENBUFFERSPROC glad_glGenBuffers = NULL;
PFNGLGENFRAMEBUFFERSPROC glad_glGenFramebuffers = NULL;
PFNGLGENLISTSPROC glad_glGenLists = NULL;
PFNGLGENPROGRAMPIPELINESPROC glad_glGenProgramPipelines = NULL;
PFNGLGENQUERIESPROC glad_glGenQueries = NULL;
PFNGLGENRENDERBUFFERSPROC glad_glGenRenderbuffers = NULL;
PFNGLGENSAMPLERSPROC glad_glGenSamplers = NULL;
PFNGLGENTEXTURESPROC glad_glGenTextures = NULL;
PFNGLGENTRANSFORMFEEDBACKSPROC glad_glGenTransformFeedbacks = NULL;
PFNGLGENVERTEXARRAYSPROC glad_glGenVertexArrays = NULL;
PFNGLGENERATEMIPMAPPROC glad_glGenerateMipmap = NULL;
PFNGLGENERATETEXTUREMIPMAPPROC glad_glGenerateTextureMipmap = NULL;
PFNGLGETACTIVEATOMICCOUNTERBUFFERIVPROC glad_glGetActiveAtomicCounterBufferiv = NULL;
PFNGLGETACTIVEATTRIBPROC glad_glGetActiveAttrib = NULL;
PFNGLGETACTIVESUBROUTINENAMEPROC glad_glGetActiveSubroutineName = NULL;
PFNGLGETACTIVESUBROUTINEUNIFORMNAMEPROC glad_glGetActiveSubroutineUniformName = NULL;
PFNGLGETACTIVESUBROUTINEUNIFORMIVPROC glad_glGetActiveSubroutineUniformiv = NULL;
PFNGLGETACTIVEUNIFORMPROC glad_glGetActiveUniform = NULL;
PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC glad_glGetActiveUniformBlockName = NULL;
PFNGLGETACTIVEUNIFORMBLOCKIVPROC glad_glGetActiveUniformBlockiv = NULL;
PFNGLGETACTIVEUNIFORMNAMEPROC glad_glGetActiveUniformName = NULL;
PFNGLGETACTIVEUNIFORMSIVPROC glad_glGetActiveUniformsiv = NULL;
PFNGLGETATTACHEDSHADERSPROC glad_glGetAttachedShaders = NULL;
PFNGLGETATTRIBLOCATIONPROC glad_glGetAttribLocation = NULL;
PFNGLGETBOOLEANI_VPROC glad_glGetBooleani_v = NULL;
PFNGLGETBOOLEANVPROC glad_glGetBooleanv = NULL;
PFNGLGETBUFFERPARAMETERI64VPROC glad_glGetBufferParameteri64v = NULL;
PFNGLGETBUFFERPARAMETERIVPROC glad_glGetBufferParameteriv = NULL;
PFNGLGETBUFFERPOINTERVPROC glad_glGetBufferPointerv = NULL;
PFNGLGETBUFFERSUBDATAPROC glad_glGetBufferSubData = NULL;
PFNGLGETCLIPPLANEPROC glad_glGetClipPlane = NULL;
PFNGLGETCOMPRESSEDTEXIMAGEPROC glad_glGetCompressedTexImage = NULL;
PFNGLGETCOMPRESSEDTEXTUREIMAGEPROC glad_glGetCompressedTextureImage = NULL;
PFNGLGETCOMPRESSEDTEXTURESUBIMAGEPROC glad_glGetCompressedTextureSubImage = NULL;
PFNGLGETDEBUGMESSAGELOGPROC glad_glGetDebugMessageLog = NULL;
PFNGLGETDOUBLEI_VPROC glad_glGetDoublei_v = NULL;
PFNGLGETDOUBLEVPROC glad_glGetDoublev = NULL;
PFNGLGETERRORPROC glad_glGetError = NULL;
PFNGLGETFLOATI_VPROC glad_glGetFloati_v = NULL;
PFNGLGETFLOATVPROC glad_glGetFloatv = NULL;
PFNGLGETFRAGDATAINDEXPROC glad_glGetFragDataIndex = NULL;
PFNGLGETFRAGDATALOCATIONPROC glad_glGetFragDataLocation = NULL;
PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC glad_glGetFramebufferAttachmentParameteriv = NULL;
PFNGLGETFRAMEBUFFERPARAMETERIVPROC glad_glGetFramebufferParameteriv = NULL;
PFNGLGETGRAPHICSRESETSTATUSPROC glad_glGetGraphicsResetStatus = NULL;
PFNGLGETGRAPHICSRESETSTATUSARBPROC glad_glGetGraphicsResetStatusARB = NULL;
PFNGLGETINTEGER64I_VPROC glad_glGetInteger64i_v = NULL;
PFNGLGETINTEGER64VPROC glad_glGetInteger64v = NULL;
PFNGLGETINTEGERI_VPROC glad_glGetIntegeri_v = NULL;
PFNGLGETINTEGERVPROC glad_glGetIntegerv = NULL;
PFNGLGETINTERNALFORMATI64VPROC glad_glGetInternalformati64v = NULL;
PFNGLGETINTERNALFORMATIVPROC glad_glGetInternalformativ = NULL;
PFNGLGETLIGHTFVPROC glad_glGetLightfv = NULL;
PFNGLGETLIGHTIVPROC glad_glGetLightiv = NULL;
PFNGLGETMAPDVPROC glad_glGetMapdv = NULL;
PFNGLGETMAPFVPROC glad_glGetMapfv = NULL;
PFNGLGETMAPIVPROC glad_glGetMapiv = NULL;
PFNGLGETMATERIALFVPROC glad_glGetMaterialfv = NULL;
PFNGLGETMATERIALIVPROC glad_glGetMaterialiv = NULL;
PFNGLGETMULTISAMPLEFVPROC glad_glGetMultisamplefv = NULL;
PFNGLGETNAMEDBUFFERPARAMETERI64VPROC glad_glGetNamedBufferParameteri64v = NULL;
PFNGLGETNAMEDBUFFERPARAMETERIVPROC glad_glGetNamedBufferParameteriv = NULL;
PFNGLGETNAMEDBUFFERPOINTERVPROC glad_glGetNamedBufferPointerv = NULL;
PFNGLGETNAMEDBUFFERSUBDATAPROC glad_glGetNamedBufferSubData = NULL;
PFNGLGETNAMEDFRAMEBUFFERATTACHMENTPARAMETERIVPROC glad_glGetNamedFramebufferAttachmentParameteriv = NULL;
PFNGLGETNAMEDFRAMEBUFFERPARAMETERIVPROC glad_glGetNamedFramebufferParameteriv = NULL;
PFNGLGETNAMEDRENDERBUFFERPARAMETERIVPROC glad_glGetNamedRenderbufferParameteriv = NULL;
PFNGLGETOBJECTLABELPROC glad_glGetObjectLabel = NULL;
PFNGLGETOBJECTPTRLABELPROC glad_glGetObjectPtrLabel = NULL;
PFNGLGETPIXELMAPFVPROC glad_glGetPixelMapfv = NULL;
PFNGLGETPIXELMAPUIVPROC glad_glGetPixelMapuiv = NULL;
PFNGLGETPIXELMAPUSVPROC glad_glGetPixelMapusv = NULL;
PFNGLGETPOINTERVPROC glad_glGetPointerv = NULL;
PFNGLGETPOLYGONSTIPPLEPROC glad_glGetPolygonStipple = NULL;
PFNGLGETPROGRAMBINARYPROC glad_glGetProgramBinary = NULL;
PFNGLGETPROGRAMINFOLOGPROC glad_glGetProgramInfoLog = NULL;
PFNGLGETPROGRAMINTERFACEIVPROC glad_glGetProgramInterfaceiv = NULL;
PFNGLGETPROGRAMPIPELINEINFOLOGPROC glad_glGetProgramPipelineInfoLog = NULL;
PFNGLGETPROGRAMPIPELINEIVPROC glad_glGetProgramPipelineiv = NULL;
PFNGLGETPROGRAMRESOURCEINDEXPROC glad_glGetProgramResourceIndex = NULL;
PFNGLGETPROGRAMRESOURCELOCATIONPROC glad_glGetProgramResourceLocation = NULL;
PFNGLGETPROGRAMRESOURCELOCATIONINDEXPROC glad_glGetProgramResourceLocationIndex = NULL;
PFNGLGETPROGRAMRESOURCENAMEPROC glad_glGetProgramResourceName = NULL;
PFNGLGETPROGRAMRESOURCEIVPROC glad_glGetProgramResourceiv = NULL;
PFNGLGETPROGRAMSTAGEIVPROC glad_glGetProgramStageiv = NULL;
PFNGLGETPROGRAMIVPROC glad_glGetProgramiv = NULL;
PFNGLGETQUERYBUFFEROBJECTI64VPROC glad_glGetQueryBufferObjecti64v = NULL;
PFNGLGETQUERYBUFFEROBJECTIVPROC glad_glGetQueryBufferObjectiv = NULL;
PFNGLGETQUERYBUFFEROBJECTUI64VPROC glad_glGetQueryBufferObjectui64v = NULL;
PFNGLGETQUERYBUFFEROBJECTUIVPROC glad_glGetQueryBufferObjectuiv = NULL;
PFNGLGETQUERYINDEXEDIVPROC glad_glGetQueryIndexediv = NULL;
PFNGLGETQUERYOBJECTI64VPROC glad_glGetQueryObjecti64v = NULL;
PFNGLGETQUERYOBJECTIVPROC glad_glGetQueryObjectiv = NULL;
PFNGLGETQUERYOBJECTUI64VPROC glad_glGetQueryObjectui64v = NULL;
PFNGLGETQUERYOBJECTUIVPROC glad_glGetQueryObjectuiv = NULL;
PFNGLGETQUERYIVPROC glad_glGetQueryiv = NULL;
PFNGLGETRENDERBUFFERPARAMETERIVPROC glad_glGetRenderbufferParameteriv = NULL;
PFNGLGETSAMPLERPARAMETERIIVPROC glad_glGetSamplerParameterIiv = NULL;
PFNGLGETSAMPLERPARAMETERIUIVPROC glad_glGetSamplerParameterIuiv = NULL;
PFNGLGETSAMPLERPARAMETERFVPROC glad_glGetSamplerParameterfv = NULL;
PFNGLGETSAMPLERPARAMETERIVPROC glad_glGetSamplerParameteriv = NULL;
PFNGLGETSHADERINFOLOGPROC glad_glGetShaderInfoLog = NULL;
PFNGLGETSHADERPRECISIONFORMATPROC glad_glGetShaderPrecisionFormat = NULL;
PFNGLGETSHADERSOURCEPROC glad_glGetShaderSource = NULL;
PFNGLGETSHADERIVPROC glad_glGetShaderiv = NULL;
PFNGLGETSTRINGPROC glad_glGetString = NULL;
PFNGLGETSTRINGIPROC glad_glGetStringi = NULL;
PFNGLGETSUBROUTINEINDEXPROC glad_glGetSubroutineIndex = NULL;
PFNGLGETSUBROUTINEUNIFORMLOCATIONPROC glad_glGetSubroutineUniformLocation = NULL;
PFNGLGETSYNCIVPROC glad_glGetSynciv = NULL;
PFNGLGETTEXENVFVPROC glad_glGetTexEnvfv = NULL;
PFNGLGETTEXENVIVPROC glad_glGetTexEnviv = NULL;
PFNGLGETTEXGENDVPROC glad_glGetTexGendv = NULL;
PFNGLGETTEXGENFVPROC glad_glGetTexGenfv = NULL;
PFNGLGETTEXGENIVPROC glad_glGetTexGeniv = NULL;
PFNGLGETTEXIMAGEPROC glad_glGetTexImage = NULL;
PFNGLGETTEXLEVELPARAMETERFVPROC glad_glGetTexLevelParameterfv = NULL;
PFNGLGETTEXLEVELPARAMETERIVPROC glad_glGetTexLevelParameteriv = NULL;
PFNGLGETTEXPARAMETERIIVPROC glad_glGetTexParameterIiv = NULL;
PFNGLGETTEXPARAMETERIUIVPROC glad_glGetTexParameterIuiv = NULL;
PFNGLGETTEXPARAMETERFVPROC glad_glGetTexParameterfv = NULL;
PFNGLGETTEXPARAMETERIVPROC glad_glGetTexParameteriv = NULL;
PFNGLGETTEXTUREIMAGEPROC glad_glGetTextureImage = NULL;
PFNGLGETTEXTURELEVELPARAMETERFVPROC glad_glGetTextureLevelParameterfv = NULL;
PFNGLGETTEXTURELEVELPARAMETERIVPROC glad_glGetTextureLevelParameteriv = NULL;
PFNGLGETTEXTUREPARAMETERIIVPROC glad_glGetTextureParameterIiv = NULL;
PFNGLGETTEXTUREPARAMETERIUIVPROC glad_glGetTextureParameterIuiv = NULL;
PFNGLGETTEXTUREPARAMETERFVPROC glad_glGetTextureParameterfv = NULL;
PFNGLGETTEXTUREPARAMETERIVPROC glad_glGetTextureParameteriv = NULL;
PFNGLGETTEXTURESUBIMAGEPROC glad_glGetTextureSubImage = NULL;
PFNGLGETTRANSFORMFEEDBACKVARYINGPROC glad_glGetTransformFeedbackVarying = NULL;
PFNGLGETTRANSFORMFEEDBACKI64_VPROC glad_glGetTransformFeedbacki64_v = NULL;
PFNGLGETTRANSFORMFEEDBACKI_VPROC glad_glGetTransformFeedbacki_v = NULL;
PFNGLGETTRANSFORMFEEDBACKIVPROC glad_glGetTransformFeedbackiv = NULL;
PFNGLGETUNIFORMBLOCKINDEXPROC glad_glGetUniformBlockIndex = NULL;
PFNGLGETUNIFORMINDICESPROC glad_glGetUniformIndices = NULL;
PFNGLGETUNIFORMLOCATIONPROC glad_glGetUniformLocation = NULL;
PFNGLGETUNIFORMSUBROUTINEUIVPROC glad_glGetUniformSubroutineuiv = NULL;
PFNGLGETUNIFORMDVPROC glad_glGetUniformdv = NULL;
PFNGLGETUNIFORMFVPROC glad_glGetUniformfv = NULL;
PFNGLGETUNIFORMIVPROC glad_glGetUniformiv = NULL;
PFNGLGETUNIFORMUIVPROC glad_glGetUniformuiv = NULL;
PFNGLGETVERTEXARRAYINDEXED64IVPROC glad_glGetVertexArrayIndexed64iv = NULL;
PFNGLGETVERTEXARRAYINDEXEDIVPROC glad_glGetVertexArrayIndexediv = NULL;
PFNGLGETVERTEXARRAYIVPROC glad_glGetVertexArrayiv = NULL;
PFNGLGETVERTEXATTRIBIIVPROC glad_glGetVertexAttribIiv = NULL;
PFNGLGETVERTEXATTRIBIUIVPROC glad_glGetVertexAttribIuiv = NULL;
PFNGLGETVERTEXATTRIBLDVPROC glad_glGetVertexAttribLdv = NULL;
PFNGLGETVERTEXATTRIBPOINTERVPROC glad_glGetVertexAttribPointerv = NULL;
PFNGLGETVERTEXATTRIBDVPROC glad_glGetVertexAttribdv = NULL;
PFNGLGETVERTEXATTRIBFVPROC glad_glGetVertexAttribfv = NULL;
PFNGLGETVERTEXATTRIBIVPROC glad_glGetVertexAttribiv = NULL;
PFNGLGETNCOLORTABLEPROC glad_glGetnColorTable = NULL;
PFNGLGETNCOLORTABLEARBPROC glad_glGetnColorTableARB = NULL;
PFNGLGETNCOMPRESSEDTEXIMAGEPROC glad_glGetnCompressedTexImage = NULL;
PFNGLGETNCOMPRESSEDTEXIMAGEARBPROC glad_glGetnCompressedTexImageARB = NULL;
PFNGLGETNCONVOLUTIONFILTERPROC glad_glGetnConvolutionFilter = NULL;
PFNGLGETNCONVOLUTIONFILTERARBPROC glad_glGetnConvolutionFilterARB = NULL;
PFNGLGETNHISTOGRAMPROC glad_glGetnHistogram = NULL;
PFNGLGETNHISTOGRAMARBPROC glad_glGetnHistogramARB = NULL;
PFNGLGETNMAPDVPROC glad_glGetnMapdv = NULL;
PFNGLGETNMAPDVARBPROC glad_glGetnMapdvARB = NULL;
PFNGLGETNMAPFVPROC glad_glGetnMapfv = NULL;
PFNGLGETNMAPFVARBPROC glad_glGetnMapfvARB = NULL;
PFNGLGETNMAPIVPROC glad_glGetnMapiv = NULL;
PFNGLGETNMAPIVARBPROC glad_glGetnMapivARB = NULL;
PFNGLGETNMINMAXPROC glad_glGetnMinmax = NULL;
PFNGLGETNMINMAXARBPROC glad_glGetnMinmaxARB = NULL;
PFNGLGETNPIXELMAPFVPROC glad_glGetnPixelMapfv = NULL;
PFNGLGETNPIXELMAPFVARBPROC glad_glGetnPixelMapfvARB = NULL;
PFNGLGETNPIXELMAPUIVPROC glad_glGetnPixelMapuiv = NULL;
PFNGLGETNPIXELMAPUIVARBPROC glad_glGetnPixelMapuivARB = NULL;
PFNGLGETNPIXELMAPUSVPROC glad_glGetnPixelMapusv = NULL;
PFNGLGETNPIXELMAPUSVARBPROC glad_glGetnPixelMapusvARB = NULL;
PFNGLGETNPOLYGONSTIPPLEPROC glad_glGetnPolygonStipple = NULL;
PFNGLGETNPOLYGONSTIPPLEARBPROC glad_glGetnPolygonStippleARB = NULL;
PFNGLGETNSEPARABLEFILTERPROC glad_glGetnSeparableFilter = NULL;
PFNGLGETNSEPARABLEFILTERARBPROC glad_glGetnSeparableFilterARB = NULL;
PFNGLGETNTEXIMAGEPROC glad_glGetnTexImage = NULL;
PFNGLGETNTEXIMAGEARBPROC glad_glGetnTexImageARB = NULL;
PFNGLGETNUNIFORMDVPROC glad_glGetnUniformdv = NULL;
PFNGLGETNUNIFORMDVARBPROC glad_glGetnUniformdvARB = NULL;
PFNGLGETNUNIFORMFVPROC glad_glGetnUniformfv = NULL;
PFNGLGETNUNIFORMFVARBPROC glad_glGetnUniformfvARB = NULL;
PFNGLGETNUNIFORMIVPROC glad_glGetnUniformiv = NULL;
PFNGLGETNUNIFORMIVARBPROC glad_glGetnUniformivARB = NULL;
PFNGLGETNUNIFORMUIVPROC glad_glGetnUniformuiv = NULL;
PFNGLGETNUNIFORMUIVARBPROC glad_glGetnUniformuivARB = NULL;
PFNGLHINTPROC glad_glHint = NULL;
PFNGLINDEXMASKPROC glad_glIndexMask = NULL;
PFNGLINDEXPOINTERPROC glad_glIndexPointer = NULL;
PFNGLINDEXDPROC glad_glIndexd = NULL;
PFNGLINDEXDVPROC glad_glIndexdv = NULL;
PFNGLINDEXFPROC glad_glIndexf = NULL;
PFNGLINDEXFVPROC glad_glIndexfv = NULL;
PFNGLINDEXIPROC glad_glIndexi = NULL;
PFNGLINDEXIVPROC glad_glIndexiv = NULL;
PFNGLINDEXSPROC glad_glIndexs = NULL;
PFNGLINDEXSVPROC glad_glIndexsv = NULL;
PFNGLINDEXUBPROC glad_glIndexub = NULL;
PFNGLINDEXUBVPROC glad_glIndexubv = NULL;
PFNGLINITNAMESPROC glad_glInitNames = NULL;
PFNGLINTERLEAVEDARRAYSPROC glad_glInterleavedArrays = NULL;
PFNGLINVALIDATEBUFFERDATAPROC glad_glInvalidateBufferData = NULL;
PFNGLINVALIDATEBUFFERSUBDATAPROC glad_glInvalidateBufferSubData = NULL;
PFNGLINVALIDATEFRAMEBUFFERPROC glad_glInvalidateFramebuffer = NULL;
PFNGLINVALIDATENAMEDFRAMEBUFFERDATAPROC glad_glInvalidateNamedFramebufferData = NULL;
PFNGLINVALIDATENAMEDFRAMEBUFFERSUBDATAPROC glad_glInvalidateNamedFramebufferSubData = NULL;
PFNGLINVALIDATESUBFRAMEBUFFERPROC glad_glInvalidateSubFramebuffer = NULL;
PFNGLINVALIDATETEXIMAGEPROC glad_glInvalidateTexImage = NULL;
PFNGLINVALIDATETEXSUBIMAGEPROC glad_glInvalidateTexSubImage = NULL;
PFNGLISBUFFERPROC glad_glIsBuffer = NULL;
PFNGLISENABLEDPROC glad_glIsEnabled = NULL;
PFNGLISENABLEDIPROC glad_glIsEnabledi = NULL;
PFNGLISFRAMEBUFFERPROC glad_glIsFramebuffer = NULL;
PFNGLISLISTPROC glad_glIsList = NULL;
PFNGLISPROGRAMPROC glad_glIsProgram = NULL;
PFNGLISPROGRAMPIPELINEPROC glad_glIsProgramPipeline = NULL;
PFNGLISQUERYPROC glad_glIsQuery = NULL;
PFNGLISRENDERBUFFERPROC glad_glIsRenderbuffer = NULL;
PFNGLISSAMPLERPROC glad_glIsSampler = NULL;
PFNGLISSHADERPROC glad_glIsShader = NULL;
PFNGLISSYNCPROC glad_glIsSync = NULL;
PFNGLISTEXTUREPROC glad_glIsTexture = NULL;
PFNGLISTRANSFORMFEEDBACKPROC glad_glIsTransformFeedback = NULL;
PFNGLISVERTEXARRAYPROC glad_glIsVertexArray = NULL;
PFNGLLIGHTMODELFPROC glad_glLightModelf = NULL;
PFNGLLIGHTMODELFVPROC glad_glLightModelfv = NULL;
PFNGLLIGHTMODELIPROC glad_glLightModeli = NULL;
PFNGLLIGHTMODELIVPROC glad_glLightModeliv = NULL;
PFNGLLIGHTFPROC glad_glLightf = NULL;
PFNGLLIGHTFVPROC glad_glLightfv = NULL;
PFNGLLIGHTIPROC glad_glLighti = NULL;
PFNGLLIGHTIVPROC glad_glLightiv = NULL;
PFNGLLINESTIPPLEPROC glad_glLineStipple = NULL;
PFNGLLINEWIDTHPROC glad_glLineWidth = NULL;
PFNGLLINKPROGRAMPROC glad_glLinkProgram = NULL;
PFNGLLISTBASEPROC glad_glListBase = NULL;
PFNGLLOADIDENTITYPROC glad_glLoadIdentity = NULL;
PFNGLLOADMATRIXDPROC glad_glLoadMatrixd = NULL;
PFNGLLOADMATRIXFPROC glad_glLoadMatrixf = NULL;
PFNGLLOADNAMEPROC glad_glLoadName = NULL;
PFNGLLOADTRANSPOSEMATRIXDPROC glad_glLoadTransposeMatrixd = NULL;
PFNGLLOADTRANSPOSEMATRIXFPROC glad_glLoadTransposeMatrixf = NULL;
PFNGLLOGICOPPROC glad_glLogicOp = NULL;
PFNGLMAP1DPROC glad_glMap1d = NULL;
PFNGLMAP1FPROC glad_glMap1f = NULL;
PFNGLMAP2DPROC glad_glMap2d = NULL;
PFNGLMAP2FPROC glad_glMap2f = NULL;
PFNGLMAPBUFFERPROC glad_glMapBuffer = NULL;
PFNGLMAPBUFFERRANGEPROC glad_glMapBufferRange = NULL;
PFNGLMAPGRID1DPROC glad_glMapGrid1d = NULL;
PFNGLMAPGRID1FPROC glad_glMapGrid1f = NULL;
PFNGLMAPGRID2DPROC glad_glMapGrid2d = NULL;
PFNGLMAPGRID2FPROC glad_glMapGrid2f = NULL;
PFNGLMAPNAMEDBUFFERPROC glad_glMapNamedBuffer = NULL;
PFNGLMAPNAMEDBUFFERRANGEPROC glad_glMapNamedBufferRange = NULL;
PFNGLMATERIALFPROC glad_glMaterialf = NULL;
PFNGLMATERIALFVPROC glad_glMaterialfv = NULL;
PFNGLMATERIALIPROC glad_glMateriali = NULL;
PFNGLMATERIALIVPROC glad_glMaterialiv = NULL;
PFNGLMATRIXMODEPROC glad_glMatrixMode = NULL;
PFNGLMEMORYBARRIERPROC glad_glMemoryBarrier = NULL;
PFNGLMEMORYBARRIERBYREGIONPROC glad_glMemoryBarrierByRegion = NULL;
PFNGLMINSAMPLESHADINGPROC glad_glMinSampleShading = NULL;
PFNGLMULTMATRIXDPROC glad_glMultMatrixd = NULL;
PFNGLMULTMATRIXFPROC glad_glMultMatrixf = NULL;
PFNGLMULTTRANSPOSEMATRIXDPROC glad_glMultTransposeMatrixd = NULL;
PFNGLMULTTRANSPOSEMATRIXFPROC glad_glMultTransposeMatrixf = NULL;
PFNGLMULTIDRAWARRAYSPROC glad_glMultiDrawArrays = NULL;
PFNGLMULTIDRAWARRAYSINDIRECTPROC glad_glMultiDrawArraysIndirect = NULL;
PFNGLMULTIDRAWARRAYSINDIRECTCOUNTPROC glad_glMultiDrawArraysIndirectCount = NULL;
PFNGLMULTIDRAWELEMENTSPROC glad_glMultiDrawElements = NULL;
PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC glad_glMultiDrawElementsBaseVertex = NULL;
PFNGLMULTIDRAWELEMENTSINDIRECTPROC glad_glMultiDrawElementsIndirect = NULL;
PFNGLMULTIDRAWELEMENTSINDIRECTCOUNTPROC glad_glMultiDrawElementsIndirectCount = NULL;
PFNGLMULTITEXCOORD1DPROC glad_glMultiTexCoord1d = NULL;
PFNGLMULTITEXCOORD1DVPROC glad_glMultiTexCoord1dv = NULL;
PFNGLMULTITEXCOORD1FPROC glad_glMultiTexCoord1f = NULL;
PFNGLMULTITEXCOORD1FVPROC glad_glMultiTexCoord1fv = NULL;
PFNGLMULTITEXCOORD1IPROC glad_glMultiTexCoord1i = NULL;
PFNGLMULTITEXCOORD1IVPROC glad_glMultiTexCoord1iv = NULL;
PFNGLMULTITEXCOORD1SPROC glad_glMultiTexCoord1s = NULL;
PFNGLMULTITEXCOORD1SVPROC glad_glMultiTexCoord1sv = NULL;
PFNGLMULTITEXCOORD2DPROC glad_glMultiTexCoord2d = NULL;
PFNGLMULTITEXCOORD2DVPROC glad_glMultiTexCoord2dv = NULL;
PFNGLMULTITEXCOORD2FPROC glad_glMultiTexCoord2f = NULL;
PFNGLMULTITEXCOORD2FVPROC glad_glMultiTexCoord2fv = NULL;
PFNGLMULTITEXCOORD2IPROC glad_glMultiTexCoord2i = NULL;
PFNGLMULTITEXCOORD2IVPROC glad_glMultiTexCoord2iv = NULL;
PFNGLMULTITEXCOORD2SPROC glad_glMultiTexCoord2s = NULL;
PFNGLMULTITEXCOORD2SVPROC glad_glMultiTexCoord2sv = NULL;
PFNGLMULTITEXCOORD3DPROC glad_glMultiTexCoord3d = NULL;
PFNGLMULTITEXCOORD3DVPROC glad_glMultiTexCoord3dv = NULL;
PFNGLMULTITEXCOORD3FPROC glad_glMultiTexCoord3f = NULL;
PFNGLMULTITEXCOORD3FVPROC glad_glMultiTexCoord3fv = NULL;
PFNGLMULTITEXCOORD3IPROC glad_glMultiTexCoord3i = NULL;
PFNGLMULTITEXCOORD3IVPROC glad_glMultiTexCoord3iv = NULL;
PFNGLMULTITEXCOORD3SPROC glad_glMultiTexCoord3s = NULL;
PFNGLMULTITEXCOORD3SVPROC glad_glMultiTexCoord3sv = NULL;
PFNGLMULTITEXCOORD4DPROC glad_glMultiTexCoord4d = NULL;
PFNGLMULTITEXCOORD4DVPROC glad_glMultiTexCoord4dv = NULL;
PFNGLMULTITEXCOORD4FPROC glad_glMultiTexCoord4f = NULL;
PFNGLMULTITEXCOORD4FVPROC glad_glMultiTexCoord4fv = NULL;
PFNGLMULTITEXCOORD4IPROC glad_glMultiTexCoord4i = NULL;
PFNGLMULTITEXCOORD4IVPROC glad_glMultiTexCoord4iv = NULL;
PFNGLMULTITEXCOORD4SPROC glad_glMultiTexCoord4s = NULL;
PFNGLMULTITEXCOORD4SVPROC glad_glMultiTexCoord4sv = NULL;
PFNGLMULTITEXCOORDP1UIPROC glad_glMultiTexCoordP1ui = NULL;
PFNGLMULTITEXCOORDP1UIVPROC glad_glMultiTexCoordP1uiv = NULL;
PFNGLMULTITEXCOORDP2UIPROC glad_glMultiTexCoordP2ui = NULL;
PFNGLMULTITEXCOORDP2UIVPROC glad_glMultiTexCoordP2uiv = NULL;
PFNGLMULTITEXCOORDP3UIPROC glad_glMultiTexCoordP3ui = NULL;
PFNGLMULTITEXCOORDP3UIVPROC glad_glMultiTexCoordP3uiv = NULL;
PFNGLMULTITEXCOORDP4UIPROC glad_glMultiTexCoordP4ui = NULL;
PFNGLMULTITEXCOORDP4UIVPROC glad_glMultiTexCoordP4uiv = NULL;
PFNGLNAMEDBUFFERDATAPROC glad_glNamedBufferData = NULL;
PFNGLNAMEDBUFFERSTORAGEPROC glad_glNamedBufferStorage = NULL;
PFNGLNAMEDBUFFERSUBDATAPROC glad_glNamedBufferSubData = NULL;
PFNGLNAMEDFRAMEBUFFERDRAWBUFFERPROC glad_glNamedFramebufferDrawBuffer = NULL;
PFNGLNAMEDFRAMEBUFFERDRAWBUFFERSPROC glad_glNamedFramebufferDrawBuffers = NULL;
PFNGLNAMEDFRAMEBUFFERPARAMETERIPROC glad_glNamedFramebufferParameteri = NULL;
PFNGLNAMEDFRAMEBUFFERREADBUFFERPROC glad_glNamedFramebufferReadBuffer = NULL;
PFNGLNAMEDFRAMEBUFFERRENDERBUFFERPROC glad_glNamedFramebufferRenderbuffer = NULL;
PFNGLNAMEDFRAMEBUFFERTEXTUREPROC glad_glNamedFramebufferTexture = NULL;
PFNGLNAMEDFRAMEBUFFERTEXTURELAYERPROC glad_glNamedFramebufferTextureLayer = NULL;
PFNGLNAMEDRENDERBUFFERSTORAGEPROC glad_glNamedRenderbufferStorage = NULL;
PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLEPROC glad_glNamedRenderbufferStorageMultisample = NULL;
PFNGLNEWLISTPROC glad_glNewList = NULL;
PFNGLNORMAL3BPROC glad_glNormal3b = NULL;
PFNGLNORMAL3BVPROC glad_glNormal3bv = NULL;
PFNGLNORMAL3DPROC glad_glNormal3d = NULL;
PFNGLNORMAL3DVPROC glad_glNormal3dv = NULL;
PFNGLNORMAL3FPROC glad_glNormal3f = NULL;
PFNGLNORMAL3FVPROC glad_glNormal3fv = NULL;
PFNGLNORMAL3IPROC glad_glNormal3i = NULL;
PFNGLNORMAL3IVPROC glad_glNormal3iv = NULL;
PFNGLNORMAL3SPROC glad_glNormal3s = NULL;
PFNGLNORMAL3SVPROC glad_glNormal3sv = NULL;
PFNGLNORMALP3UIPROC glad_glNormalP3ui = NULL;
PFNGLNORMALP3UIVPROC glad_glNormalP3uiv = NULL;
PFNGLNORMALPOINTERPROC glad_glNormalPointer = NULL;
PFNGLOBJECTLABELPROC glad_glObjectLabel = NULL;
PFNGLOBJECTPTRLABELPROC glad_glObjectPtrLabel = NULL;
PFNGLORTHOPROC glad_glOrtho = NULL;
PFNGLPASSTHROUGHPROC glad_glPassThrough = NULL;
PFNGLPATCHPARAMETERFVPROC glad_glPatchParameterfv = NULL;
PFNGLPATCHPARAMETERIPROC glad_glPatchParameteri = NULL;
PFNGLPAUSETRANSFORMFEEDBACKPROC glad_glPauseTransformFeedback = NULL;
PFNGLPIXELMAPFVPROC glad_glPixelMapfv = NULL;
PFNGLPIXELMAPUIVPROC glad_glPixelMapuiv = NULL;
PFNGLPIXELMAPUSVPROC glad_glPixelMapusv = NULL;
PFNGLPIXELSTOREFPROC glad_glPixelStoref = NULL;
PFNGLPIXELSTOREIPROC glad_glPixelStorei = NULL;
PFNGLPIXELTRANSFERFPROC glad_glPixelTransferf = NULL;
PFNGLPIXELTRANSFERIPROC glad_glPixelTransferi = NULL;
PFNGLPIXELZOOMPROC glad_glPixelZoom = NULL;
PFNGLPOINTPARAMETERFPROC glad_glPointParameterf = NULL;
PFNGLPOINTPARAMETERFVPROC glad_glPointParameterfv = NULL;
PFNGLPOINTPARAMETERIPROC glad_glPointParameteri = NULL;
PFNGLPOINTPARAMETERIVPROC glad_glPointParameteriv = NULL;
PFNGLPOINTSIZEPROC glad_glPointSize = NULL;
PFNGLPOLYGONMODEPROC glad_glPolygonMode = NULL;
PFNGLPOLYGONOFFSETPROC glad_glPolygonOffset = NULL;
PFNGLPOLYGONOFFSETCLAMPPROC glad_glPolygonOffsetClamp = NULL;
PFNGLPOLYGONSTIPPLEPROC glad_glPolygonStipple = NULL;
PFNGLPOPATTRIBPROC glad_glPopAttrib = NULL;
PFNGLPOPCLIENTATTRIBPROC glad_glPopClientAttrib = NULL;
PFNGLPOPDEBUGGROUPPROC glad_glPopDebugGroup = NULL;
PFNGLPOPMATRIXPROC glad_glPopMatrix = NULL;
PFNGLPOPNAMEPROC glad_glPopName = NULL;
PFNGLPRIMITIVERESTARTINDEXPROC glad_glPrimitiveRestartIndex = NULL;
PFNGLPRIORITIZETEXTURESPROC glad_glPrioritizeTextures = NULL;
PFNGLPROGRAMBINARYPROC glad_glProgramBinary = NULL;
PFNGLPROGRAMPARAMETERIPROC glad_glProgramParameteri = NULL;
PFNGLPROGRAMUNIFORM1DPROC glad_glProgramUniform1d = NULL;
PFNGLPROGRAMUNIFORM1DVPROC glad_glProgramUniform1dv = NULL;
PFNGLPROGRAMUNIFORM1FPROC glad_glProgramUniform1f = NULL;
PFNGLPROGRAMUNIFORM1FVPROC glad_glProgramUniform1fv = NULL;
PFNGLPROGRAMUNIFORM1IPROC glad_glProgramUniform1i = NULL;
PFNGLPROGRAMUNIFORM1IVPROC glad_glProgramUniform1iv = NULL;
PFNGLPROGRAMUNIFORM1UIPROC glad_glProgramUniform1ui = NULL;
PFNGLPROGRAMUNIFORM1UIVPROC glad_glProgramUniform1uiv = NULL;
PFNGLPROGRAMUNIFORM2DPROC glad_glProgramUniform2d = NULL;
PFNGLPROGRAMUNIFORM2DVPROC glad_glProgramUniform2dv = NULL;
PFNGLPROGRAMUNIFORM2FPROC glad_glProgramUniform2f = NULL;
PFNGLPROGRAMUNIFORM2FVPROC glad_glProgramUniform2fv = NULL;
PFNGLPROGRAMUNIFORM2IPROC glad_glProgramUniform2i = NULL;
PFNGLPROGRAMUNIFORM2IVPROC glad_glProgramUniform2iv = NULL;
PFNGLPROGRAMUNIFORM2UIPROC glad_glProgramUniform2ui = NULL;
PFNGLPROGRAMUNIFORM2UIVPROC glad_glProgramUniform2uiv = NULL;
PFNGLPROGRAMUNIFORM3DPROC glad_glProgramUniform3d = NULL;
PFNGLPROGRAMUNIFORM3DVPROC glad_glProgramUniform3dv = NULL;
PFNGLPROGRAMUNIFORM3FPROC glad_glProgramUniform3f = NULL;
PFNGLPROGRAMUNIFORM3FVPROC glad_glProgramUniform3fv = NULL;
PFNGLPROGRAMUNIFORM3IPROC glad_glProgramUniform3i = NULL;
PFNGLPROGRAMUNIFORM3IVPROC glad_glProgramUniform3iv = NULL;
PFNGLPROGRAMUNIFORM3UIPROC glad_glProgramUniform3ui = NULL;
PFNGLPROGRAMUNIFORM3UIVPROC glad_glProgramUniform3uiv = NULL;
PFNGLPROGRAMUNIFORM4DPROC glad_glProgramUniform4d = NULL;
PFNGLPROGRAMUNIFORM4DVPROC glad_glProgramUniform4dv = NULL;
PFNGLPROGRAMUNIFORM4FPROC glad_glProgramUniform4f = NULL;
PFNGLPROGRAMUNIFORM4FVPROC glad_glProgramUniform4fv = NULL;
PFNGLPROGRAMUNIFORM4IPROC glad_glProgramUniform4i = NULL;
PFNGLPROGRAMUNIFORM4IVPROC glad_glProgramUniform4iv = NULL;
PFNGLPROGRAMUNIFORM4UIPROC glad_glProgramUniform4ui = NULL;
PFNGLPROGRAMUNIFORM4UIVPROC glad_glProgramUniform4uiv = NULL;
PFNGLPROGRAMUNIFORMMATRIX2DVPROC glad_glProgramUniformMatrix2dv = NULL;
PFNGLPROGRAMUNIFORMMATRIX2FVPROC glad_glProgramUniformMatrix2fv = NULL;
PFNGLPROGRAMUNIFORMMATRIX2X3DVPROC glad_glProgramUniformMatrix2x3dv = NULL;
PFNGLPROGRAMUNIFORMMATRIX2X3FVPROC glad_glProgramUniformMatrix2x3fv = NULL;
PFNGLPROGRAMUNIFORMMATRIX2X4DVPROC glad_glProgramUniformMatrix2x4dv = NULL;
PFNGLPROGRAMUNIFORMMATRIX2X4FVPROC glad_glProgramUniformMatrix2x4fv = NULL;
PFNGLPROGRAMUNIFORMMATRIX3DVPROC glad_glProgramUniformMatrix3dv = NULL;
PFNGLPROGRAMUNIFORMMATRIX3FVPROC glad_glProgramUniformMatrix3fv = NULL;
PFNGLPROGRAMUNIFORMMATRIX3X2DVPROC glad_glProgramUniformMatrix3x2dv = NULL;
PFNGLPROGRAMUNIFORMMATRIX3X2FVPROC glad_glProgramUniformMatrix3x2fv = NULL;
PFNGLPROGRAMUNIFORMMATRIX3X4DVPROC glad_glProgramUniformMatrix3x4dv = NULL;
PFNGLPROGRAMUNIFORMMATRIX3X4FVPROC glad_glProgramUniformMatrix3x4fv = NULL;
PFNGLPROGRAMUNIFORMMATRIX4DVPROC glad_glProgramUniformMatrix4dv = NULL;
PFNGLPROGRAMUNIFORMMATRIX4FVPROC glad_glProgramUniformMatrix4fv = NULL;
PFNGLPROGRAMUNIFORMMATRIX4X2DVPROC glad_glProgramUniformMatrix4x2dv = NULL;
PFNGLPROGRAMUNIFORMMATRIX4X2FVPROC glad_glProgramUniformMatrix4x2fv = NULL;
PFNGLPROGRAMUNIFORMMATRIX4X3DVPROC glad_glProgramUniformMatrix4x3dv = NULL;
PFNGLPROGRAMUNIFORMMATRIX4X3FVPROC glad_glProgramUniformMatrix4x3fv = NULL;
PFNGLPROVOKINGVERTEXPROC glad_glProvokingVertex = NULL;
PFNGLPUSHATTRIBPROC glad_glPushAttrib = NULL;
PFNGLPUSHCLIENTATTRIBPROC glad_glPushClientAttrib = NULL;
PFNGLPUSHDEBUGGROUPPROC glad_glPushDebugGroup = NULL;
PFNGLPUSHMATRIXPROC glad_glPushMatrix = NULL;
PFNGLPUSHNAMEPROC glad_glPushName = NULL;
PFNGLQUERYCOUNTERPROC glad_glQueryCounter = NULL;
PFNGLRASTERPOS2DPROC glad_glRasterPos2d = NULL;
PFNGLRASTERPOS2DVPROC glad_glRasterPos2dv = NULL;
PFNGLRASTERPOS2FPROC glad_glRasterPos2f = NULL;
PFNGLRASTERPOS2FVPROC glad_glRasterPos2fv = NULL;
PFNGLRASTERPOS2IPROC glad_glRasterPos2i = NULL;
PFNGLRASTERPOS2IVPROC glad_glRasterPos2iv = NULL;
PFNGLRASTERPOS2SPROC glad_glRasterPos2s = NULL;
PFNGLRASTERPOS2SVPROC glad_glRasterPos2sv = NULL;
PFNGLRASTERPOS3DPROC glad_glRasterPos3d = NULL;
PFNGLRASTERPOS3DVPROC glad_glRasterPos3dv = NULL;
PFNGLRASTERPOS3FPROC glad_glRasterPos3f = NULL;
PFNGLRASTERPOS3FVPROC glad_glRasterPos3fv = NULL;
PFNGLRASTERPOS3IPROC glad_glRasterPos3i = NULL;
PFNGLRASTERPOS3IVPROC glad_glRasterPos3iv = NULL;
PFNGLRASTERPOS3SPROC glad_glRasterPos3s = NULL;
PFNGLRASTERPOS3SVPROC glad_glRasterPos3sv = NULL;
PFNGLRASTERPOS4DPROC glad_glRasterPos4d = NULL;
PFNGLRASTERPOS4DVPROC glad_glRasterPos4dv = NULL;
PFNGLRASTERPOS4FPROC glad_glRasterPos4f = NULL;
PFNGLRASTERPOS4FVPROC glad_glRasterPos4fv = NULL;
PFNGLRASTERPOS4IPROC glad_glRasterPos4i = NULL;
PFNGLRASTERPOS4IVPROC glad_glRasterPos4iv = NULL;
PFNGLRASTERPOS4SPROC glad_glRasterPos4s = NULL;
PFNGLRASTERPOS4SVPROC glad_glRasterPos4sv = NULL;
PFNGLREADBUFFERPROC glad_glReadBuffer = NULL;
PFNGLREADPIXELSPROC glad_glReadPixels = NULL;
PFNGLREADNPIXELSPROC glad_glReadnPixels = NULL;
PFNGLREADNPIXELSARBPROC glad_glReadnPixelsARB = NULL;
PFNGLRECTDPROC glad_glRectd = NULL;
PFNGLRECTDVPROC glad_glRectdv = NULL;
PFNGLRECTFPROC glad_glRectf = NULL;
PFNGLRECTFVPROC glad_glRectfv = NULL;
PFNGLRECTIPROC glad_glRecti = NULL;
PFNGLRECTIVPROC glad_glRectiv = NULL;
PFNGLRECTSPROC glad_glRects = NULL;
PFNGLRECTSVPROC glad_glRectsv = NULL;
PFNGLRELEASESHADERCOMPILERPROC glad_glReleaseShaderCompiler = NULL;
PFNGLRENDERMODEPROC glad_glRenderMode = NULL;
PFNGLRENDERBUFFERSTORAGEPROC glad_glRenderbufferStorage = NULL;
PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC glad_glRenderbufferStorageMultisample = NULL;
PFNGLRESUMETRANSFORMFEEDBACKPROC glad_glResumeTransformFeedback = NULL;
PFNGLROTATEDPROC glad_glRotated = NULL;
PFNGLROTATEFPROC glad_glRotatef = NULL;
PFNGLSAMPLECOVERAGEPROC glad_glSampleCoverage = NULL;
PFNGLSAMPLECOVERAGEARBPROC glad_glSampleCoverageARB = NULL;
PFNGLSAMPLEMASKIPROC glad_glSampleMaski = NULL;
PFNGLSAMPLERPARAMETERIIVPROC glad_glSamplerParameterIiv = NULL;
PFNGLSAMPLERPARAMETERIUIVPROC glad_glSamplerParameterIuiv = NULL;
PFNGLSAMPLERPARAMETERFPROC glad_glSamplerParameterf = NULL;
PFNGLSAMPLERPARAMETERFVPROC glad_glSamplerParameterfv = NULL;
PFNGLSAMPLERPARAMETERIPROC glad_glSamplerParameteri = NULL;
PFNGLSAMPLERPARAMETERIVPROC glad_glSamplerParameteriv = NULL;
PFNGLSCALEDPROC glad_glScaled = NULL;
PFNGLSCALEFPROC glad_glScalef = NULL;
PFNGLSCISSORPROC glad_glScissor = NULL;
PFNGLSCISSORARRAYVPROC glad_glScissorArrayv = NULL;
PFNGLSCISSORINDEXEDPROC glad_glScissorIndexed = NULL;
PFNGLSCISSORINDEXEDVPROC glad_glScissorIndexedv = NULL;
PFNGLSECONDARYCOLOR3BPROC glad_glSecondaryColor3b = NULL;
PFNGLSECONDARYCOLOR3BVPROC glad_glSecondaryColor3bv = NULL;
PFNGLSECONDARYCOLOR3DPROC glad_glSecondaryColor3d = NULL;
PFNGLSECONDARYCOLOR3DVPROC glad_glSecondaryColor3dv = NULL;
PFNGLSECONDARYCOLOR3FPROC glad_glSecondaryColor3f = NULL;
PFNGLSECONDARYCOLOR3FVPROC glad_glSecondaryColor3fv = NULL;
PFNGLSECONDARYCOLOR3IPROC glad_glSecondaryColor3i = NULL;
PFNGLSECONDARYCOLOR3IVPROC glad_glSecondaryColor3iv = NULL;
PFNGLSECONDARYCOLOR3SPROC glad_glSecondaryColor3s = NULL;
PFNGLSECONDARYCOLOR3SVPROC glad_glSecondaryColor3sv = NULL;
PFNGLSECONDARYCOLOR3UBPROC glad_glSecondaryColor3ub = NULL;
PFNGLSECONDARYCOLOR3UBVPROC glad_glSecondaryColor3ubv = NULL;
PFNGLSECONDARYCOLOR3UIPROC glad_glSecondaryColor3ui = NULL;
PFNGLSECONDARYCOLOR3UIVPROC glad_glSecondaryColor3uiv = NULL;
PFNGLSECONDARYCOLOR3USPROC glad_glSecondaryColor3us = NULL;
PFNGLSECONDARYCOLOR3USVPROC glad_glSecondaryColor3usv = NULL;
PFNGLSECONDARYCOLORP3UIPROC glad_glSecondaryColorP3ui = NULL;
PFNGLSECONDARYCOLORP3UIVPROC glad_glSecondaryColorP3uiv = NULL;
PFNGLSECONDARYCOLORPOINTERPROC glad_glSecondaryColorPointer = NULL;
PFNGLSELECTBUFFERPROC glad_glSelectBuffer = NULL;
PFNGLSHADEMODELPROC glad_glShadeModel = NULL;
PFNGLSHADERBINARYPROC glad_glShaderBinary = NULL;
PFNGLSHADERSOURCEPROC glad_glShaderSource = NULL;
PFNGLSHADERSTORAGEBLOCKBINDINGPROC glad_glShaderStorageBlockBinding = NULL;
PFNGLSPECIALIZESHADERPROC glad_glSpecializeShader = NULL;
PFNGLSTENCILFUNCPROC glad_glStencilFunc = NULL;
PFNGLSTENCILFUNCSEPARATEPROC glad_glStencilFuncSeparate = NULL;
PFNGLSTENCILMASKPROC glad_glStencilMask = NULL;
PFNGLSTENCILMASKSEPARATEPROC glad_glStencilMaskSeparate = NULL;
PFNGLSTENCILOPPROC glad_glStencilOp = NULL;
PFNGLSTENCILOPSEPARATEPROC glad_glStencilOpSeparate = NULL;
PFNGLTEXBUFFERPROC glad_glTexBuffer = NULL;
PFNGLTEXBUFFERRANGEPROC glad_glTexBufferRange = NULL;
PFNGLTEXCOORD1DPROC glad_glTexCoord1d = NULL;
PFNGLTEXCOORD1DVPROC glad_glTexCoord1dv = NULL;
PFNGLTEXCOORD1FPROC glad_glTexCoord1f = NULL;
PFNGLTEXCOORD1FVPROC glad_glTexCoord1fv = NULL;
PFNGLTEXCOORD1IPROC glad_glTexCoord1i = NULL;
PFNGLTEXCOORD1IVPROC glad_glTexCoord1iv = NULL;
PFNGLTEXCOORD1SPROC glad_glTexCoord1s = NULL;
PFNGLTEXCOORD1SVPROC glad_glTexCoord1sv = NULL;
PFNGLTEXCOORD2DPROC glad_glTexCoord2d = NULL;
PFNGLTEXCOORD2DVPROC glad_glTexCoord2dv = NULL;
PFNGLTEXCOORD2FPROC glad_glTexCoord2f = NULL;
PFNGLTEXCOORD2FVPROC glad_glTexCoord2fv = NULL;
PFNGLTEXCOORD2IPROC glad_glTexCoord2i = NULL;
PFNGLTEXCOORD2IVPROC glad_glTexCoord2iv = NULL;
PFNGLTEXCOORD2SPROC glad_glTexCoord2s = NULL;
PFNGLTEXCOORD2SVPROC glad_glTexCoord2sv = NULL;
PFNGLTEXCOORD3DPROC glad_glTexCoord3d = NULL;
PFNGLTEXCOORD3DVPROC glad_glTexCoord3dv = NULL;
PFNGLTEXCOORD3FPROC glad_glTexCoord3f = NULL;
PFNGLTEXCOORD3FVPROC glad_glTexCoord3fv = NULL;
PFNGLTEXCOORD3IPROC glad_glTexCoord3i = NULL;
PFNGLTEXCOORD3IVPROC glad_glTexCoord3iv = NULL;
PFNGLTEXCOORD3SPROC glad_glTexCoord3s = NULL;
PFNGLTEXCOORD3SVPROC glad_glTexCoord3sv = NULL;
PFNGLTEXCOORD4DPROC glad_glTexCoord4d = NULL;
PFNGLTEXCOORD4DVPROC glad_glTexCoord4dv = NULL;
PFNGLTEXCOORD4FPROC glad_glTexCoord4f = NULL;
PFNGLTEXCOORD4FVPROC glad_glTexCoord4fv = NULL;
PFNGLTEXCOORD4IPROC glad_glTexCoord4i = NULL;
PFNGLTEXCOORD4IVPROC glad_glTexCoord4iv = NULL;
PFNGLTEXCOORD4SPROC glad_glTexCoord4s = NULL;
PFNGLTEXCOORD4SVPROC glad_glTexCoord4sv = NULL;
PFNGLTEXCOORDP1UIPROC glad_glTexCoordP1ui = NULL;
PFNGLTEXCOORDP1UIVPROC glad_glTexCoordP1uiv = NULL;
PFNGLTEXCOORDP2UIPROC glad_glTexCoordP2ui = NULL;
PFNGLTEXCOORDP2UIVPROC glad_glTexCoordP2uiv = NULL;
PFNGLTEXCOORDP3UIPROC glad_glTexCoordP3ui = NULL;
PFNGLTEXCOORDP3UIVPROC glad_glTexCoordP3uiv = NULL;
PFNGLTEXCOORDP4UIPROC glad_glTexCoordP4ui = NULL;
PFNGLTEXCOORDP4UIVPROC glad_glTexCoordP4uiv = NULL;
PFNGLTEXCOORDPOINTERPROC glad_glTexCoordPointer = NULL;
PFNGLTEXENVFPROC glad_glTexEnvf = NULL;
PFNGLTEXENVFVPROC glad_glTexEnvfv = NULL;
PFNGLTEXENVIPROC glad_glTexEnvi = NULL;
PFNGLTEXENVIVPROC glad_glTexEnviv = NULL;
PFNGLTEXGENDPROC glad_glTexGend = NULL;
PFNGLTEXGENDVPROC glad_glTexGendv = NULL;
PFNGLTEXGENFPROC glad_glTexGenf = NULL;
PFNGLTEXGENFVPROC glad_glTexGenfv = NULL;
PFNGLTEXGENIPROC glad_glTexGeni = NULL;
PFNGLTEXGENIVPROC glad_glTexGeniv = NULL;
PFNGLTEXIMAGE1DPROC glad_glTexImage1D = NULL;
PFNGLTEXIMAGE2DPROC glad_glTexImage2D = NULL;
PFNGLTEXIMAGE2DMULTISAMPLEPROC glad_glTexImage2DMultisample = NULL;
PFNGLTEXIMAGE3DPROC glad_glTexImage3D = NULL;
PFNGLTEXIMAGE3DMULTISAMPLEPROC glad_glTexImage3DMultisample = NULL;
PFNGLTEXPARAMETERIIVPROC glad_glTexParameterIiv = NULL;
PFNGLTEXPARAMETERIUIVPROC glad_glTexParameterIuiv = NULL;
PFNGLTEXPARAMETERFPROC glad_glTexParameterf = NULL;
PFNGLTEXPARAMETERFVPROC glad_glTexParameterfv = NULL;
PFNGLTEXPARAMETERIPROC glad_glTexParameteri = NULL;
PFNGLTEXPARAMETERIVPROC glad_glTexParameteriv = NULL;
PFNGLTEXSTORAGE1DPROC glad_glTexStorage1D = NULL;
PFNGLTEXSTORAGE2DPROC glad_glTexStorage2D = NULL;
PFNGLTEXSTORAGE2DMULTISAMPLEPROC glad_glTexStorage2DMultisample = NULL;
PFNGLTEXSTORAGE3DPROC glad_glTexStorage3D = NULL;
PFNGLTEXSTORAGE3DMULTISAMPLEPROC glad_glTexStorage3DMultisample = NULL;
PFNGLTEXSUBIMAGE1DPROC glad_glTexSubImage1D = NULL;
PFNGLTEXSUBIMAGE2DPROC glad_glTexSubImage2D = NULL;
PFNGLTEXSUBIMAGE3DPROC glad_glTexSubImage3D = NULL;
PFNGLTEXTUREBARRIERPROC glad_glTextureBarrier = NULL;
PFNGLTEXTUREBUFFERPROC glad_glTextureBuffer = NULL;
PFNGLTEXTUREBUFFERRANGEPROC glad_glTextureBufferRange = NULL;
PFNGLTEXTUREPARAMETERIIVPROC glad_glTextureParameterIiv = NULL;
PFNGLTEXTUREPARAMETERIUIVPROC glad_glTextureParameterIuiv = NULL;
PFNGLTEXTUREPARAMETERFPROC glad_glTextureParameterf = NULL;
PFNGLTEXTUREPARAMETERFVPROC glad_glTextureParameterfv = NULL;
PFNGLTEXTUREPARAMETERIPROC glad_glTextureParameteri = NULL;
PFNGLTEXTUREPARAMETERIVPROC glad_glTextureParameteriv = NULL;
PFNGLTEXTURESTORAGE1DPROC glad_glTextureStorage1D = NULL;
PFNGLTEXTURESTORAGE2DPROC glad_glTextureStorage2D = NULL;
PFNGLTEXTURESTORAGE2DMULTISAMPLEPROC glad_glTextureStorage2DMultisample = NULL;
PFNGLTEXTURESTORAGE3DPROC glad_glTextureStorage3D = NULL;
PFNGLTEXTURESTORAGE3DMULTISAMPLEPROC glad_glTextureStorage3DMultisample = NULL;
PFNGLTEXTURESUBIMAGE1DPROC glad_glTextureSubImage1D = NULL;
PFNGLTEXTURESUBIMAGE2DPROC glad_glTextureSubImage2D = NULL;
PFNGLTEXTURESUBIMAGE3DPROC glad_glTextureSubImage3D = NULL;
PFNGLTEXTUREVIEWPROC glad_glTextureView = NULL;
PFNGLTRANSFORMFEEDBACKBUFFERBASEPROC glad_glTransformFeedbackBufferBase = NULL;
PFNGLTRANSFORMFEEDBACKBUFFERRANGEPROC glad_glTransformFeedbackBufferRange = NULL;
PFNGLTRANSFORMFEEDBACKVARYINGSPROC glad_glTransformFeedbackVaryings = NULL;
PFNGLTRANSLATEDPROC glad_glTranslated = NULL;
PFNGLTRANSLATEFPROC glad_glTranslatef = NULL;
PFNGLUNIFORM1DPROC glad_glUniform1d = NULL;
PFNGLUNIFORM1DVPROC glad_glUniform1dv = NULL;
PFNGLUNIFORM1FPROC glad_glUniform1f = NULL;
PFNGLUNIFORM1FVPROC glad_glUniform1fv = NULL;
PFNGLUNIFORM1IPROC glad_glUniform1i = NULL;
PFNGLUNIFORM1IVPROC glad_glUniform1iv = NULL;
PFNGLUNIFORM1UIPROC glad_glUniform1ui = NULL;
PFNGLUNIFORM1UIVPROC glad_glUniform1uiv = NULL;
PFNGLUNIFORM2DPROC glad_glUniform2d = NULL;
PFNGLUNIFORM2DVPROC glad_glUniform2dv = NULL;
PFNGLUNIFORM2FPROC glad_glUniform2f = NULL;
PFNGLUNIFORM2FVPROC glad_glUniform2fv = NULL;
PFNGLUNIFORM2IPROC glad_glUniform2i = NULL;
PFNGLUNIFORM2IVPROC glad_glUniform2iv = NULL;
PFNGLUNIFORM2UIPROC glad_glUniform2ui = NULL;
PFNGLUNIFORM2UIVPROC glad_glUniform2uiv = NULL;
PFNGLUNIFORM3DPROC glad_glUniform3d = NULL;
PFNGLUNIFORM3DVPROC glad_glUniform3dv = NULL;
PFNGLUNIFORM3FPROC glad_glUniform3f = NULL;
PFNGLUNIFORM3FVPROC glad_glUniform3fv = NULL;
PFNGLUNIFORM3IPROC glad_glUniform3i = NULL;
PFNGLUNIFORM3IVPROC glad_glUniform3iv = NULL;
PFNGLUNIFORM3UIPROC glad_glUniform3ui = NULL;
PFNGLUNIFORM3UIVPROC glad_glUniform3uiv = NULL;
PFNGLUNIFORM4DPROC glad_glUniform4d = NULL;
PFNGLUNIFORM4DVPROC glad_glUniform4dv = NULL;
PFNGLUNIFORM4FPROC glad_glUniform4f = NULL;
PFNGLUNIFORM4FVPROC glad_glUniform4fv = NULL;
PFNGLUNIFORM4IPROC glad_glUniform4i = NULL;
PFNGLUNIFORM4IVPROC glad_glUniform4iv = NULL;
PFNGLUNIFORM4UIPROC glad_glUniform4ui = NULL;
PFNGLUNIFORM4UIVPROC glad_glUniform4uiv = NULL;
PFNGLUNIFORMBLOCKBINDINGPROC glad_glUniformBlockBinding = NULL;
PFNGLUNIFORMMATRIX2DVPROC glad_glUniformMatrix2dv = NULL;
PFNGLUNIFORMMATRIX2FVPROC glad_glUniformMatrix2fv = NULL;
PFNGLUNIFORMMATRIX2X3DVPROC glad_glUniformMatrix2x3dv = NULL;
PFNGLUNIFORMMATRIX2X3FVPROC glad_glUniformMatrix2x3fv = NULL;
PFNGLUNIFORMMATRIX2X4DVPROC glad_glUniformMatrix2x4dv = NULL;
PFNGLUNIFORMMATRIX2X4FVPROC glad_glUniformMatrix2x4fv = NULL;
PFNGLUNIFORMMATRIX3DVPROC glad_glUniformMatrix3dv = NULL;
PFNGLUNIFORMMATRIX3FVPROC glad_glUniformMatrix3fv = NULL;
PFNGLUNIFORMMATRIX3X2DVPROC glad_glUniformMatrix3x2dv = NULL;
PFNGLUNIFORMMATRIX3X2FVPROC glad_glUniformMatrix3x2fv = NULL;
PFNGLUNIFORMMATRIX3X4DVPROC glad_glUniformMatrix3x4dv = NULL;
PFNGLUNIFORMMATRIX3X4FVPROC glad_glUniformMatrix3x4fv = NULL;
PFNGLUNIFORMMATRIX4DVPROC glad_glUniformMatrix4dv = NULL;
PFNGLUNIFORMMATRIX4FVPROC glad_glUniformMatrix4fv = NULL;
PFNGLUNIFORMMATRIX4X2DVPROC glad_glUniformMatrix4x2dv = NULL;
PFNGLUNIFORMMATRIX4X2FVPROC glad_glUniformMatrix4x2fv = NULL;
PFNGLUNIFORMMATRIX4X3DVPROC glad_glUniformMatrix4x3dv = NULL;
PFNGLUNIFORMMATRIX4X3FVPROC glad_glUniformMatrix4x3fv = NULL;
PFNGLUNIFORMSUBROUTINESUIVPROC glad_glUniformSubroutinesuiv = NULL;
PFNGLUNMAPBUFFERPROC glad_glUnmapBuffer = NULL;
PFNGLUNMAPNAMEDBUFFERPROC glad_glUnmapNamedBuffer = NULL;
PFNGLUSEPROGRAMPROC glad_glUseProgram = NULL;
PFNGLUSEPROGRAMSTAGESPROC glad_glUseProgramStages = NULL;
PFNGLVALIDATEPROGRAMPROC glad_glValidateProgram = NULL;
PFNGLVALIDATEPROGRAMPIPELINEPROC glad_glValidateProgramPipeline = NULL;
PFNGLVERTEX2DPROC glad_glVertex2d = NULL;
PFNGLVERTEX2DVPROC glad_glVertex2dv = NULL;
PFNGLVERTEX2FPROC glad_glVertex2f = NULL;
PFNGLVERTEX2FVPROC glad_glVertex2fv = NULL;
PFNGLVERTEX2IPROC glad_glVertex2i = NULL;
PFNGLVERTEX2IVPROC glad_glVertex2iv = NULL;
PFNGLVERTEX2SPROC glad_glVertex2s = NULL;
PFNGLVERTEX2SVPROC glad_glVertex2sv = NULL;
PFNGLVERTEX3DPROC glad_glVertex3d = NULL;
PFNGLVERTEX3DVPROC glad_glVertex3dv = NULL;
PFNGLVERTEX3FPROC glad_glVertex3f = NULL;
PFNGLVERTEX3FVPROC glad_glVertex3fv = NULL;
PFNGLVERTEX3IPROC glad_glVertex3i = NULL;
PFNGLVERTEX3IVPROC glad_glVertex3iv = NULL;
PFNGLVERTEX3SPROC glad_glVertex3s = NULL;
PFNGLVERTEX3SVPROC glad_glVertex3sv = NULL;
PFNGLVERTEX4DPROC glad_glVertex4d = NULL;
PFNGLVERTEX4DVPROC glad_glVertex4dv = NULL;
PFNGLVERTEX4FPROC glad_glVertex4f = NULL;
PFNGLVERTEX4FVPROC glad_glVertex4fv = NULL;
PFNGLVERTEX4IPROC glad_glVertex4i = NULL;
PFNGLVERTEX4IVPROC glad_glVertex4iv = NULL;
PFNGLVERTEX4SPROC glad_glVertex4s = NULL;
PFNGLVERTEX4SVPROC glad_glVertex4sv = NULL;
PFNGLVERTEXARRAYATTRIBBINDINGPROC glad_glVertexArrayAttribBinding = NULL;
PFNGLVERTEXARRAYATTRIBFORMATPROC glad_glVertexArrayAttribFormat = NULL;
PFNGLVERTEXARRAYATTRIBIFORMATPROC glad_glVertexArrayAttribIFormat = NULL;
PFNGLVERTEXARRAYATTRIBLFORMATPROC glad_glVertexArrayAttribLFormat = NULL;
PFNGLVERTEXARRAYBINDINGDIVISORPROC glad_glVertexArrayBindingDivisor = NULL;
PFNGLVERTEXARRAYELEMENTBUFFERPROC glad_glVertexArrayElementBuffer = NULL;
PFNGLVERTEXARRAYVERTEXBUFFERPROC glad_glVertexArrayVertexBuffer = NULL;
PFNGLVERTEXARRAYVERTEXBUFFERSPROC glad_glVertexArrayVertexBuffers = NULL;
PFNGLVERTEXATTRIB1DPROC glad_glVertexAttrib1d = NULL;
PFNGLVERTEXATTRIB1DVPROC glad_glVertexAttrib1dv = NULL;
PFNGLVERTEXATTRIB1FPROC glad_glVertexAttrib1f = NULL;
PFNGLVERTEXATTRIB1FVPROC glad_glVertexAttrib1fv = NULL;
PFNGLVERTEXATTRIB1SPROC glad_glVertexAttrib1s = NULL;
PFNGLVERTEXATTRIB1SVPROC glad_glVertexAttrib1sv = NULL;
PFNGLVERTEXATTRIB2DPROC glad_glVertexAttrib2d = NULL;
PFNGLVERTEXATTRIB2DVPROC glad_glVertexAttrib2dv = NULL;
PFNGLVERTEXATTRIB2FPROC glad_glVertexAttrib2f = NULL;
PFNGLVERTEXATTRIB2FVPROC glad_glVertexAttrib2fv = NULL;
PFNGLVERTEXATTRIB2SPROC glad_glVertexAttrib2s = NULL;
PFNGLVERTEXATTRIB2SVPROC glad_glVertexAttrib2sv = NULL;
PFNGLVERTEXATTRIB3DPROC glad_glVertexAttrib3d = NULL;
PFNGLVERTEXATTRIB3DVPROC glad_glVertexAttrib3dv = NULL;
PFNGLVERTEXATTRIB3FPROC glad_glVertexAttrib3f = NULL;
PFNGLVERTEXATTRIB3FVPROC glad_glVertexAttrib3fv = NULL;
PFNGLVERTEXATTRIB3SPROC glad_glVertexAttrib3s = NULL;
PFNGLVERTEXATTRIB3SVPROC glad_glVertexAttrib3sv = NULL;
PFNGLVERTEXATTRIB4NBVPROC glad_glVertexAttrib4Nbv = NULL;
PFNGLVERTEXATTRIB4NIVPROC glad_glVertexAttrib4Niv = NULL;
PFNGLVERTEXATTRIB4NSVPROC glad_glVertexAttrib4Nsv = NULL;
PFNGLVERTEXATTRIB4NUBPROC glad_glVertexAttrib4Nub = NULL;
PFNGLVERTEXATTRIB4NUBVPROC glad_glVertexAttrib4Nubv = NULL;
PFNGLVERTEXATTRIB4NUIVPROC glad_glVertexAttrib4Nuiv = NULL;
PFNGLVERTEXATTRIB4NUSVPROC glad_glVertexAttrib4Nusv = NULL;
PFNGLVERTEXATTRIB4BVPROC glad_glVertexAttrib4bv = NULL;
PFNGLVERTEXATTRIB4DPROC glad_glVertexAttrib4d = NULL;
PFNGLVERTEXATTRIB4DVPROC glad_glVertexAttrib4dv = NULL;
PFNGLVERTEXATTRIB4FPROC glad_glVertexAttrib4f = NULL;
PFNGLVERTEXATTRIB4FVPROC glad_glVertexAttrib4fv = NULL;
PFNGLVERTEXATTRIB4IVPROC glad_glVertexAttrib4iv = NULL;
PFNGLVERTEXATTRIB4SPROC glad_glVertexAttrib4s = NULL;
PFNGLVERTEXATTRIB4SVPROC glad_glVertexAttrib4sv = NULL;
PFNGLVERTEXATTRIB4UBVPROC glad_glVertexAttrib4ubv = NULL;
PFNGLVERTEXATTRIB4UIVPROC glad_glVertexAttrib4uiv = NULL;
PFNGLVERTEXATTRIB4USVPROC glad_glVertexAttrib4usv = NULL;
PFNGLVERTEXATTRIBBINDINGPROC glad_glVertexAttribBinding = NULL;
PFNGLVERTEXATTRIBDIVISORPROC glad_glVertexAttribDivisor = NULL;
PFNGLVERTEXATTRIBFORMATPROC glad_glVertexAttribFormat = NULL;
PFNGLVERTEXATTRIBI1IPROC glad_glVertexAttribI1i = NULL;
PFNGLVERTEXATTRIBI1IVPROC glad_glVertexAttribI1iv = NULL;
PFNGLVERTEXATTRIBI1UIPROC glad_glVertexAttribI1ui = NULL;
PFNGLVERTEXATTRIBI1UIVPROC glad_glVertexAttribI1uiv = NULL;
PFNGLVERTEXATTRIBI2IPROC glad_glVertexAttribI2i = NULL;
PFNGLVERTEXATTRIBI2IVPROC glad_glVertexAttribI2iv = NULL;
PFNGLVERTEXATTRIBI2UIPROC glad_glVertexAttribI2ui = NULL;
PFNGLVERTEXATTRIBI2UIVPROC glad_glVertexAttribI2uiv = NULL;
PFNGLVERTEXATTRIBI3IPROC glad_glVertexAttribI3i = NULL;
PFNGLVERTEXATTRIBI3IVPROC glad_glVertexAttribI3iv = NULL;
PFNGLVERTEXATTRIBI3UIPROC glad_glVertexAttribI3ui = NULL;
PFNGLVERTEXATTRIBI3UIVPROC glad_glVertexAttribI3uiv = NULL;
PFNGLVERTEXATTRIBI4BVPROC glad_glVertexAttribI4bv = NULL;
PFNGLVERTEXATTRIBI4IPROC glad_glVertexAttribI4i = NULL;
PFNGLVERTEXATTRIBI4IVPROC glad_glVertexAttribI4iv = NULL;
PFNGLVERTEXATTRIBI4SVPROC glad_glVertexAttribI4sv = NULL;
PFNGLVERTEXATTRIBI4UBVPROC glad_glVertexAttribI4ubv = NULL;
PFNGLVERTEXATTRIBI4UIPROC glad_glVertexAttribI4ui = NULL;
PFNGLVERTEXATTRIBI4UIVPROC glad_glVertexAttribI4uiv = NULL;
PFNGLVERTEXATTRIBI4USVPROC glad_glVertexAttribI4usv = NULL;
PFNGLVERTEXATTRIBIFORMATPROC glad_glVertexAttribIFormat = NULL;
PFNGLVERTEXATTRIBIPOINTERPROC glad_glVertexAttribIPointer = NULL;
PFNGLVERTEXATTRIBL1DPROC glad_glVertexAttribL1d = NULL;
PFNGLVERTEXATTRIBL1DVPROC glad_glVertexAttribL1dv = NULL;
PFNGLVERTEXATTRIBL2DPROC glad_glVertexAttribL2d = NULL;
PFNGLVERTEXATTRIBL2DVPROC glad_glVertexAttribL2dv = NULL;
PFNGLVERTEXATTRIBL3DPROC glad_glVertexAttribL3d = NULL;
PFNGLVERTEXATTRIBL3DVPROC glad_glVertexAttribL3dv = NULL;
PFNGLVERTEXATTRIBL4DPROC glad_glVertexAttribL4d = NULL;
PFNGLVERTEXATTRIBL4DVPROC glad_glVertexAttribL4dv = NULL;
PFNGLVERTEXATTRIBLFORMATPROC glad_glVertexAttribLFormat = NULL;
PFNGLVERTEXATTRIBLPOINTERPROC glad_glVertexAttribLPointer = NULL;
PFNGLVERTEXATTRIBP1UIPROC glad_glVertexAttribP1ui = NULL;
PFNGLVERTEXATTRIBP1UIVPROC glad_glVertexAttribP1uiv = NULL;
PFNGLVERTEXATTRIBP2UIPROC glad_glVertexAttribP2ui = NULL;
PFNGLVERTEXATTRIBP2UIVPROC glad_glVertexAttribP2uiv = NULL;
PFNGLVERTEXATTRIBP3UIPROC glad_glVertexAttribP3ui = NULL;
PFNGLVERTEXATTRIBP3UIVPROC glad_glVertexAttribP3uiv = NULL;
PFNGLVERTEXATTRIBP4UIPROC glad_glVertexAttribP4ui = NULL;
PFNGLVERTEXATTRIBP4UIVPROC glad_glVertexAttribP4uiv = NULL;
PFNGLVERTEXATTRIBPOINTERPROC glad_glVertexAttribPointer = NULL;
PFNGLVERTEXBINDINGDIVISORPROC glad_glVertexBindingDivisor = NULL;
PFNGLVERTEXP2UIPROC glad_glVertexP2ui = NULL;
PFNGLVERTEXP2UIVPROC glad_glVertexP2uiv = NULL;
PFNGLVERTEXP3UIPROC glad_glVertexP3ui = NULL;
PFNGLVERTEXP3UIVPROC glad_glVertexP3uiv = NULL;
PFNGLVERTEXP4UIPROC glad_glVertexP4ui = NULL;
PFNGLVERTEXP4UIVPROC glad_glVertexP4uiv = NULL;
PFNGLVERTEXPOINTERPROC glad_glVertexPointer = NULL;
PFNGLVIEWPORTPROC glad_glViewport = NULL;
PFNGLVIEWPORTARRAYVPROC glad_glViewportArrayv = NULL;
PFNGLVIEWPORTINDEXEDFPROC glad_glViewportIndexedf = NULL;
PFNGLVIEWPORTINDEXEDFVPROC glad_glViewportIndexedfv = NULL;
PFNGLWAITSYNCPROC glad_glWaitSync = NULL;
PFNGLWINDOWPOS2DPROC glad_glWindowPos2d = NULL;
PFNGLWINDOWPOS2DVPROC glad_glWindowPos2dv = NULL;
PFNGLWINDOWPOS2FPROC glad_glWindowPos2f = NULL;
PFNGLWINDOWPOS2FVPROC glad_glWindowPos2fv = NULL;
PFNGLWINDOWPOS2IPROC glad_glWindowPos2i = NULL;
PFNGLWINDOWPOS2IVPROC glad_glWindowPos2iv = NULL;
PFNGLWINDOWPOS2SPROC glad_glWindowPos2s = NULL;
PFNGLWINDOWPOS2SVPROC glad_glWindowPos2sv = NULL;
PFNGLWINDOWPOS3DPROC glad_glWindowPos3d = NULL;
PFNGLWINDOWPOS3DVPROC glad_glWindowPos3dv = NULL;
PFNGLWINDOWPOS3FPROC glad_glWindowPos3f = NULL;
PFNGLWINDOWPOS3FVPROC glad_glWindowPos3fv = NULL;
PFNGLWINDOWPOS3IPROC glad_glWindowPos3i = NULL;
PFNGLWINDOWPOS3IVPROC glad_glWindowPos3iv = NULL;
PFNGLWINDOWPOS3SPROC glad_glWindowPos3s = NULL;
PFNGLWINDOWPOS3SVPROC glad_glWindowPos3sv = NULL;
static void glad_gl_load_GL_VERSION_1_0( GLADuserptrloadfunc load, void* userptr) {
if(!GLAD_GL_VERSION_1_0) return;
glad_glAccum = (PFNGLACCUMPROC) load(userptr, "glAccum");
glad_glAlphaFunc = (PFNGLALPHAFUNCPROC) load(userptr, "glAlphaFunc");
glad_glBegin = (PFNGLBEGINPROC) load(userptr, "glBegin");
glad_glBitmap = (PFNGLBITMAPPROC) load(userptr, "glBitmap");
glad_glBlendFunc = (PFNGLBLENDFUNCPROC) load(userptr, "glBlendFunc");
glad_glCallList = (PFNGLCALLLISTPROC) load(userptr, "glCallList");
glad_glCallLists = (PFNGLCALLLISTSPROC) load(userptr, "glCallLists");
glad_glClear = (PFNGLCLEARPROC) load(userptr, "glClear");
glad_glClearAccum = (PFNGLCLEARACCUMPROC) load(userptr, "glClearAccum");
glad_glClearColor = (PFNGLCLEARCOLORPROC) load(userptr, "glClearColor");
glad_glClearDepth = (PFNGLCLEARDEPTHPROC) load(userptr, "glClearDepth");
glad_glClearIndex = (PFNGLCLEARINDEXPROC) load(userptr, "glClearIndex");
glad_glClearStencil = (PFNGLCLEARSTENCILPROC) load(userptr, "glClearStencil");
glad_glClipPlane = (PFNGLCLIPPLANEPROC) load(userptr, "glClipPlane");
glad_glColor3b = (PFNGLCOLOR3BPROC) load(userptr, "glColor3b");
glad_glColor3bv = (PFNGLCOLOR3BVPROC) load(userptr, "glColor3bv");
glad_glColor3d = (PFNGLCOLOR3DPROC) load(userptr, "glColor3d");
glad_glColor3dv = (PFNGLCOLOR3DVPROC) load(userptr, "glColor3dv");
glad_glColor3f = (PFNGLCOLOR3FPROC) load(userptr, "glColor3f");
glad_glColor3fv = (PFNGLCOLOR3FVPROC) load(userptr, "glColor3fv");
glad_glColor3i = (PFNGLCOLOR3IPROC) load(userptr, "glColor3i");
glad_glColor3iv = (PFNGLCOLOR3IVPROC) load(userptr, "glColor3iv");
glad_glColor3s = (PFNGLCOLOR3SPROC) load(userptr, "glColor3s");
glad_glColor3sv = (PFNGLCOLOR3SVPROC) load(userptr, "glColor3sv");
glad_glColor3ub = (PFNGLCOLOR3UBPROC) load(userptr, "glColor3ub");
glad_glColor3ubv = (PFNGLCOLOR3UBVPROC) load(userptr, "glColor3ubv");
glad_glColor3ui = (PFNGLCOLOR3UIPROC) load(userptr, "glColor3ui");
glad_glColor3uiv = (PFNGLCOLOR3UIVPROC) load(userptr, "glColor3uiv");
glad_glColor3us = (PFNGLCOLOR3USPROC) load(userptr, "glColor3us");
glad_glColor3usv = (PFNGLCOLOR3USVPROC) load(userptr, "glColor3usv");
glad_glColor4b = (PFNGLCOLOR4BPROC) load(userptr, "glColor4b");
glad_glColor4bv = (PFNGLCOLOR4BVPROC) load(userptr, "glColor4bv");
glad_glColor4d = (PFNGLCOLOR4DPROC) load(userptr, "glColor4d");
glad_glColor4dv = (PFNGLCOLOR4DVPROC) load(userptr, "glColor4dv");
glad_glColor4f = (PFNGLCOLOR4FPROC) load(userptr, "glColor4f");
glad_glColor4fv = (PFNGLCOLOR4FVPROC) load(userptr, "glColor4fv");
glad_glColor4i = (PFNGLCOLOR4IPROC) load(userptr, "glColor4i");
glad_glColor4iv = (PFNGLCOLOR4IVPROC) load(userptr, "glColor4iv");
glad_glColor4s = (PFNGLCOLOR4SPROC) load(userptr, "glColor4s");
glad_glColor4sv = (PFNGLCOLOR4SVPROC) load(userptr, "glColor4sv");
glad_glColor4ub = (PFNGLCOLOR4UBPROC) load(userptr, "glColor4ub");
glad_glColor4ubv = (PFNGLCOLOR4UBVPROC) load(userptr, "glColor4ubv");
glad_glColor4ui = (PFNGLCOLOR4UIPROC) load(userptr, "glColor4ui");
glad_glColor4uiv = (PFNGLCOLOR4UIVPROC) load(userptr, "glColor4uiv");
glad_glColor4us = (PFNGLCOLOR4USPROC) load(userptr, "glColor4us");
glad_glColor4usv = (PFNGLCOLOR4USVPROC) load(userptr, "glColor4usv");
glad_glColorMask = (PFNGLCOLORMASKPROC) load(userptr, "glColorMask");
glad_glColorMaterial = (PFNGLCOLORMATERIALPROC) load(userptr, "glColorMaterial");
glad_glCopyPixels = (PFNGLCOPYPIXELSPROC) load(userptr, "glCopyPixels");
glad_glCullFace = (PFNGLCULLFACEPROC) load(userptr, "glCullFace");
glad_glDeleteLists = (PFNGLDELETELISTSPROC) load(userptr, "glDeleteLists");
glad_glDepthFunc = (PFNGLDEPTHFUNCPROC) load(userptr, "glDepthFunc");
glad_glDepthMask = (PFNGLDEPTHMASKPROC) load(userptr, "glDepthMask");
glad_glDepthRange = (PFNGLDEPTHRANGEPROC) load(userptr, "glDepthRange");
glad_glDisable = (PFNGLDISABLEPROC) load(userptr, "glDisable");
glad_glDrawBuffer = (PFNGLDRAWBUFFERPROC) load(userptr, "glDrawBuffer");
glad_glDrawPixels = (PFNGLDRAWPIXELSPROC) load(userptr, "glDrawPixels");
glad_glEdgeFlag = (PFNGLEDGEFLAGPROC) load(userptr, "glEdgeFlag");
glad_glEdgeFlagv = (PFNGLEDGEFLAGVPROC) load(userptr, "glEdgeFlagv");
glad_glEnable = (PFNGLENABLEPROC) load(userptr, "glEnable");
glad_glEnd = (PFNGLENDPROC) load(userptr, "glEnd");
glad_glEndList = (PFNGLENDLISTPROC) load(userptr, "glEndList");
glad_glEvalCoord1d = (PFNGLEVALCOORD1DPROC) load(userptr, "glEvalCoord1d");
glad_glEvalCoord1dv = (PFNGLEVALCOORD1DVPROC) load(userptr, "glEvalCoord1dv");
glad_glEvalCoord1f = (PFNGLEVALCOORD1FPROC) load(userptr, "glEvalCoord1f");
glad_glEvalCoord1fv = (PFNGLEVALCOORD1FVPROC) load(userptr, "glEvalCoord1fv");
glad_glEvalCoord2d = (PFNGLEVALCOORD2DPROC) load(userptr, "glEvalCoord2d");
glad_glEvalCoord2dv = (PFNGLEVALCOORD2DVPROC) load(userptr, "glEvalCoord2dv");
glad_glEvalCoord2f = (PFNGLEVALCOORD2FPROC) load(userptr, "glEvalCoord2f");
glad_glEvalCoord2fv = (PFNGLEVALCOORD2FVPROC) load(userptr, "glEvalCoord2fv");
glad_glEvalMesh1 = (PFNGLEVALMESH1PROC) load(userptr, "glEvalMesh1");
glad_glEvalMesh2 = (PFNGLEVALMESH2PROC) load(userptr, "glEvalMesh2");
glad_glEvalPoint1 = (PFNGLEVALPOINT1PROC) load(userptr, "glEvalPoint1");
glad_glEvalPoint2 = (PFNGLEVALPOINT2PROC) load(userptr, "glEvalPoint2");
glad_glFeedbackBuffer = (PFNGLFEEDBACKBUFFERPROC) load(userptr, "glFeedbackBuffer");
glad_glFinish = (PFNGLFINISHPROC) load(userptr, "glFinish");
glad_glFlush = (PFNGLFLUSHPROC) load(userptr, "glFlush");
glad_glFogf = (PFNGLFOGFPROC) load(userptr, "glFogf");
glad_glFogfv = (PFNGLFOGFVPROC) load(userptr, "glFogfv");
glad_glFogi = (PFNGLFOGIPROC) load(userptr, "glFogi");
glad_glFogiv = (PFNGLFOGIVPROC) load(userptr, "glFogiv");
glad_glFrontFace = (PFNGLFRONTFACEPROC) load(userptr, "glFrontFace");
glad_glFrustum = (PFNGLFRUSTUMPROC) load(userptr, "glFrustum");
glad_glGenLists = (PFNGLGENLISTSPROC) load(userptr, "glGenLists");
glad_glGetBooleanv = (PFNGLGETBOOLEANVPROC) load(userptr, "glGetBooleanv");
glad_glGetClipPlane = (PFNGLGETCLIPPLANEPROC) load(userptr, "glGetClipPlane");
glad_glGetDoublev = (PFNGLGETDOUBLEVPROC) load(userptr, "glGetDoublev");
glad_glGetError = (PFNGLGETERRORPROC) load(userptr, "glGetError");
glad_glGetFloatv = (PFNGLGETFLOATVPROC) load(userptr, "glGetFloatv");
glad_glGetIntegerv = (PFNGLGETINTEGERVPROC) load(userptr, "glGetIntegerv");
glad_glGetLightfv = (PFNGLGETLIGHTFVPROC) load(userptr, "glGetLightfv");
glad_glGetLightiv = (PFNGLGETLIGHTIVPROC) load(userptr, "glGetLightiv");
glad_glGetMapdv = (PFNGLGETMAPDVPROC) load(userptr, "glGetMapdv");
glad_glGetMapfv = (PFNGLGETMAPFVPROC) load(userptr, "glGetMapfv");
glad_glGetMapiv = (PFNGLGETMAPIVPROC) load(userptr, "glGetMapiv");
glad_glGetMaterialfv = (PFNGLGETMATERIALFVPROC) load(userptr, "glGetMaterialfv");
glad_glGetMaterialiv = (PFNGLGETMATERIALIVPROC) load(userptr, "glGetMaterialiv");
glad_glGetPixelMapfv = (PFNGLGETPIXELMAPFVPROC) load(userptr, "glGetPixelMapfv");
glad_glGetPixelMapuiv = (PFNGLGETPIXELMAPUIVPROC) load(userptr, "glGetPixelMapuiv");
glad_glGetPixelMapusv = (PFNGLGETPIXELMAPUSVPROC) load(userptr, "glGetPixelMapusv");
glad_glGetPolygonStipple = (PFNGLGETPOLYGONSTIPPLEPROC) load(userptr, "glGetPolygonStipple");
glad_glGetString = (PFNGLGETSTRINGPROC) load(userptr, "glGetString");
glad_glGetTexEnvfv = (PFNGLGETTEXENVFVPROC) load(userptr, "glGetTexEnvfv");
glad_glGetTexEnviv = (PFNGLGETTEXENVIVPROC) load(userptr, "glGetTexEnviv");
glad_glGetTexGendv = (PFNGLGETTEXGENDVPROC) load(userptr, "glGetTexGendv");
glad_glGetTexGenfv = (PFNGLGETTEXGENFVPROC) load(userptr, "glGetTexGenfv");
glad_glGetTexGeniv = (PFNGLGETTEXGENIVPROC) load(userptr, "glGetTexGeniv");
glad_glGetTexImage = (PFNGLGETTEXIMAGEPROC) load(userptr, "glGetTexImage");
glad_glGetTexLevelParameterfv = (PFNGLGETTEXLEVELPARAMETERFVPROC) load(userptr, "glGetTexLevelParameterfv");
glad_glGetTexLevelParameteriv = (PFNGLGETTEXLEVELPARAMETERIVPROC) load(userptr, "glGetTexLevelParameteriv");
glad_glGetTexParameterfv = (PFNGLGETTEXPARAMETERFVPROC) load(userptr, "glGetTexParameterfv");
glad_glGetTexParameteriv = (PFNGLGETTEXPARAMETERIVPROC) load(userptr, "glGetTexParameteriv");
glad_glHint = (PFNGLHINTPROC) load(userptr, "glHint");
glad_glIndexMask = (PFNGLINDEXMASKPROC) load(userptr, "glIndexMask");
glad_glIndexd = (PFNGLINDEXDPROC) load(userptr, "glIndexd");
glad_glIndexdv = (PFNGLINDEXDVPROC) load(userptr, "glIndexdv");
glad_glIndexf = (PFNGLINDEXFPROC) load(userptr, "glIndexf");
glad_glIndexfv = (PFNGLINDEXFVPROC) load(userptr, "glIndexfv");
glad_glIndexi = (PFNGLINDEXIPROC) load(userptr, "glIndexi");
glad_glIndexiv = (PFNGLINDEXIVPROC) load(userptr, "glIndexiv");
glad_glIndexs = (PFNGLINDEXSPROC) load(userptr, "glIndexs");
glad_glIndexsv = (PFNGLINDEXSVPROC) load(userptr, "glIndexsv");
glad_glInitNames = (PFNGLINITNAMESPROC) load(userptr, "glInitNames");
glad_glIsEnabled = (PFNGLISENABLEDPROC) load(userptr, "glIsEnabled");
glad_glIsList = (PFNGLISLISTPROC) load(userptr, "glIsList");
glad_glLightModelf = (PFNGLLIGHTMODELFPROC) load(userptr, "glLightModelf");
glad_glLightModelfv = (PFNGLLIGHTMODELFVPROC) load(userptr, "glLightModelfv");
glad_glLightModeli = (PFNGLLIGHTMODELIPROC) load(userptr, "glLightModeli");
glad_glLightModeliv = (PFNGLLIGHTMODELIVPROC) load(userptr, "glLightModeliv");
glad_glLightf = (PFNGLLIGHTFPROC) load(userptr, "glLightf");
glad_glLightfv = (PFNGLLIGHTFVPROC) load(userptr, "glLightfv");
glad_glLighti = (PFNGLLIGHTIPROC) load(userptr, "glLighti");
glad_glLightiv = (PFNGLLIGHTIVPROC) load(userptr, "glLightiv");
glad_glLineStipple = (PFNGLLINESTIPPLEPROC) load(userptr, "glLineStipple");
glad_glLineWidth = (PFNGLLINEWIDTHPROC) load(userptr, "glLineWidth");
glad_glListBase = (PFNGLLISTBASEPROC) load(userptr, "glListBase");
glad_glLoadIdentity = (PFNGLLOADIDENTITYPROC) load(userptr, "glLoadIdentity");
glad_glLoadMatrixd = (PFNGLLOADMATRIXDPROC) load(userptr, "glLoadMatrixd");
glad_glLoadMatrixf = (PFNGLLOADMATRIXFPROC) load(userptr, "glLoadMatrixf");
glad_glLoadName = (PFNGLLOADNAMEPROC) load(userptr, "glLoadName");
glad_glLogicOp = (PFNGLLOGICOPPROC) load(userptr, "glLogicOp");
glad_glMap1d = (PFNGLMAP1DPROC) load(userptr, "glMap1d");
glad_glMap1f = (PFNGLMAP1FPROC) load(userptr, "glMap1f");
glad_glMap2d = (PFNGLMAP2DPROC) load(userptr, "glMap2d");
glad_glMap2f = (PFNGLMAP2FPROC) load(userptr, "glMap2f");
glad_glMapGrid1d = (PFNGLMAPGRID1DPROC) load(userptr, "glMapGrid1d");
glad_glMapGrid1f = (PFNGLMAPGRID1FPROC) load(userptr, "glMapGrid1f");
glad_glMapGrid2d = (PFNGLMAPGRID2DPROC) load(userptr, "glMapGrid2d");
glad_glMapGrid2f = (PFNGLMAPGRID2FPROC) load(userptr, "glMapGrid2f");
glad_glMaterialf = (PFNGLMATERIALFPROC) load(userptr, "glMaterialf");
glad_glMaterialfv = (PFNGLMATERIALFVPROC) load(userptr, "glMaterialfv");
glad_glMateriali = (PFNGLMATERIALIPROC) load(userptr, "glMateriali");
glad_glMaterialiv = (PFNGLMATERIALIVPROC) load(userptr, "glMaterialiv");
glad_glMatrixMode = (PFNGLMATRIXMODEPROC) load(userptr, "glMatrixMode");
glad_glMultMatrixd = (PFNGLMULTMATRIXDPROC) load(userptr, "glMultMatrixd");
glad_glMultMatrixf = (PFNGLMULTMATRIXFPROC) load(userptr, "glMultMatrixf");
glad_glNewList = (PFNGLNEWLISTPROC) load(userptr, "glNewList");
glad_glNormal3b = (PFNGLNORMAL3BPROC) load(userptr, "glNormal3b");
glad_glNormal3bv = (PFNGLNORMAL3BVPROC) load(userptr, "glNormal3bv");
glad_glNormal3d = (PFNGLNORMAL3DPROC) load(userptr, "glNormal3d");
glad_glNormal3dv = (PFNGLNORMAL3DVPROC) load(userptr, "glNormal3dv");
glad_glNormal3f = (PFNGLNORMAL3FPROC) load(userptr, "glNormal3f");
glad_glNormal3fv = (PFNGLNORMAL3FVPROC) load(userptr, "glNormal3fv");
glad_glNormal3i = (PFNGLNORMAL3IPROC) load(userptr, "glNormal3i");
glad_glNormal3iv = (PFNGLNORMAL3IVPROC) load(userptr, "glNormal3iv");
glad_glNormal3s = (PFNGLNORMAL3SPROC) load(userptr, "glNormal3s");
glad_glNormal3sv = (PFNGLNORMAL3SVPROC) load(userptr, "glNormal3sv");
glad_glOrtho = (PFNGLORTHOPROC) load(userptr, "glOrtho");
glad_glPassThrough = (PFNGLPASSTHROUGHPROC) load(userptr, "glPassThrough");
glad_glPixelMapfv = (PFNGLPIXELMAPFVPROC) load(userptr, "glPixelMapfv");
glad_glPixelMapuiv = (PFNGLPIXELMAPUIVPROC) load(userptr, "glPixelMapuiv");
glad_glPixelMapusv = (PFNGLPIXELMAPUSVPROC) load(userptr, "glPixelMapusv");
glad_glPixelStoref = (PFNGLPIXELSTOREFPROC) load(userptr, "glPixelStoref");
glad_glPixelStorei = (PFNGLPIXELSTOREIPROC) load(userptr, "glPixelStorei");
glad_glPixelTransferf = (PFNGLPIXELTRANSFERFPROC) load(userptr, "glPixelTransferf");
glad_glPixelTransferi = (PFNGLPIXELTRANSFERIPROC) load(userptr, "glPixelTransferi");
glad_glPixelZoom = (PFNGLPIXELZOOMPROC) load(userptr, "glPixelZoom");
glad_glPointSize = (PFNGLPOINTSIZEPROC) load(userptr, "glPointSize");
glad_glPolygonMode = (PFNGLPOLYGONMODEPROC) load(userptr, "glPolygonMode");
glad_glPolygonStipple = (PFNGLPOLYGONSTIPPLEPROC) load(userptr, "glPolygonStipple");
glad_glPopAttrib = (PFNGLPOPATTRIBPROC) load(userptr, "glPopAttrib");
glad_glPopMatrix = (PFNGLPOPMATRIXPROC) load(userptr, "glPopMatrix");
glad_glPopName = (PFNGLPOPNAMEPROC) load(userptr, "glPopName");
glad_glPushAttrib = (PFNGLPUSHATTRIBPROC) load(userptr, "glPushAttrib");
glad_glPushMatrix = (PFNGLPUSHMATRIXPROC) load(userptr, "glPushMatrix");
glad_glPushName = (PFNGLPUSHNAMEPROC) load(userptr, "glPushName");
glad_glRasterPos2d = (PFNGLRASTERPOS2DPROC) load(userptr, "glRasterPos2d");
glad_glRasterPos2dv = (PFNGLRASTERPOS2DVPROC) load(userptr, "glRasterPos2dv");
glad_glRasterPos2f = (PFNGLRASTERPOS2FPROC) load(userptr, "glRasterPos2f");
glad_glRasterPos2fv = (PFNGLRASTERPOS2FVPROC) load(userptr, "glRasterPos2fv");
glad_glRasterPos2i = (PFNGLRASTERPOS2IPROC) load(userptr, "glRasterPos2i");
glad_glRasterPos2iv = (PFNGLRASTERPOS2IVPROC) load(userptr, "glRasterPos2iv");
glad_glRasterPos2s = (PFNGLRASTERPOS2SPROC) load(userptr, "glRasterPos2s");
glad_glRasterPos2sv = (PFNGLRASTERPOS2SVPROC) load(userptr, "glRasterPos2sv");
glad_glRasterPos3d = (PFNGLRASTERPOS3DPROC) load(userptr, "glRasterPos3d");
glad_glRasterPos3dv = (PFNGLRASTERPOS3DVPROC) load(userptr, "glRasterPos3dv");
glad_glRasterPos3f = (PFNGLRASTERPOS3FPROC) load(userptr, "glRasterPos3f");
glad_glRasterPos3fv = (PFNGLRASTERPOS3FVPROC) load(userptr, "glRasterPos3fv");
glad_glRasterPos3i = (PFNGLRASTERPOS3IPROC) load(userptr, "glRasterPos3i");
glad_glRasterPos3iv = (PFNGLRASTERPOS3IVPROC) load(userptr, "glRasterPos3iv");
glad_glRasterPos3s = (PFNGLRASTERPOS3SPROC) load(userptr, "glRasterPos3s");
glad_glRasterPos3sv = (PFNGLRASTERPOS3SVPROC) load(userptr, "glRasterPos3sv");
glad_glRasterPos4d = (PFNGLRASTERPOS4DPROC) load(userptr, "glRasterPos4d");
glad_glRasterPos4dv = (PFNGLRASTERPOS4DVPROC) load(userptr, "glRasterPos4dv");
glad_glRasterPos4f = (PFNGLRASTERPOS4FPROC) load(userptr, "glRasterPos4f");
glad_glRasterPos4fv = (PFNGLRASTERPOS4FVPROC) load(userptr, "glRasterPos4fv");
glad_glRasterPos4i = (PFNGLRASTERPOS4IPROC) load(userptr, "glRasterPos4i");
glad_glRasterPos4iv = (PFNGLRASTERPOS4IVPROC) load(userptr, "glRasterPos4iv");
glad_glRasterPos4s = (PFNGLRASTERPOS4SPROC) load(userptr, "glRasterPos4s");
glad_glRasterPos4sv = (PFNGLRASTERPOS4SVPROC) load(userptr, "glRasterPos4sv");
glad_glReadBuffer = (PFNGLREADBUFFERPROC) load(userptr, "glReadBuffer");
glad_glReadPixels = (PFNGLREADPIXELSPROC) load(userptr, "glReadPixels");
glad_glRectd = (PFNGLRECTDPROC) load(userptr, "glRectd");
glad_glRectdv = (PFNGLRECTDVPROC) load(userptr, "glRectdv");
glad_glRectf = (PFNGLRECTFPROC) load(userptr, "glRectf");
glad_glRectfv = (PFNGLRECTFVPROC) load(userptr, "glRectfv");
glad_glRecti = (PFNGLRECTIPROC) load(userptr, "glRecti");
glad_glRectiv = (PFNGLRECTIVPROC) load(userptr, "glRectiv");
glad_glRects = (PFNGLRECTSPROC) load(userptr, "glRects");
glad_glRectsv = (PFNGLRECTSVPROC) load(userptr, "glRectsv");
glad_glRenderMode = (PFNGLRENDERMODEPROC) load(userptr, "glRenderMode");
glad_glRotated = (PFNGLROTATEDPROC) load(userptr, "glRotated");
glad_glRotatef = (PFNGLROTATEFPROC) load(userptr, "glRotatef");
glad_glScaled = (PFNGLSCALEDPROC) load(userptr, "glScaled");
glad_glScalef = (PFNGLSCALEFPROC) load(userptr, "glScalef");
glad_glScissor = (PFNGLSCISSORPROC) load(userptr, "glScissor");
glad_glSelectBuffer = (PFNGLSELECTBUFFERPROC) load(userptr, "glSelectBuffer");
glad_glShadeModel = (PFNGLSHADEMODELPROC) load(userptr, "glShadeModel");
glad_glStencilFunc = (PFNGLSTENCILFUNCPROC) load(userptr, "glStencilFunc");
glad_glStencilMask = (PFNGLSTENCILMASKPROC) load(userptr, "glStencilMask");
glad_glStencilOp = (PFNGLSTENCILOPPROC) load(userptr, "glStencilOp");
glad_glTexCoord1d = (PFNGLTEXCOORD1DPROC) load(userptr, "glTexCoord1d");
glad_glTexCoord1dv = (PFNGLTEXCOORD1DVPROC) load(userptr, "glTexCoord1dv");
glad_glTexCoord1f = (PFNGLTEXCOORD1FPROC) load(userptr, "glTexCoord1f");
glad_glTexCoord1fv = (PFNGLTEXCOORD1FVPROC) load(userptr, "glTexCoord1fv");
glad_glTexCoord1i = (PFNGLTEXCOORD1IPROC) load(userptr, "glTexCoord1i");
glad_glTexCoord1iv = (PFNGLTEXCOORD1IVPROC) load(userptr, "glTexCoord1iv");
glad_glTexCoord1s = (PFNGLTEXCOORD1SPROC) load(userptr, "glTexCoord1s");
glad_glTexCoord1sv = (PFNGLTEXCOORD1SVPROC) load(userptr, "glTexCoord1sv");
glad_glTexCoord2d = (PFNGLTEXCOORD2DPROC) load(userptr, "glTexCoord2d");
glad_glTexCoord2dv = (PFNGLTEXCOORD2DVPROC) load(userptr, "glTexCoord2dv");
glad_glTexCoord2f = (PFNGLTEXCOORD2FPROC) load(userptr, "glTexCoord2f");
glad_glTexCoord2fv = (PFNGLTEXCOORD2FVPROC) load(userptr, "glTexCoord2fv");
glad_glTexCoord2i = (PFNGLTEXCOORD2IPROC) load(userptr, "glTexCoord2i");
glad_glTexCoord2iv = (PFNGLTEXCOORD2IVPROC) load(userptr, "glTexCoord2iv");
glad_glTexCoord2s = (PFNGLTEXCOORD2SPROC) load(userptr, "glTexCoord2s");
glad_glTexCoord2sv = (PFNGLTEXCOORD2SVPROC) load(userptr, "glTexCoord2sv");
glad_glTexCoord3d = (PFNGLTEXCOORD3DPROC) load(userptr, "glTexCoord3d");
glad_glTexCoord3dv = (PFNGLTEXCOORD3DVPROC) load(userptr, "glTexCoord3dv");
glad_glTexCoord3f = (PFNGLTEXCOORD3FPROC) load(userptr, "glTexCoord3f");
glad_glTexCoord3fv = (PFNGLTEXCOORD3FVPROC) load(userptr, "glTexCoord3fv");
glad_glTexCoord3i = (PFNGLTEXCOORD3IPROC) load(userptr, "glTexCoord3i");
glad_glTexCoord3iv = (PFNGLTEXCOORD3IVPROC) load(userptr, "glTexCoord3iv");
glad_glTexCoord3s = (PFNGLTEXCOORD3SPROC) load(userptr, "glTexCoord3s");
glad_glTexCoord3sv = (PFNGLTEXCOORD3SVPROC) load(userptr, "glTexCoord3sv");
glad_glTexCoord4d = (PFNGLTEXCOORD4DPROC) load(userptr, "glTexCoord4d");
glad_glTexCoord4dv = (PFNGLTEXCOORD4DVPROC) load(userptr, "glTexCoord4dv");
glad_glTexCoord4f = (PFNGLTEXCOORD4FPROC) load(userptr, "glTexCoord4f");
glad_glTexCoord4fv = (PFNGLTEXCOORD4FVPROC) load(userptr, "glTexCoord4fv");
glad_glTexCoord4i = (PFNGLTEXCOORD4IPROC) load(userptr, "glTexCoord4i");
glad_glTexCoord4iv = (PFNGLTEXCOORD4IVPROC) load(userptr, "glTexCoord4iv");
glad_glTexCoord4s = (PFNGLTEXCOORD4SPROC) load(userptr, "glTexCoord4s");
glad_glTexCoord4sv = (PFNGLTEXCOORD4SVPROC) load(userptr, "glTexCoord4sv");
glad_glTexEnvf = (PFNGLTEXENVFPROC) load(userptr, "glTexEnvf");
glad_glTexEnvfv = (PFNGLTEXENVFVPROC) load(userptr, "glTexEnvfv");
glad_glTexEnvi = (PFNGLTEXENVIPROC) load(userptr, "glTexEnvi");
glad_glTexEnviv = (PFNGLTEXENVIVPROC) load(userptr, "glTexEnviv");
glad_glTexGend = (PFNGLTEXGENDPROC) load(userptr, "glTexGend");
glad_glTexGendv = (PFNGLTEXGENDVPROC) load(userptr, "glTexGendv");
glad_glTexGenf = (PFNGLTEXGENFPROC) load(userptr, "glTexGenf");
glad_glTexGenfv = (PFNGLTEXGENFVPROC) load(userptr, "glTexGenfv");
glad_glTexGeni = (PFNGLTEXGENIPROC) load(userptr, "glTexGeni");
glad_glTexGeniv = (PFNGLTEXGENIVPROC) load(userptr, "glTexGeniv");
glad_glTexImage1D = (PFNGLTEXIMAGE1DPROC) load(userptr, "glTexImage1D");
glad_glTexImage2D = (PFNGLTEXIMAGE2DPROC) load(userptr, "glTexImage2D");
glad_glTexParameterf = (PFNGLTEXPARAMETERFPROC) load(userptr, "glTexParameterf");
glad_glTexParameterfv = (PFNGLTEXPARAMETERFVPROC) load(userptr, "glTexParameterfv");
glad_glTexParameteri = (PFNGLTEXPARAMETERIPROC) load(userptr, "glTexParameteri");
glad_glTexParameteriv = (PFNGLTEXPARAMETERIVPROC) load(userptr, "glTexParameteriv");
glad_glTranslated = (PFNGLTRANSLATEDPROC) load(userptr, "glTranslated");
glad_glTranslatef = (PFNGLTRANSLATEFPROC) load(userptr, "glTranslatef");
glad_glVertex2d = (PFNGLVERTEX2DPROC) load(userptr, "glVertex2d");
glad_glVertex2dv = (PFNGLVERTEX2DVPROC) load(userptr, "glVertex2dv");
glad_glVertex2f = (PFNGLVERTEX2FPROC) load(userptr, "glVertex2f");
glad_glVertex2fv = (PFNGLVERTEX2FVPROC) load(userptr, "glVertex2fv");
glad_glVertex2i = (PFNGLVERTEX2IPROC) load(userptr, "glVertex2i");
glad_glVertex2iv = (PFNGLVERTEX2IVPROC) load(userptr, "glVertex2iv");
glad_glVertex2s = (PFNGLVERTEX2SPROC) load(userptr, "glVertex2s");
glad_glVertex2sv = (PFNGLVERTEX2SVPROC) load(userptr, "glVertex2sv");
glad_glVertex3d = (PFNGLVERTEX3DPROC) load(userptr, "glVertex3d");
glad_glVertex3dv = (PFNGLVERTEX3DVPROC) load(userptr, "glVertex3dv");
glad_glVertex3f = (PFNGLVERTEX3FPROC) load(userptr, "glVertex3f");
glad_glVertex3fv = (PFNGLVERTEX3FVPROC) load(userptr, "glVertex3fv");
glad_glVertex3i = (PFNGLVERTEX3IPROC) load(userptr, "glVertex3i");
glad_glVertex3iv = (PFNGLVERTEX3IVPROC) load(userptr, "glVertex3iv");
glad_glVertex3s = (PFNGLVERTEX3SPROC) load(userptr, "glVertex3s");
glad_glVertex3sv = (PFNGLVERTEX3SVPROC) load(userptr, "glVertex3sv");
glad_glVertex4d = (PFNGLVERTEX4DPROC) load(userptr, "glVertex4d");
glad_glVertex4dv = (PFNGLVERTEX4DVPROC) load(userptr, "glVertex4dv");
glad_glVertex4f = (PFNGLVERTEX4FPROC) load(userptr, "glVertex4f");
glad_glVertex4fv = (PFNGLVERTEX4FVPROC) load(userptr, "glVertex4fv");
glad_glVertex4i = (PFNGLVERTEX4IPROC) load(userptr, "glVertex4i");
glad_glVertex4iv = (PFNGLVERTEX4IVPROC) load(userptr, "glVertex4iv");
glad_glVertex4s = (PFNGLVERTEX4SPROC) load(userptr, "glVertex4s");
glad_glVertex4sv = (PFNGLVERTEX4SVPROC) load(userptr, "glVertex4sv");
glad_glViewport = (PFNGLVIEWPORTPROC) load(userptr, "glViewport");
}
static void glad_gl_load_GL_VERSION_1_1( GLADuserptrloadfunc load, void* userptr) {
if(!GLAD_GL_VERSION_1_1) return;
glad_glAreTexturesResident = (PFNGLARETEXTURESRESIDENTPROC) load(userptr, "glAreTexturesResident");
glad_glArrayElement = (PFNGLARRAYELEMENTPROC) load(userptr, "glArrayElement");
glad_glBindTexture = (PFNGLBINDTEXTUREPROC) load(userptr, "glBindTexture");
glad_glColorPointer = (PFNGLCOLORPOINTERPROC) load(userptr, "glColorPointer");
glad_glCopyTexImage1D = (PFNGLCOPYTEXIMAGE1DPROC) load(userptr, "glCopyTexImage1D");
glad_glCopyTexImage2D = (PFNGLCOPYTEXIMAGE2DPROC) load(userptr, "glCopyTexImage2D");
glad_glCopyTexSubImage1D = (PFNGLCOPYTEXSUBIMAGE1DPROC) load(userptr, "glCopyTexSubImage1D");
glad_glCopyTexSubImage2D = (PFNGLCOPYTEXSUBIMAGE2DPROC) load(userptr, "glCopyTexSubImage2D");
glad_glDeleteTextures = (PFNGLDELETETEXTURESPROC) load(userptr, "glDeleteTextures");
glad_glDisableClientState = (PFNGLDISABLECLIENTSTATEPROC) load(userptr, "glDisableClientState");
glad_glDrawArrays = (PFNGLDRAWARRAYSPROC) load(userptr, "glDrawArrays");
glad_glDrawElements = (PFNGLDRAWELEMENTSPROC) load(userptr, "glDrawElements");
glad_glEdgeFlagPointer = (PFNGLEDGEFLAGPOINTERPROC) load(userptr, "glEdgeFlagPointer");
glad_glEnableClientState = (PFNGLENABLECLIENTSTATEPROC) load(userptr, "glEnableClientState");
glad_glGenTextures = (PFNGLGENTEXTURESPROC) load(userptr, "glGenTextures");
glad_glGetPointerv = (PFNGLGETPOINTERVPROC) load(userptr, "glGetPointerv");
glad_glIndexPointer = (PFNGLINDEXPOINTERPROC) load(userptr, "glIndexPointer");
glad_glIndexub = (PFNGLINDEXUBPROC) load(userptr, "glIndexub");
glad_glIndexubv = (PFNGLINDEXUBVPROC) load(userptr, "glIndexubv");
glad_glInterleavedArrays = (PFNGLINTERLEAVEDARRAYSPROC) load(userptr, "glInterleavedArrays");
glad_glIsTexture = (PFNGLISTEXTUREPROC) load(userptr, "glIsTexture");
glad_glNormalPointer = (PFNGLNORMALPOINTERPROC) load(userptr, "glNormalPointer");
glad_glPolygonOffset = (PFNGLPOLYGONOFFSETPROC) load(userptr, "glPolygonOffset");
glad_glPopClientAttrib = (PFNGLPOPCLIENTATTRIBPROC) load(userptr, "glPopClientAttrib");
glad_glPrioritizeTextures = (PFNGLPRIORITIZETEXTURESPROC) load(userptr, "glPrioritizeTextures");
glad_glPushClientAttrib = (PFNGLPUSHCLIENTATTRIBPROC) load(userptr, "glPushClientAttrib");
glad_glTexCoordPointer = (PFNGLTEXCOORDPOINTERPROC) load(userptr, "glTexCoordPointer");
glad_glTexSubImage1D = (PFNGLTEXSUBIMAGE1DPROC) load(userptr, "glTexSubImage1D");
glad_glTexSubImage2D = (PFNGLTEXSUBIMAGE2DPROC) load(userptr, "glTexSubImage2D");
glad_glVertexPointer = (PFNGLVERTEXPOINTERPROC) load(userptr, "glVertexPointer");
}
static void glad_gl_load_GL_VERSION_1_2( GLADuserptrloadfunc load, void* userptr) {
if(!GLAD_GL_VERSION_1_2) return;
glad_glCopyTexSubImage3D = (PFNGLCOPYTEXSUBIMAGE3DPROC) load(userptr, "glCopyTexSubImage3D");
glad_glDrawRangeElements = (PFNGLDRAWRANGEELEMENTSPROC) load(userptr, "glDrawRangeElements");
glad_glTexImage3D = (PFNGLTEXIMAGE3DPROC) load(userptr, "glTexImage3D");
glad_glTexSubImage3D = (PFNGLTEXSUBIMAGE3DPROC) load(userptr, "glTexSubImage3D");
}
static void glad_gl_load_GL_VERSION_1_3( GLADuserptrloadfunc load, void* userptr) {
if(!GLAD_GL_VERSION_1_3) return;
glad_glActiveTexture = (PFNGLACTIVETEXTUREPROC) load(userptr, "glActiveTexture");
glad_glClientActiveTexture = (PFNGLCLIENTACTIVETEXTUREPROC) load(userptr, "glClientActiveTexture");
glad_glCompressedTexImage1D = (PFNGLCOMPRESSEDTEXIMAGE1DPROC) load(userptr, "glCompressedTexImage1D");
glad_glCompressedTexImage2D = (PFNGLCOMPRESSEDTEXIMAGE2DPROC) load(userptr, "glCompressedTexImage2D");
glad_glCompressedTexImage3D = (PFNGLCOMPRESSEDTEXIMAGE3DPROC) load(userptr, "glCompressedTexImage3D");
glad_glCompressedTexSubImage1D = (PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC) load(userptr, "glCompressedTexSubImage1D");
glad_glCompressedTexSubImage2D = (PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC) load(userptr, "glCompressedTexSubImage2D");
glad_glCompressedTexSubImage3D = (PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC) load(userptr, "glCompressedTexSubImage3D");
glad_glGetCompressedTexImage = (PFNGLGETCOMPRESSEDTEXIMAGEPROC) load(userptr, "glGetCompressedTexImage");
glad_glLoadTransposeMatrixd = (PFNGLLOADTRANSPOSEMATRIXDPROC) load(userptr, "glLoadTransposeMatrixd");
glad_glLoadTransposeMatrixf = (PFNGLLOADTRANSPOSEMATRIXFPROC) load(userptr, "glLoadTransposeMatrixf");
glad_glMultTransposeMatrixd = (PFNGLMULTTRANSPOSEMATRIXDPROC) load(userptr, "glMultTransposeMatrixd");
glad_glMultTransposeMatrixf = (PFNGLMULTTRANSPOSEMATRIXFPROC) load(userptr, "glMultTransposeMatrixf");
glad_glMultiTexCoord1d = (PFNGLMULTITEXCOORD1DPROC) load(userptr, "glMultiTexCoord1d");
glad_glMultiTexCoord1dv = (PFNGLMULTITEXCOORD1DVPROC) load(userptr, "glMultiTexCoord1dv");
glad_glMultiTexCoord1f = (PFNGLMULTITEXCOORD1FPROC) load(userptr, "glMultiTexCoord1f");
glad_glMultiTexCoord1fv = (PFNGLMULTITEXCOORD1FVPROC) load(userptr, "glMultiTexCoord1fv");
glad_glMultiTexCoord1i = (PFNGLMULTITEXCOORD1IPROC) load(userptr, "glMultiTexCoord1i");
glad_glMultiTexCoord1iv = (PFNGLMULTITEXCOORD1IVPROC) load(userptr, "glMultiTexCoord1iv");
glad_glMultiTexCoord1s = (PFNGLMULTITEXCOORD1SPROC) load(userptr, "glMultiTexCoord1s");
glad_glMultiTexCoord1sv = (PFNGLMULTITEXCOORD1SVPROC) load(userptr, "glMultiTexCoord1sv");
glad_glMultiTexCoord2d = (PFNGLMULTITEXCOORD2DPROC) load(userptr, "glMultiTexCoord2d");
glad_glMultiTexCoord2dv = (PFNGLMULTITEXCOORD2DVPROC) load(userptr, "glMultiTexCoord2dv");
glad_glMultiTexCoord2f = (PFNGLMULTITEXCOORD2FPROC) load(userptr, "glMultiTexCoord2f");
glad_glMultiTexCoord2fv = (PFNGLMULTITEXCOORD2FVPROC) load(userptr, "glMultiTexCoord2fv");
glad_glMultiTexCoord2i = (PFNGLMULTITEXCOORD2IPROC) load(userptr, "glMultiTexCoord2i");
glad_glMultiTexCoord2iv = (PFNGLMULTITEXCOORD2IVPROC) load(userptr, "glMultiTexCoord2iv");
glad_glMultiTexCoord2s = (PFNGLMULTITEXCOORD2SPROC) load(userptr, "glMultiTexCoord2s");
glad_glMultiTexCoord2sv = (PFNGLMULTITEXCOORD2SVPROC) load(userptr, "glMultiTexCoord2sv");
glad_glMultiTexCoord3d = (PFNGLMULTITEXCOORD3DPROC) load(userptr, "glMultiTexCoord3d");
glad_glMultiTexCoord3dv = (PFNGLMULTITEXCOORD3DVPROC) load(userptr, "glMultiTexCoord3dv");
glad_glMultiTexCoord3f = (PFNGLMULTITEXCOORD3FPROC) load(userptr, "glMultiTexCoord3f");
glad_glMultiTexCoord3fv = (PFNGLMULTITEXCOORD3FVPROC) load(userptr, "glMultiTexCoord3fv");
glad_glMultiTexCoord3i = (PFNGLMULTITEXCOORD3IPROC) load(userptr, "glMultiTexCoord3i");
glad_glMultiTexCoord3iv = (PFNGLMULTITEXCOORD3IVPROC) load(userptr, "glMultiTexCoord3iv");
glad_glMultiTexCoord3s = (PFNGLMULTITEXCOORD3SPROC) load(userptr, "glMultiTexCoord3s");
glad_glMultiTexCoord3sv = (PFNGLMULTITEXCOORD3SVPROC) load(userptr, "glMultiTexCoord3sv");
glad_glMultiTexCoord4d = (PFNGLMULTITEXCOORD4DPROC) load(userptr, "glMultiTexCoord4d");
glad_glMultiTexCoord4dv = (PFNGLMULTITEXCOORD4DVPROC) load(userptr, "glMultiTexCoord4dv");
glad_glMultiTexCoord4f = (PFNGLMULTITEXCOORD4FPROC) load(userptr, "glMultiTexCoord4f");
glad_glMultiTexCoord4fv = (PFNGLMULTITEXCOORD4FVPROC) load(userptr, "glMultiTexCoord4fv");
glad_glMultiTexCoord4i = (PFNGLMULTITEXCOORD4IPROC) load(userptr, "glMultiTexCoord4i");
glad_glMultiTexCoord4iv = (PFNGLMULTITEXCOORD4IVPROC) load(userptr, "glMultiTexCoord4iv");
glad_glMultiTexCoord4s = (PFNGLMULTITEXCOORD4SPROC) load(userptr, "glMultiTexCoord4s");
glad_glMultiTexCoord4sv = (PFNGLMULTITEXCOORD4SVPROC) load(userptr, "glMultiTexCoord4sv");
glad_glSampleCoverage = (PFNGLSAMPLECOVERAGEPROC) load(userptr, "glSampleCoverage");
}
static void glad_gl_load_GL_VERSION_1_4( GLADuserptrloadfunc load, void* userptr) {
if(!GLAD_GL_VERSION_1_4) return;
glad_glBlendColor = (PFNGLBLENDCOLORPROC) load(userptr, "glBlendColor");
glad_glBlendEquation = (PFNGLBLENDEQUATIONPROC) load(userptr, "glBlendEquation");
glad_glBlendFuncSeparate = (PFNGLBLENDFUNCSEPARATEPROC) load(userptr, "glBlendFuncSeparate");
glad_glFogCoordPointer = (PFNGLFOGCOORDPOINTERPROC) load(userptr, "glFogCoordPointer");
glad_glFogCoordd = (PFNGLFOGCOORDDPROC) load(userptr, "glFogCoordd");
glad_glFogCoorddv = (PFNGLFOGCOORDDVPROC) load(userptr, "glFogCoorddv");
glad_glFogCoordf = (PFNGLFOGCOORDFPROC) load(userptr, "glFogCoordf");
glad_glFogCoordfv = (PFNGLFOGCOORDFVPROC) load(userptr, "glFogCoordfv");
glad_glMultiDrawArrays = (PFNGLMULTIDRAWARRAYSPROC) load(userptr, "glMultiDrawArrays");
glad_glMultiDrawElements = (PFNGLMULTIDRAWELEMENTSPROC) load(userptr, "glMultiDrawElements");
glad_glPointParameterf = (PFNGLPOINTPARAMETERFPROC) load(userptr, "glPointParameterf");
glad_glPointParameterfv = (PFNGLPOINTPARAMETERFVPROC) load(userptr, "glPointParameterfv");
glad_glPointParameteri = (PFNGLPOINTPARAMETERIPROC) load(userptr, "glPointParameteri");
glad_glPointParameteriv = (PFNGLPOINTPARAMETERIVPROC) load(userptr, "glPointParameteriv");
glad_glSecondaryColor3b = (PFNGLSECONDARYCOLOR3BPROC) load(userptr, "glSecondaryColor3b");
glad_glSecondaryColor3bv = (PFNGLSECONDARYCOLOR3BVPROC) load(userptr, "glSecondaryColor3bv");
glad_glSecondaryColor3d = (PFNGLSECONDARYCOLOR3DPROC) load(userptr, "glSecondaryColor3d");
glad_glSecondaryColor3dv = (PFNGLSECONDARYCOLOR3DVPROC) load(userptr, "glSecondaryColor3dv");
glad_glSecondaryColor3f = (PFNGLSECONDARYCOLOR3FPROC) load(userptr, "glSecondaryColor3f");
glad_glSecondaryColor3fv = (PFNGLSECONDARYCOLOR3FVPROC) load(userptr, "glSecondaryColor3fv");
glad_glSecondaryColor3i = (PFNGLSECONDARYCOLOR3IPROC) load(userptr, "glSecondaryColor3i");
glad_glSecondaryColor3iv = (PFNGLSECONDARYCOLOR3IVPROC) load(userptr, "glSecondaryColor3iv");
glad_glSecondaryColor3s = (PFNGLSECONDARYCOLOR3SPROC) load(userptr, "glSecondaryColor3s");
glad_glSecondaryColor3sv = (PFNGLSECONDARYCOLOR3SVPROC) load(userptr, "glSecondaryColor3sv");
glad_glSecondaryColor3ub = (PFNGLSECONDARYCOLOR3UBPROC) load(userptr, "glSecondaryColor3ub");
glad_glSecondaryColor3ubv = (PFNGLSECONDARYCOLOR3UBVPROC) load(userptr, "glSecondaryColor3ubv");
glad_glSecondaryColor3ui = (PFNGLSECONDARYCOLOR3UIPROC) load(userptr, "glSecondaryColor3ui");
glad_glSecondaryColor3uiv = (PFNGLSECONDARYCOLOR3UIVPROC) load(userptr, "glSecondaryColor3uiv");
glad_glSecondaryColor3us = (PFNGLSECONDARYCOLOR3USPROC) load(userptr, "glSecondaryColor3us");
glad_glSecondaryColor3usv = (PFNGLSECONDARYCOLOR3USVPROC) load(userptr, "glSecondaryColor3usv");
glad_glSecondaryColorPointer = (PFNGLSECONDARYCOLORPOINTERPROC) load(userptr, "glSecondaryColorPointer");
glad_glWindowPos2d = (PFNGLWINDOWPOS2DPROC) load(userptr, "glWindowPos2d");
glad_glWindowPos2dv = (PFNGLWINDOWPOS2DVPROC) load(userptr, "glWindowPos2dv");
glad_glWindowPos2f = (PFNGLWINDOWPOS2FPROC) load(userptr, "glWindowPos2f");
glad_glWindowPos2fv = (PFNGLWINDOWPOS2FVPROC) load(userptr, "glWindowPos2fv");
glad_glWindowPos2i = (PFNGLWINDOWPOS2IPROC) load(userptr, "glWindowPos2i");
glad_glWindowPos2iv = (PFNGLWINDOWPOS2IVPROC) load(userptr, "glWindowPos2iv");
glad_glWindowPos2s = (PFNGLWINDOWPOS2SPROC) load(userptr, "glWindowPos2s");
glad_glWindowPos2sv = (PFNGLWINDOWPOS2SVPROC) load(userptr, "glWindowPos2sv");
glad_glWindowPos3d = (PFNGLWINDOWPOS3DPROC) load(userptr, "glWindowPos3d");
glad_glWindowPos3dv = (PFNGLWINDOWPOS3DVPROC) load(userptr, "glWindowPos3dv");
glad_glWindowPos3f = (PFNGLWINDOWPOS3FPROC) load(userptr, "glWindowPos3f");
glad_glWindowPos3fv = (PFNGLWINDOWPOS3FVPROC) load(userptr, "glWindowPos3fv");
glad_glWindowPos3i = (PFNGLWINDOWPOS3IPROC) load(userptr, "glWindowPos3i");
glad_glWindowPos3iv = (PFNGLWINDOWPOS3IVPROC) load(userptr, "glWindowPos3iv");
glad_glWindowPos3s = (PFNGLWINDOWPOS3SPROC) load(userptr, "glWindowPos3s");
glad_glWindowPos3sv = (PFNGLWINDOWPOS3SVPROC) load(userptr, "glWindowPos3sv");
}
static void glad_gl_load_GL_VERSION_1_5( GLADuserptrloadfunc load, void* userptr) {
if(!GLAD_GL_VERSION_1_5) return;
glad_glBeginQuery = (PFNGLBEGINQUERYPROC) load(userptr, "glBeginQuery");
glad_glBindBuffer = (PFNGLBINDBUFFERPROC) load(userptr, "glBindBuffer");
glad_glBufferData = (PFNGLBUFFERDATAPROC) load(userptr, "glBufferData");
glad_glBufferSubData = (PFNGLBUFFERSUBDATAPROC) load(userptr, "glBufferSubData");
glad_glDeleteBuffers = (PFNGLDELETEBUFFERSPROC) load(userptr, "glDeleteBuffers");
glad_glDeleteQueries = (PFNGLDELETEQUERIESPROC) load(userptr, "glDeleteQueries");
glad_glEndQuery = (PFNGLENDQUERYPROC) load(userptr, "glEndQuery");
glad_glGenBuffers = (PFNGLGENBUFFERSPROC) load(userptr, "glGenBuffers");
glad_glGenQueries = (PFNGLGENQUERIESPROC) load(userptr, "glGenQueries");
glad_glGetBufferParameteriv = (PFNGLGETBUFFERPARAMETERIVPROC) load(userptr, "glGetBufferParameteriv");
glad_glGetBufferPointerv = (PFNGLGETBUFFERPOINTERVPROC) load(userptr, "glGetBufferPointerv");
glad_glGetBufferSubData = (PFNGLGETBUFFERSUBDATAPROC) load(userptr, "glGetBufferSubData");
glad_glGetQueryObjectiv = (PFNGLGETQUERYOBJECTIVPROC) load(userptr, "glGetQueryObjectiv");
glad_glGetQueryObjectuiv = (PFNGLGETQUERYOBJECTUIVPROC) load(userptr, "glGetQueryObjectuiv");
glad_glGetQueryiv = (PFNGLGETQUERYIVPROC) load(userptr, "glGetQueryiv");
glad_glIsBuffer = (PFNGLISBUFFERPROC) load(userptr, "glIsBuffer");
glad_glIsQuery = (PFNGLISQUERYPROC) load(userptr, "glIsQuery");
glad_glMapBuffer = (PFNGLMAPBUFFERPROC) load(userptr, "glMapBuffer");
glad_glUnmapBuffer = (PFNGLUNMAPBUFFERPROC) load(userptr, "glUnmapBuffer");
}
static void glad_gl_load_GL_VERSION_2_0( GLADuserptrloadfunc load, void* userptr) {
if(!GLAD_GL_VERSION_2_0) return;
glad_glAttachShader = (PFNGLATTACHSHADERPROC) load(userptr, "glAttachShader");
glad_glBindAttribLocation = (PFNGLBINDATTRIBLOCATIONPROC) load(userptr, "glBindAttribLocation");
glad_glBlendEquationSeparate = (PFNGLBLENDEQUATIONSEPARATEPROC) load(userptr, "glBlendEquationSeparate");
glad_glCompileShader = (PFNGLCOMPILESHADERPROC) load(userptr, "glCompileShader");
glad_glCreateProgram = (PFNGLCREATEPROGRAMPROC) load(userptr, "glCreateProgram");
glad_glCreateShader = (PFNGLCREATESHADERPROC) load(userptr, "glCreateShader");
glad_glDeleteProgram = (PFNGLDELETEPROGRAMPROC) load(userptr, "glDeleteProgram");
glad_glDeleteShader = (PFNGLDELETESHADERPROC) load(userptr, "glDeleteShader");
glad_glDetachShader = (PFNGLDETACHSHADERPROC) load(userptr, "glDetachShader");
glad_glDisableVertexAttribArray = (PFNGLDISABLEVERTEXATTRIBARRAYPROC) load(userptr, "glDisableVertexAttribArray");
glad_glDrawBuffers = (PFNGLDRAWBUFFERSPROC) load(userptr, "glDrawBuffers");
glad_glEnableVertexAttribArray = (PFNGLENABLEVERTEXATTRIBARRAYPROC) load(userptr, "glEnableVertexAttribArray");
glad_glGetActiveAttrib = (PFNGLGETACTIVEATTRIBPROC) load(userptr, "glGetActiveAttrib");
glad_glGetActiveUniform = (PFNGLGETACTIVEUNIFORMPROC) load(userptr, "glGetActiveUniform");
glad_glGetAttachedShaders = (PFNGLGETATTACHEDSHADERSPROC) load(userptr, "glGetAttachedShaders");
glad_glGetAttribLocation = (PFNGLGETATTRIBLOCATIONPROC) load(userptr, "glGetAttribLocation");
glad_glGetProgramInfoLog = (PFNGLGETPROGRAMINFOLOGPROC) load(userptr, "glGetProgramInfoLog");
glad_glGetProgramiv = (PFNGLGETPROGRAMIVPROC) load(userptr, "glGetProgramiv");
glad_glGetShaderInfoLog = (PFNGLGETSHADERINFOLOGPROC) load(userptr, "glGetShaderInfoLog");
glad_glGetShaderSource = (PFNGLGETSHADERSOURCEPROC) load(userptr, "glGetShaderSource");
glad_glGetShaderiv = (PFNGLGETSHADERIVPROC) load(userptr, "glGetShaderiv");
glad_glGetUniformLocation = (PFNGLGETUNIFORMLOCATIONPROC) load(userptr, "glGetUniformLocation");
glad_glGetUniformfv = (PFNGLGETUNIFORMFVPROC) load(userptr, "glGetUniformfv");
glad_glGetUniformiv = (PFNGLGETUNIFORMIVPROC) load(userptr, "glGetUniformiv");
glad_glGetVertexAttribPointerv = (PFNGLGETVERTEXATTRIBPOINTERVPROC) load(userptr, "glGetVertexAttribPointerv");
glad_glGetVertexAttribdv = (PFNGLGETVERTEXATTRIBDVPROC) load(userptr, "glGetVertexAttribdv");
glad_glGetVertexAttribfv = (PFNGLGETVERTEXATTRIBFVPROC) load(userptr, "glGetVertexAttribfv");
glad_glGetVertexAttribiv = (PFNGLGETVERTEXATTRIBIVPROC) load(userptr, "glGetVertexAttribiv");
glad_glIsProgram = (PFNGLISPROGRAMPROC) load(userptr, "glIsProgram");
glad_glIsShader = (PFNGLISSHADERPROC) load(userptr, "glIsShader");
glad_glLinkProgram = (PFNGLLINKPROGRAMPROC) load(userptr, "glLinkProgram");
glad_glShaderSource = (PFNGLSHADERSOURCEPROC) load(userptr, "glShaderSource");
glad_glStencilFuncSeparate = (PFNGLSTENCILFUNCSEPARATEPROC) load(userptr, "glStencilFuncSeparate");
glad_glStencilMaskSeparate = (PFNGLSTENCILMASKSEPARATEPROC) load(userptr, "glStencilMaskSeparate");
glad_glStencilOpSeparate = (PFNGLSTENCILOPSEPARATEPROC) load(userptr, "glStencilOpSeparate");
glad_glUniform1f = (PFNGLUNIFORM1FPROC) load(userptr, "glUniform1f");
glad_glUniform1fv = (PFNGLUNIFORM1FVPROC) load(userptr, "glUniform1fv");
glad_glUniform1i = (PFNGLUNIFORM1IPROC) load(userptr, "glUniform1i");
glad_glUniform1iv = (PFNGLUNIFORM1IVPROC) load(userptr, "glUniform1iv");
glad_glUniform2f = (PFNGLUNIFORM2FPROC) load(userptr, "glUniform2f");
glad_glUniform2fv = (PFNGLUNIFORM2FVPROC) load(userptr, "glUniform2fv");
glad_glUniform2i = (PFNGLUNIFORM2IPROC) load(userptr, "glUniform2i");
glad_glUniform2iv = (PFNGLUNIFORM2IVPROC) load(userptr, "glUniform2iv");
glad_glUniform3f = (PFNGLUNIFORM3FPROC) load(userptr, "glUniform3f");
glad_glUniform3fv = (PFNGLUNIFORM3FVPROC) load(userptr, "glUniform3fv");
glad_glUniform3i = (PFNGLUNIFORM3IPROC) load(userptr, "glUniform3i");
glad_glUniform3iv = (PFNGLUNIFORM3IVPROC) load(userptr, "glUniform3iv");
glad_glUniform4f = (PFNGLUNIFORM4FPROC) load(userptr, "glUniform4f");
glad_glUniform4fv = (PFNGLUNIFORM4FVPROC) load(userptr, "glUniform4fv");
glad_glUniform4i = (PFNGLUNIFORM4IPROC) load(userptr, "glUniform4i");
glad_glUniform4iv = (PFNGLUNIFORM4IVPROC) load(userptr, "glUniform4iv");
glad_glUniformMatrix2fv = (PFNGLUNIFORMMATRIX2FVPROC) load(userptr, "glUniformMatrix2fv");
glad_glUniformMatrix3fv = (PFNGLUNIFORMMATRIX3FVPROC) load(userptr, "glUniformMatrix3fv");
glad_glUniformMatrix4fv = (PFNGLUNIFORMMATRIX4FVPROC) load(userptr, "glUniformMatrix4fv");
glad_glUseProgram = (PFNGLUSEPROGRAMPROC) load(userptr, "glUseProgram");
glad_glValidateProgram = (PFNGLVALIDATEPROGRAMPROC) load(userptr, "glValidateProgram");
glad_glVertexAttrib1d = (PFNGLVERTEXATTRIB1DPROC) load(userptr, "glVertexAttrib1d");
glad_glVertexAttrib1dv = (PFNGLVERTEXATTRIB1DVPROC) load(userptr, "glVertexAttrib1dv");
glad_glVertexAttrib1f = (PFNGLVERTEXATTRIB1FPROC) load(userptr, "glVertexAttrib1f");
glad_glVertexAttrib1fv = (PFNGLVERTEXATTRIB1FVPROC) load(userptr, "glVertexAttrib1fv");
glad_glVertexAttrib1s = (PFNGLVERTEXATTRIB1SPROC) load(userptr, "glVertexAttrib1s");
glad_glVertexAttrib1sv = (PFNGLVERTEXATTRIB1SVPROC) load(userptr, "glVertexAttrib1sv");
glad_glVertexAttrib2d = (PFNGLVERTEXATTRIB2DPROC) load(userptr, "glVertexAttrib2d");
glad_glVertexAttrib2dv = (PFNGLVERTEXATTRIB2DVPROC) load(userptr, "glVertexAttrib2dv");
glad_glVertexAttrib2f = (PFNGLVERTEXATTRIB2FPROC) load(userptr, "glVertexAttrib2f");
glad_glVertexAttrib2fv = (PFNGLVERTEXATTRIB2FVPROC) load(userptr, "glVertexAttrib2fv");
glad_glVertexAttrib2s = (PFNGLVERTEXATTRIB2SPROC) load(userptr, "glVertexAttrib2s");
glad_glVertexAttrib2sv = (PFNGLVERTEXATTRIB2SVPROC) load(userptr, "glVertexAttrib2sv");
glad_glVertexAttrib3d = (PFNGLVERTEXATTRIB3DPROC) load(userptr, "glVertexAttrib3d");
glad_glVertexAttrib3dv = (PFNGLVERTEXATTRIB3DVPROC) load(userptr, "glVertexAttrib3dv");
glad_glVertexAttrib3f = (PFNGLVERTEXATTRIB3FPROC) load(userptr, "glVertexAttrib3f");
glad_glVertexAttrib3fv = (PFNGLVERTEXATTRIB3FVPROC) load(userptr, "glVertexAttrib3fv");
glad_glVertexAttrib3s = (PFNGLVERTEXATTRIB3SPROC) load(userptr, "glVertexAttrib3s");
glad_glVertexAttrib3sv = (PFNGLVERTEXATTRIB3SVPROC) load(userptr, "glVertexAttrib3sv");
glad_glVertexAttrib4Nbv = (PFNGLVERTEXATTRIB4NBVPROC) load(userptr, "glVertexAttrib4Nbv");
glad_glVertexAttrib4Niv = (PFNGLVERTEXATTRIB4NIVPROC) load(userptr, "glVertexAttrib4Niv");
glad_glVertexAttrib4Nsv = (PFNGLVERTEXATTRIB4NSVPROC) load(userptr, "glVertexAttrib4Nsv");
glad_glVertexAttrib4Nub = (PFNGLVERTEXATTRIB4NUBPROC) load(userptr, "glVertexAttrib4Nub");
glad_glVertexAttrib4Nubv = (PFNGLVERTEXATTRIB4NUBVPROC) load(userptr, "glVertexAttrib4Nubv");
glad_glVertexAttrib4Nuiv = (PFNGLVERTEXATTRIB4NUIVPROC) load(userptr, "glVertexAttrib4Nuiv");
glad_glVertexAttrib4Nusv = (PFNGLVERTEXATTRIB4NUSVPROC) load(userptr, "glVertexAttrib4Nusv");
glad_glVertexAttrib4bv = (PFNGLVERTEXATTRIB4BVPROC) load(userptr, "glVertexAttrib4bv");
glad_glVertexAttrib4d = (PFNGLVERTEXATTRIB4DPROC) load(userptr, "glVertexAttrib4d");
glad_glVertexAttrib4dv = (PFNGLVERTEXATTRIB4DVPROC) load(userptr, "glVertexAttrib4dv");
glad_glVertexAttrib4f = (PFNGLVERTEXATTRIB4FPROC) load(userptr, "glVertexAttrib4f");
glad_glVertexAttrib4fv = (PFNGLVERTEXATTRIB4FVPROC) load(userptr, "glVertexAttrib4fv");
glad_glVertexAttrib4iv = (PFNGLVERTEXATTRIB4IVPROC) load(userptr, "glVertexAttrib4iv");
glad_glVertexAttrib4s = (PFNGLVERTEXATTRIB4SPROC) load(userptr, "glVertexAttrib4s");
glad_glVertexAttrib4sv = (PFNGLVERTEXATTRIB4SVPROC) load(userptr, "glVertexAttrib4sv");
glad_glVertexAttrib4ubv = (PFNGLVERTEXATTRIB4UBVPROC) load(userptr, "glVertexAttrib4ubv");
glad_glVertexAttrib4uiv = (PFNGLVERTEXATTRIB4UIVPROC) load(userptr, "glVertexAttrib4uiv");
glad_glVertexAttrib4usv = (PFNGLVERTEXATTRIB4USVPROC) load(userptr, "glVertexAttrib4usv");
glad_glVertexAttribPointer = (PFNGLVERTEXATTRIBPOINTERPROC) load(userptr, "glVertexAttribPointer");
}
static void glad_gl_load_GL_VERSION_2_1( GLADuserptrloadfunc load, void* userptr) {
if(!GLAD_GL_VERSION_2_1) return;
glad_glUniformMatrix2x3fv = (PFNGLUNIFORMMATRIX2X3FVPROC) load(userptr, "glUniformMatrix2x3fv");
glad_glUniformMatrix2x4fv = (PFNGLUNIFORMMATRIX2X4FVPROC) load(userptr, "glUniformMatrix2x4fv");
glad_glUniformMatrix3x2fv = (PFNGLUNIFORMMATRIX3X2FVPROC) load(userptr, "glUniformMatrix3x2fv");
glad_glUniformMatrix3x4fv = (PFNGLUNIFORMMATRIX3X4FVPROC) load(userptr, "glUniformMatrix3x4fv");
glad_glUniformMatrix4x2fv = (PFNGLUNIFORMMATRIX4X2FVPROC) load(userptr, "glUniformMatrix4x2fv");
glad_glUniformMatrix4x3fv = (PFNGLUNIFORMMATRIX4X3FVPROC) load(userptr, "glUniformMatrix4x3fv");
}
static void glad_gl_load_GL_VERSION_3_0( GLADuserptrloadfunc load, void* userptr) {
if(!GLAD_GL_VERSION_3_0) return;
glad_glBeginConditionalRender = (PFNGLBEGINCONDITIONALRENDERPROC) load(userptr, "glBeginConditionalRender");
glad_glBeginTransformFeedback = (PFNGLBEGINTRANSFORMFEEDBACKPROC) load(userptr, "glBeginTransformFeedback");
glad_glBindBufferBase = (PFNGLBINDBUFFERBASEPROC) load(userptr, "glBindBufferBase");
glad_glBindBufferRange = (PFNGLBINDBUFFERRANGEPROC) load(userptr, "glBindBufferRange");
glad_glBindFragDataLocation = (PFNGLBINDFRAGDATALOCATIONPROC) load(userptr, "glBindFragDataLocation");
glad_glBindFramebuffer = (PFNGLBINDFRAMEBUFFERPROC) load(userptr, "glBindFramebuffer");
glad_glBindRenderbuffer = (PFNGLBINDRENDERBUFFERPROC) load(userptr, "glBindRenderbuffer");
glad_glBindVertexArray = (PFNGLBINDVERTEXARRAYPROC) load(userptr, "glBindVertexArray");
glad_glBlitFramebuffer = (PFNGLBLITFRAMEBUFFERPROC) load(userptr, "glBlitFramebuffer");
glad_glCheckFramebufferStatus = (PFNGLCHECKFRAMEBUFFERSTATUSPROC) load(userptr, "glCheckFramebufferStatus");
glad_glClampColor = (PFNGLCLAMPCOLORPROC) load(userptr, "glClampColor");
glad_glClearBufferfi = (PFNGLCLEARBUFFERFIPROC) load(userptr, "glClearBufferfi");
glad_glClearBufferfv = (PFNGLCLEARBUFFERFVPROC) load(userptr, "glClearBufferfv");
glad_glClearBufferiv = (PFNGLCLEARBUFFERIVPROC) load(userptr, "glClearBufferiv");
glad_glClearBufferuiv = (PFNGLCLEARBUFFERUIVPROC) load(userptr, "glClearBufferuiv");
glad_glColorMaski = (PFNGLCOLORMASKIPROC) load(userptr, "glColorMaski");
glad_glDeleteFramebuffers = (PFNGLDELETEFRAMEBUFFERSPROC) load(userptr, "glDeleteFramebuffers");
glad_glDeleteRenderbuffers = (PFNGLDELETERENDERBUFFERSPROC) load(userptr, "glDeleteRenderbuffers");
glad_glDeleteVertexArrays = (PFNGLDELETEVERTEXARRAYSPROC) load(userptr, "glDeleteVertexArrays");
glad_glDisablei = (PFNGLDISABLEIPROC) load(userptr, "glDisablei");
glad_glEnablei = (PFNGLENABLEIPROC) load(userptr, "glEnablei");
glad_glEndConditionalRender = (PFNGLENDCONDITIONALRENDERPROC) load(userptr, "glEndConditionalRender");
glad_glEndTransformFeedback = (PFNGLENDTRANSFORMFEEDBACKPROC) load(userptr, "glEndTransformFeedback");
glad_glFlushMappedBufferRange = (PFNGLFLUSHMAPPEDBUFFERRANGEPROC) load(userptr, "glFlushMappedBufferRange");
glad_glFramebufferRenderbuffer = (PFNGLFRAMEBUFFERRENDERBUFFERPROC) load(userptr, "glFramebufferRenderbuffer");
glad_glFramebufferTexture1D = (PFNGLFRAMEBUFFERTEXTURE1DPROC) load(userptr, "glFramebufferTexture1D");
glad_glFramebufferTexture2D = (PFNGLFRAMEBUFFERTEXTURE2DPROC) load(userptr, "glFramebufferTexture2D");
glad_glFramebufferTexture3D = (PFNGLFRAMEBUFFERTEXTURE3DPROC) load(userptr, "glFramebufferTexture3D");
glad_glFramebufferTextureLayer = (PFNGLFRAMEBUFFERTEXTURELAYERPROC) load(userptr, "glFramebufferTextureLayer");
glad_glGenFramebuffers = (PFNGLGENFRAMEBUFFERSPROC) load(userptr, "glGenFramebuffers");
glad_glGenRenderbuffers = (PFNGLGENRENDERBUFFERSPROC) load(userptr, "glGenRenderbuffers");
glad_glGenVertexArrays = (PFNGLGENVERTEXARRAYSPROC) load(userptr, "glGenVertexArrays");
glad_glGenerateMipmap = (PFNGLGENERATEMIPMAPPROC) load(userptr, "glGenerateMipmap");
glad_glGetBooleani_v = (PFNGLGETBOOLEANI_VPROC) load(userptr, "glGetBooleani_v");
glad_glGetFragDataLocation = (PFNGLGETFRAGDATALOCATIONPROC) load(userptr, "glGetFragDataLocation");
glad_glGetFramebufferAttachmentParameteriv = (PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC) load(userptr, "glGetFramebufferAttachmentParameteriv");
glad_glGetIntegeri_v = (PFNGLGETINTEGERI_VPROC) load(userptr, "glGetIntegeri_v");
glad_glGetRenderbufferParameteriv = (PFNGLGETRENDERBUFFERPARAMETERIVPROC) load(userptr, "glGetRenderbufferParameteriv");
glad_glGetStringi = (PFNGLGETSTRINGIPROC) load(userptr, "glGetStringi");
glad_glGetTexParameterIiv = (PFNGLGETTEXPARAMETERIIVPROC) load(userptr, "glGetTexParameterIiv");
glad_glGetTexParameterIuiv = (PFNGLGETTEXPARAMETERIUIVPROC) load(userptr, "glGetTexParameterIuiv");
glad_glGetTransformFeedbackVarying = (PFNGLGETTRANSFORMFEEDBACKVARYINGPROC) load(userptr, "glGetTransformFeedbackVarying");
glad_glGetUniformuiv = (PFNGLGETUNIFORMUIVPROC) load(userptr, "glGetUniformuiv");
glad_glGetVertexAttribIiv = (PFNGLGETVERTEXATTRIBIIVPROC) load(userptr, "glGetVertexAttribIiv");
glad_glGetVertexAttribIuiv = (PFNGLGETVERTEXATTRIBIUIVPROC) load(userptr, "glGetVertexAttribIuiv");
glad_glIsEnabledi = (PFNGLISENABLEDIPROC) load(userptr, "glIsEnabledi");
glad_glIsFramebuffer = (PFNGLISFRAMEBUFFERPROC) load(userptr, "glIsFramebuffer");
glad_glIsRenderbuffer = (PFNGLISRENDERBUFFERPROC) load(userptr, "glIsRenderbuffer");
glad_glIsVertexArray = (PFNGLISVERTEXARRAYPROC) load(userptr, "glIsVertexArray");
glad_glMapBufferRange = (PFNGLMAPBUFFERRANGEPROC) load(userptr, "glMapBufferRange");
glad_glRenderbufferStorage = (PFNGLRENDERBUFFERSTORAGEPROC) load(userptr, "glRenderbufferStorage");
glad_glRenderbufferStorageMultisample = (PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC) load(userptr, "glRenderbufferStorageMultisample");
glad_glTexParameterIiv = (PFNGLTEXPARAMETERIIVPROC) load(userptr, "glTexParameterIiv");
glad_glTexParameterIuiv = (PFNGLTEXPARAMETERIUIVPROC) load(userptr, "glTexParameterIuiv");
glad_glTransformFeedbackVaryings = (PFNGLTRANSFORMFEEDBACKVARYINGSPROC) load(userptr, "glTransformFeedbackVaryings");
glad_glUniform1ui = (PFNGLUNIFORM1UIPROC) load(userptr, "glUniform1ui");
glad_glUniform1uiv = (PFNGLUNIFORM1UIVPROC) load(userptr, "glUniform1uiv");
glad_glUniform2ui = (PFNGLUNIFORM2UIPROC) load(userptr, "glUniform2ui");
glad_glUniform2uiv = (PFNGLUNIFORM2UIVPROC) load(userptr, "glUniform2uiv");
glad_glUniform3ui = (PFNGLUNIFORM3UIPROC) load(userptr, "glUniform3ui");
glad_glUniform3uiv = (PFNGLUNIFORM3UIVPROC) load(userptr, "glUniform3uiv");
glad_glUniform4ui = (PFNGLUNIFORM4UIPROC) load(userptr, "glUniform4ui");
glad_glUniform4uiv = (PFNGLUNIFORM4UIVPROC) load(userptr, "glUniform4uiv");
glad_glVertexAttribI1i = (PFNGLVERTEXATTRIBI1IPROC) load(userptr, "glVertexAttribI1i");
glad_glVertexAttribI1iv = (PFNGLVERTEXATTRIBI1IVPROC) load(userptr, "glVertexAttribI1iv");
glad_glVertexAttribI1ui = (PFNGLVERTEXATTRIBI1UIPROC) load(userptr, "glVertexAttribI1ui");
glad_glVertexAttribI1uiv = (PFNGLVERTEXATTRIBI1UIVPROC) load(userptr, "glVertexAttribI1uiv");
glad_glVertexAttribI2i = (PFNGLVERTEXATTRIBI2IPROC) load(userptr, "glVertexAttribI2i");
glad_glVertexAttribI2iv = (PFNGLVERTEXATTRIBI2IVPROC) load(userptr, "glVertexAttribI2iv");
glad_glVertexAttribI2ui = (PFNGLVERTEXATTRIBI2UIPROC) load(userptr, "glVertexAttribI2ui");
glad_glVertexAttribI2uiv = (PFNGLVERTEXATTRIBI2UIVPROC) load(userptr, "glVertexAttribI2uiv");
glad_glVertexAttribI3i = (PFNGLVERTEXATTRIBI3IPROC) load(userptr, "glVertexAttribI3i");
glad_glVertexAttribI3iv = (PFNGLVERTEXATTRIBI3IVPROC) load(userptr, "glVertexAttribI3iv");
glad_glVertexAttribI3ui = (PFNGLVERTEXATTRIBI3UIPROC) load(userptr, "glVertexAttribI3ui");
glad_glVertexAttribI3uiv = (PFNGLVERTEXATTRIBI3UIVPROC) load(userptr, "glVertexAttribI3uiv");
glad_glVertexAttribI4bv = (PFNGLVERTEXATTRIBI4BVPROC) load(userptr, "glVertexAttribI4bv");
glad_glVertexAttribI4i = (PFNGLVERTEXATTRIBI4IPROC) load(userptr, "glVertexAttribI4i");
glad_glVertexAttribI4iv = (PFNGLVERTEXATTRIBI4IVPROC) load(userptr, "glVertexAttribI4iv");
glad_glVertexAttribI4sv = (PFNGLVERTEXATTRIBI4SVPROC) load(userptr, "glVertexAttribI4sv");
glad_glVertexAttribI4ubv = (PFNGLVERTEXATTRIBI4UBVPROC) load(userptr, "glVertexAttribI4ubv");
glad_glVertexAttribI4ui = (PFNGLVERTEXATTRIBI4UIPROC) load(userptr, "glVertexAttribI4ui");
glad_glVertexAttribI4uiv = (PFNGLVERTEXATTRIBI4UIVPROC) load(userptr, "glVertexAttribI4uiv");
glad_glVertexAttribI4usv = (PFNGLVERTEXATTRIBI4USVPROC) load(userptr, "glVertexAttribI4usv");
glad_glVertexAttribIPointer = (PFNGLVERTEXATTRIBIPOINTERPROC) load(userptr, "glVertexAttribIPointer");
}
static void glad_gl_load_GL_VERSION_3_1( GLADuserptrloadfunc load, void* userptr) {
if(!GLAD_GL_VERSION_3_1) return;
glad_glBindBufferBase = (PFNGLBINDBUFFERBASEPROC) load(userptr, "glBindBufferBase");
glad_glBindBufferRange = (PFNGLBINDBUFFERRANGEPROC) load(userptr, "glBindBufferRange");
glad_glCopyBufferSubData = (PFNGLCOPYBUFFERSUBDATAPROC) load(userptr, "glCopyBufferSubData");
glad_glDrawArraysInstanced = (PFNGLDRAWARRAYSINSTANCEDPROC) load(userptr, "glDrawArraysInstanced");
glad_glDrawElementsInstanced = (PFNGLDRAWELEMENTSINSTANCEDPROC) load(userptr, "glDrawElementsInstanced");
glad_glGetActiveUniformBlockName = (PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC) load(userptr, "glGetActiveUniformBlockName");
glad_glGetActiveUniformBlockiv = (PFNGLGETACTIVEUNIFORMBLOCKIVPROC) load(userptr, "glGetActiveUniformBlockiv");
glad_glGetActiveUniformName = (PFNGLGETACTIVEUNIFORMNAMEPROC) load(userptr, "glGetActiveUniformName");
glad_glGetActiveUniformsiv = (PFNGLGETACTIVEUNIFORMSIVPROC) load(userptr, "glGetActiveUniformsiv");
glad_glGetIntegeri_v = (PFNGLGETINTEGERI_VPROC) load(userptr, "glGetIntegeri_v");
glad_glGetUniformBlockIndex = (PFNGLGETUNIFORMBLOCKINDEXPROC) load(userptr, "glGetUniformBlockIndex");
glad_glGetUniformIndices = (PFNGLGETUNIFORMINDICESPROC) load(userptr, "glGetUniformIndices");
glad_glPrimitiveRestartIndex = (PFNGLPRIMITIVERESTARTINDEXPROC) load(userptr, "glPrimitiveRestartIndex");
glad_glTexBuffer = (PFNGLTEXBUFFERPROC) load(userptr, "glTexBuffer");
glad_glUniformBlockBinding = (PFNGLUNIFORMBLOCKBINDINGPROC) load(userptr, "glUniformBlockBinding");
}
static void glad_gl_load_GL_VERSION_3_2( GLADuserptrloadfunc load, void* userptr) {
if(!GLAD_GL_VERSION_3_2) return;
glad_glClientWaitSync = (PFNGLCLIENTWAITSYNCPROC) load(userptr, "glClientWaitSync");
glad_glDeleteSync = (PFNGLDELETESYNCPROC) load(userptr, "glDeleteSync");
glad_glDrawElementsBaseVertex = (PFNGLDRAWELEMENTSBASEVERTEXPROC) load(userptr, "glDrawElementsBaseVertex");
glad_glDrawElementsInstancedBaseVertex = (PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC) load(userptr, "glDrawElementsInstancedBaseVertex");
glad_glDrawRangeElementsBaseVertex = (PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC) load(userptr, "glDrawRangeElementsBaseVertex");
glad_glFenceSync = (PFNGLFENCESYNCPROC) load(userptr, "glFenceSync");
glad_glFramebufferTexture = (PFNGLFRAMEBUFFERTEXTUREPROC) load(userptr, "glFramebufferTexture");
glad_glGetBufferParameteri64v = (PFNGLGETBUFFERPARAMETERI64VPROC) load(userptr, "glGetBufferParameteri64v");
glad_glGetInteger64i_v = (PFNGLGETINTEGER64I_VPROC) load(userptr, "glGetInteger64i_v");
glad_glGetInteger64v = (PFNGLGETINTEGER64VPROC) load(userptr, "glGetInteger64v");
glad_glGetMultisamplefv = (PFNGLGETMULTISAMPLEFVPROC) load(userptr, "glGetMultisamplefv");
glad_glGetSynciv = (PFNGLGETSYNCIVPROC) load(userptr, "glGetSynciv");
glad_glIsSync = (PFNGLISSYNCPROC) load(userptr, "glIsSync");
glad_glMultiDrawElementsBaseVertex = (PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC) load(userptr, "glMultiDrawElementsBaseVertex");
glad_glProvokingVertex = (PFNGLPROVOKINGVERTEXPROC) load(userptr, "glProvokingVertex");
glad_glSampleMaski = (PFNGLSAMPLEMASKIPROC) load(userptr, "glSampleMaski");
glad_glTexImage2DMultisample = (PFNGLTEXIMAGE2DMULTISAMPLEPROC) load(userptr, "glTexImage2DMultisample");
glad_glTexImage3DMultisample = (PFNGLTEXIMAGE3DMULTISAMPLEPROC) load(userptr, "glTexImage3DMultisample");
glad_glWaitSync = (PFNGLWAITSYNCPROC) load(userptr, "glWaitSync");
}
static void glad_gl_load_GL_VERSION_3_3( GLADuserptrloadfunc load, void* userptr) {
if(!GLAD_GL_VERSION_3_3) return;
glad_glBindFragDataLocationIndexed = (PFNGLBINDFRAGDATALOCATIONINDEXEDPROC) load(userptr, "glBindFragDataLocationIndexed");
glad_glBindSampler = (PFNGLBINDSAMPLERPROC) load(userptr, "glBindSampler");
glad_glColorP3ui = (PFNGLCOLORP3UIPROC) load(userptr, "glColorP3ui");
glad_glColorP3uiv = (PFNGLCOLORP3UIVPROC) load(userptr, "glColorP3uiv");
glad_glColorP4ui = (PFNGLCOLORP4UIPROC) load(userptr, "glColorP4ui");
glad_glColorP4uiv = (PFNGLCOLORP4UIVPROC) load(userptr, "glColorP4uiv");
glad_glDeleteSamplers = (PFNGLDELETESAMPLERSPROC) load(userptr, "glDeleteSamplers");
glad_glGenSamplers = (PFNGLGENSAMPLERSPROC) load(userptr, "glGenSamplers");
glad_glGetFragDataIndex = (PFNGLGETFRAGDATAINDEXPROC) load(userptr, "glGetFragDataIndex");
glad_glGetQueryObjecti64v = (PFNGLGETQUERYOBJECTI64VPROC) load(userptr, "glGetQueryObjecti64v");
glad_glGetQueryObjectui64v = (PFNGLGETQUERYOBJECTUI64VPROC) load(userptr, "glGetQueryObjectui64v");
glad_glGetSamplerParameterIiv = (PFNGLGETSAMPLERPARAMETERIIVPROC) load(userptr, "glGetSamplerParameterIiv");
glad_glGetSamplerParameterIuiv = (PFNGLGETSAMPLERPARAMETERIUIVPROC) load(userptr, "glGetSamplerParameterIuiv");
glad_glGetSamplerParameterfv = (PFNGLGETSAMPLERPARAMETERFVPROC) load(userptr, "glGetSamplerParameterfv");
glad_glGetSamplerParameteriv = (PFNGLGETSAMPLERPARAMETERIVPROC) load(userptr, "glGetSamplerParameteriv");
glad_glIsSampler = (PFNGLISSAMPLERPROC) load(userptr, "glIsSampler");
glad_glMultiTexCoordP1ui = (PFNGLMULTITEXCOORDP1UIPROC) load(userptr, "glMultiTexCoordP1ui");
glad_glMultiTexCoordP1uiv = (PFNGLMULTITEXCOORDP1UIVPROC) load(userptr, "glMultiTexCoordP1uiv");
glad_glMultiTexCoordP2ui = (PFNGLMULTITEXCOORDP2UIPROC) load(userptr, "glMultiTexCoordP2ui");
glad_glMultiTexCoordP2uiv = (PFNGLMULTITEXCOORDP2UIVPROC) load(userptr, "glMultiTexCoordP2uiv");
glad_glMultiTexCoordP3ui = (PFNGLMULTITEXCOORDP3UIPROC) load(userptr, "glMultiTexCoordP3ui");
glad_glMultiTexCoordP3uiv = (PFNGLMULTITEXCOORDP3UIVPROC) load(userptr, "glMultiTexCoordP3uiv");
glad_glMultiTexCoordP4ui = (PFNGLMULTITEXCOORDP4UIPROC) load(userptr, "glMultiTexCoordP4ui");
glad_glMultiTexCoordP4uiv = (PFNGLMULTITEXCOORDP4UIVPROC) load(userptr, "glMultiTexCoordP4uiv");
glad_glNormalP3ui = (PFNGLNORMALP3UIPROC) load(userptr, "glNormalP3ui");
glad_glNormalP3uiv = (PFNGLNORMALP3UIVPROC) load(userptr, "glNormalP3uiv");
glad_glQueryCounter = (PFNGLQUERYCOUNTERPROC) load(userptr, "glQueryCounter");
glad_glSamplerParameterIiv = (PFNGLSAMPLERPARAMETERIIVPROC) load(userptr, "glSamplerParameterIiv");
glad_glSamplerParameterIuiv = (PFNGLSAMPLERPARAMETERIUIVPROC) load(userptr, "glSamplerParameterIuiv");
glad_glSamplerParameterf = (PFNGLSAMPLERPARAMETERFPROC) load(userptr, "glSamplerParameterf");
glad_glSamplerParameterfv = (PFNGLSAMPLERPARAMETERFVPROC) load(userptr, "glSamplerParameterfv");
glad_glSamplerParameteri = (PFNGLSAMPLERPARAMETERIPROC) load(userptr, "glSamplerParameteri");
glad_glSamplerParameteriv = (PFNGLSAMPLERPARAMETERIVPROC) load(userptr, "glSamplerParameteriv");
glad_glSecondaryColorP3ui = (PFNGLSECONDARYCOLORP3UIPROC) load(userptr, "glSecondaryColorP3ui");
glad_glSecondaryColorP3uiv = (PFNGLSECONDARYCOLORP3UIVPROC) load(userptr, "glSecondaryColorP3uiv");
glad_glTexCoordP1ui = (PFNGLTEXCOORDP1UIPROC) load(userptr, "glTexCoordP1ui");
glad_glTexCoordP1uiv = (PFNGLTEXCOORDP1UIVPROC) load(userptr, "glTexCoordP1uiv");
glad_glTexCoordP2ui = (PFNGLTEXCOORDP2UIPROC) load(userptr, "glTexCoordP2ui");
glad_glTexCoordP2uiv = (PFNGLTEXCOORDP2UIVPROC) load(userptr, "glTexCoordP2uiv");
glad_glTexCoordP3ui = (PFNGLTEXCOORDP3UIPROC) load(userptr, "glTexCoordP3ui");
glad_glTexCoordP3uiv = (PFNGLTEXCOORDP3UIVPROC) load(userptr, "glTexCoordP3uiv");
glad_glTexCoordP4ui = (PFNGLTEXCOORDP4UIPROC) load(userptr, "glTexCoordP4ui");
glad_glTexCoordP4uiv = (PFNGLTEXCOORDP4UIVPROC) load(userptr, "glTexCoordP4uiv");
glad_glVertexAttribDivisor = (PFNGLVERTEXATTRIBDIVISORPROC) load(userptr, "glVertexAttribDivisor");
glad_glVertexAttribP1ui = (PFNGLVERTEXATTRIBP1UIPROC) load(userptr, "glVertexAttribP1ui");
glad_glVertexAttribP1uiv = (PFNGLVERTEXATTRIBP1UIVPROC) load(userptr, "glVertexAttribP1uiv");
glad_glVertexAttribP2ui = (PFNGLVERTEXATTRIBP2UIPROC) load(userptr, "glVertexAttribP2ui");
glad_glVertexAttribP2uiv = (PFNGLVERTEXATTRIBP2UIVPROC) load(userptr, "glVertexAttribP2uiv");
glad_glVertexAttribP3ui = (PFNGLVERTEXATTRIBP3UIPROC) load(userptr, "glVertexAttribP3ui");
glad_glVertexAttribP3uiv = (PFNGLVERTEXATTRIBP3UIVPROC) load(userptr, "glVertexAttribP3uiv");
glad_glVertexAttribP4ui = (PFNGLVERTEXATTRIBP4UIPROC) load(userptr, "glVertexAttribP4ui");
glad_glVertexAttribP4uiv = (PFNGLVERTEXATTRIBP4UIVPROC) load(userptr, "glVertexAttribP4uiv");
glad_glVertexP2ui = (PFNGLVERTEXP2UIPROC) load(userptr, "glVertexP2ui");
glad_glVertexP2uiv = (PFNGLVERTEXP2UIVPROC) load(userptr, "glVertexP2uiv");
glad_glVertexP3ui = (PFNGLVERTEXP3UIPROC) load(userptr, "glVertexP3ui");
glad_glVertexP3uiv = (PFNGLVERTEXP3UIVPROC) load(userptr, "glVertexP3uiv");
glad_glVertexP4ui = (PFNGLVERTEXP4UIPROC) load(userptr, "glVertexP4ui");
glad_glVertexP4uiv = (PFNGLVERTEXP4UIVPROC) load(userptr, "glVertexP4uiv");
}
static void glad_gl_load_GL_VERSION_4_0( GLADuserptrloadfunc load, void* userptr) {
if(!GLAD_GL_VERSION_4_0) return;
glad_glBeginQueryIndexed = (PFNGLBEGINQUERYINDEXEDPROC) load(userptr, "glBeginQueryIndexed");
glad_glBindTransformFeedback = (PFNGLBINDTRANSFORMFEEDBACKPROC) load(userptr, "glBindTransformFeedback");
glad_glBlendEquationSeparatei = (PFNGLBLENDEQUATIONSEPARATEIPROC) load(userptr, "glBlendEquationSeparatei");
glad_glBlendEquationi = (PFNGLBLENDEQUATIONIPROC) load(userptr, "glBlendEquationi");
glad_glBlendFuncSeparatei = (PFNGLBLENDFUNCSEPARATEIPROC) load(userptr, "glBlendFuncSeparatei");
glad_glBlendFunci = (PFNGLBLENDFUNCIPROC) load(userptr, "glBlendFunci");
glad_glDeleteTransformFeedbacks = (PFNGLDELETETRANSFORMFEEDBACKSPROC) load(userptr, "glDeleteTransformFeedbacks");
glad_glDrawArraysIndirect = (PFNGLDRAWARRAYSINDIRECTPROC) load(userptr, "glDrawArraysIndirect");
glad_glDrawElementsIndirect = (PFNGLDRAWELEMENTSINDIRECTPROC) load(userptr, "glDrawElementsIndirect");
glad_glDrawTransformFeedback = (PFNGLDRAWTRANSFORMFEEDBACKPROC) load(userptr, "glDrawTransformFeedback");
glad_glDrawTransformFeedbackStream = (PFNGLDRAWTRANSFORMFEEDBACKSTREAMPROC) load(userptr, "glDrawTransformFeedbackStream");
glad_glEndQueryIndexed = (PFNGLENDQUERYINDEXEDPROC) load(userptr, "glEndQueryIndexed");
glad_glGenTransformFeedbacks = (PFNGLGENTRANSFORMFEEDBACKSPROC) load(userptr, "glGenTransformFeedbacks");
glad_glGetActiveSubroutineName = (PFNGLGETACTIVESUBROUTINENAMEPROC) load(userptr, "glGetActiveSubroutineName");
glad_glGetActiveSubroutineUniformName = (PFNGLGETACTIVESUBROUTINEUNIFORMNAMEPROC) load(userptr, "glGetActiveSubroutineUniformName");
glad_glGetActiveSubroutineUniformiv = (PFNGLGETACTIVESUBROUTINEUNIFORMIVPROC) load(userptr, "glGetActiveSubroutineUniformiv");
glad_glGetProgramStageiv = (PFNGLGETPROGRAMSTAGEIVPROC) load(userptr, "glGetProgramStageiv");
glad_glGetQueryIndexediv = (PFNGLGETQUERYINDEXEDIVPROC) load(userptr, "glGetQueryIndexediv");
glad_glGetSubroutineIndex = (PFNGLGETSUBROUTINEINDEXPROC) load(userptr, "glGetSubroutineIndex");
glad_glGetSubroutineUniformLocation = (PFNGLGETSUBROUTINEUNIFORMLOCATIONPROC) load(userptr, "glGetSubroutineUniformLocation");
glad_glGetUniformSubroutineuiv = (PFNGLGETUNIFORMSUBROUTINEUIVPROC) load(userptr, "glGetUniformSubroutineuiv");
glad_glGetUniformdv = (PFNGLGETUNIFORMDVPROC) load(userptr, "glGetUniformdv");
glad_glIsTransformFeedback = (PFNGLISTRANSFORMFEEDBACKPROC) load(userptr, "glIsTransformFeedback");
glad_glMinSampleShading = (PFNGLMINSAMPLESHADINGPROC) load(userptr, "glMinSampleShading");
glad_glPatchParameterfv = (PFNGLPATCHPARAMETERFVPROC) load(userptr, "glPatchParameterfv");
glad_glPatchParameteri = (PFNGLPATCHPARAMETERIPROC) load(userptr, "glPatchParameteri");
glad_glPauseTransformFeedback = (PFNGLPAUSETRANSFORMFEEDBACKPROC) load(userptr, "glPauseTransformFeedback");
glad_glResumeTransformFeedback = (PFNGLRESUMETRANSFORMFEEDBACKPROC) load(userptr, "glResumeTransformFeedback");
glad_glUniform1d = (PFNGLUNIFORM1DPROC) load(userptr, "glUniform1d");
glad_glUniform1dv = (PFNGLUNIFORM1DVPROC) load(userptr, "glUniform1dv");
glad_glUniform2d = (PFNGLUNIFORM2DPROC) load(userptr, "glUniform2d");
glad_glUniform2dv = (PFNGLUNIFORM2DVPROC) load(userptr, "glUniform2dv");
glad_glUniform3d = (PFNGLUNIFORM3DPROC) load(userptr, "glUniform3d");
glad_glUniform3dv = (PFNGLUNIFORM3DVPROC) load(userptr, "glUniform3dv");
glad_glUniform4d = (PFNGLUNIFORM4DPROC) load(userptr, "glUniform4d");
glad_glUniform4dv = (PFNGLUNIFORM4DVPROC) load(userptr, "glUniform4dv");
glad_glUniformMatrix2dv = (PFNGLUNIFORMMATRIX2DVPROC) load(userptr, "glUniformMatrix2dv");
glad_glUniformMatrix2x3dv = (PFNGLUNIFORMMATRIX2X3DVPROC) load(userptr, "glUniformMatrix2x3dv");
glad_glUniformMatrix2x4dv = (PFNGLUNIFORMMATRIX2X4DVPROC) load(userptr, "glUniformMatrix2x4dv");
glad_glUniformMatrix3dv = (PFNGLUNIFORMMATRIX3DVPROC) load(userptr, "glUniformMatrix3dv");
glad_glUniformMatrix3x2dv = (PFNGLUNIFORMMATRIX3X2DVPROC) load(userptr, "glUniformMatrix3x2dv");
glad_glUniformMatrix3x4dv = (PFNGLUNIFORMMATRIX3X4DVPROC) load(userptr, "glUniformMatrix3x4dv");
glad_glUniformMatrix4dv = (PFNGLUNIFORMMATRIX4DVPROC) load(userptr, "glUniformMatrix4dv");
glad_glUniformMatrix4x2dv = (PFNGLUNIFORMMATRIX4X2DVPROC) load(userptr, "glUniformMatrix4x2dv");
glad_glUniformMatrix4x3dv = (PFNGLUNIFORMMATRIX4X3DVPROC) load(userptr, "glUniformMatrix4x3dv");
glad_glUniformSubroutinesuiv = (PFNGLUNIFORMSUBROUTINESUIVPROC) load(userptr, "glUniformSubroutinesuiv");
}
static void glad_gl_load_GL_VERSION_4_1( GLADuserptrloadfunc load, void* userptr) {
if(!GLAD_GL_VERSION_4_1) return;
glad_glActiveShaderProgram = (PFNGLACTIVESHADERPROGRAMPROC) load(userptr, "glActiveShaderProgram");
glad_glBindProgramPipeline = (PFNGLBINDPROGRAMPIPELINEPROC) load(userptr, "glBindProgramPipeline");
glad_glClearDepthf = (PFNGLCLEARDEPTHFPROC) load(userptr, "glClearDepthf");
glad_glCreateShaderProgramv = (PFNGLCREATESHADERPROGRAMVPROC) load(userptr, "glCreateShaderProgramv");
glad_glDeleteProgramPipelines = (PFNGLDELETEPROGRAMPIPELINESPROC) load(userptr, "glDeleteProgramPipelines");
glad_glDepthRangeArrayv = (PFNGLDEPTHRANGEARRAYVPROC) load(userptr, "glDepthRangeArrayv");
glad_glDepthRangeIndexed = (PFNGLDEPTHRANGEINDEXEDPROC) load(userptr, "glDepthRangeIndexed");
glad_glDepthRangef = (PFNGLDEPTHRANGEFPROC) load(userptr, "glDepthRangef");
glad_glGenProgramPipelines = (PFNGLGENPROGRAMPIPELINESPROC) load(userptr, "glGenProgramPipelines");
glad_glGetDoublei_v = (PFNGLGETDOUBLEI_VPROC) load(userptr, "glGetDoublei_v");
glad_glGetFloati_v = (PFNGLGETFLOATI_VPROC) load(userptr, "glGetFloati_v");
glad_glGetProgramBinary = (PFNGLGETPROGRAMBINARYPROC) load(userptr, "glGetProgramBinary");
glad_glGetProgramPipelineInfoLog = (PFNGLGETPROGRAMPIPELINEINFOLOGPROC) load(userptr, "glGetProgramPipelineInfoLog");
glad_glGetProgramPipelineiv = (PFNGLGETPROGRAMPIPELINEIVPROC) load(userptr, "glGetProgramPipelineiv");
glad_glGetShaderPrecisionFormat = (PFNGLGETSHADERPRECISIONFORMATPROC) load(userptr, "glGetShaderPrecisionFormat");
glad_glGetVertexAttribLdv = (PFNGLGETVERTEXATTRIBLDVPROC) load(userptr, "glGetVertexAttribLdv");
glad_glIsProgramPipeline = (PFNGLISPROGRAMPIPELINEPROC) load(userptr, "glIsProgramPipeline");
glad_glProgramBinary = (PFNGLPROGRAMBINARYPROC) load(userptr, "glProgramBinary");
glad_glProgramParameteri = (PFNGLPROGRAMPARAMETERIPROC) load(userptr, "glProgramParameteri");
glad_glProgramUniform1d = (PFNGLPROGRAMUNIFORM1DPROC) load(userptr, "glProgramUniform1d");
glad_glProgramUniform1dv = (PFNGLPROGRAMUNIFORM1DVPROC) load(userptr, "glProgramUniform1dv");
glad_glProgramUniform1f = (PFNGLPROGRAMUNIFORM1FPROC) load(userptr, "glProgramUniform1f");
glad_glProgramUniform1fv = (PFNGLPROGRAMUNIFORM1FVPROC) load(userptr, "glProgramUniform1fv");
glad_glProgramUniform1i = (PFNGLPROGRAMUNIFORM1IPROC) load(userptr, "glProgramUniform1i");
glad_glProgramUniform1iv = (PFNGLPROGRAMUNIFORM1IVPROC) load(userptr, "glProgramUniform1iv");
glad_glProgramUniform1ui = (PFNGLPROGRAMUNIFORM1UIPROC) load(userptr, "glProgramUniform1ui");
glad_glProgramUniform1uiv = (PFNGLPROGRAMUNIFORM1UIVPROC) load(userptr, "glProgramUniform1uiv");
glad_glProgramUniform2d = (PFNGLPROGRAMUNIFORM2DPROC) load(userptr, "glProgramUniform2d");
glad_glProgramUniform2dv = (PFNGLPROGRAMUNIFORM2DVPROC) load(userptr, "glProgramUniform2dv");
glad_glProgramUniform2f = (PFNGLPROGRAMUNIFORM2FPROC) load(userptr, "glProgramUniform2f");
glad_glProgramUniform2fv = (PFNGLPROGRAMUNIFORM2FVPROC) load(userptr, "glProgramUniform2fv");
glad_glProgramUniform2i = (PFNGLPROGRAMUNIFORM2IPROC) load(userptr, "glProgramUniform2i");
glad_glProgramUniform2iv = (PFNGLPROGRAMUNIFORM2IVPROC) load(userptr, "glProgramUniform2iv");
glad_glProgramUniform2ui = (PFNGLPROGRAMUNIFORM2UIPROC) load(userptr, "glProgramUniform2ui");
glad_glProgramUniform2uiv = (PFNGLPROGRAMUNIFORM2UIVPROC) load(userptr, "glProgramUniform2uiv");
glad_glProgramUniform3d = (PFNGLPROGRAMUNIFORM3DPROC) load(userptr, "glProgramUniform3d");
glad_glProgramUniform3dv = (PFNGLPROGRAMUNIFORM3DVPROC) load(userptr, "glProgramUniform3dv");
glad_glProgramUniform3f = (PFNGLPROGRAMUNIFORM3FPROC) load(userptr, "glProgramUniform3f");
glad_glProgramUniform3fv = (PFNGLPROGRAMUNIFORM3FVPROC) load(userptr, "glProgramUniform3fv");
glad_glProgramUniform3i = (PFNGLPROGRAMUNIFORM3IPROC) load(userptr, "glProgramUniform3i");
glad_glProgramUniform3iv = (PFNGLPROGRAMUNIFORM3IVPROC) load(userptr, "glProgramUniform3iv");
glad_glProgramUniform3ui = (PFNGLPROGRAMUNIFORM3UIPROC) load(userptr, "glProgramUniform3ui");
glad_glProgramUniform3uiv = (PFNGLPROGRAMUNIFORM3UIVPROC) load(userptr, "glProgramUniform3uiv");
glad_glProgramUniform4d = (PFNGLPROGRAMUNIFORM4DPROC) load(userptr, "glProgramUniform4d");
glad_glProgramUniform4dv = (PFNGLPROGRAMUNIFORM4DVPROC) load(userptr, "glProgramUniform4dv");
glad_glProgramUniform4f = (PFNGLPROGRAMUNIFORM4FPROC) load(userptr, "glProgramUniform4f");
glad_glProgramUniform4fv = (PFNGLPROGRAMUNIFORM4FVPROC) load(userptr, "glProgramUniform4fv");
glad_glProgramUniform4i = (PFNGLPROGRAMUNIFORM4IPROC) load(userptr, "glProgramUniform4i");
glad_glProgramUniform4iv = (PFNGLPROGRAMUNIFORM4IVPROC) load(userptr, "glProgramUniform4iv");
glad_glProgramUniform4ui = (PFNGLPROGRAMUNIFORM4UIPROC) load(userptr, "glProgramUniform4ui");
glad_glProgramUniform4uiv = (PFNGLPROGRAMUNIFORM4UIVPROC) load(userptr, "glProgramUniform4uiv");
glad_glProgramUniformMatrix2dv = (PFNGLPROGRAMUNIFORMMATRIX2DVPROC) load(userptr, "glProgramUniformMatrix2dv");
glad_glProgramUniformMatrix2fv = (PFNGLPROGRAMUNIFORMMATRIX2FVPROC) load(userptr, "glProgramUniformMatrix2fv");
glad_glProgramUniformMatrix2x3dv = (PFNGLPROGRAMUNIFORMMATRIX2X3DVPROC) load(userptr, "glProgramUniformMatrix2x3dv");
glad_glProgramUniformMatrix2x3fv = (PFNGLPROGRAMUNIFORMMATRIX2X3FVPROC) load(userptr, "glProgramUniformMatrix2x3fv");
glad_glProgramUniformMatrix2x4dv = (PFNGLPROGRAMUNIFORMMATRIX2X4DVPROC) load(userptr, "glProgramUniformMatrix2x4dv");
glad_glProgramUniformMatrix2x4fv = (PFNGLPROGRAMUNIFORMMATRIX2X4FVPROC) load(userptr, "glProgramUniformMatrix2x4fv");
glad_glProgramUniformMatrix3dv = (PFNGLPROGRAMUNIFORMMATRIX3DVPROC) load(userptr, "glProgramUniformMatrix3dv");
glad_glProgramUniformMatrix3fv = (PFNGLPROGRAMUNIFORMMATRIX3FVPROC) load(userptr, "glProgramUniformMatrix3fv");
glad_glProgramUniformMatrix3x2dv = (PFNGLPROGRAMUNIFORMMATRIX3X2DVPROC) load(userptr, "glProgramUniformMatrix3x2dv");
glad_glProgramUniformMatrix3x2fv = (PFNGLPROGRAMUNIFORMMATRIX3X2FVPROC) load(userptr, "glProgramUniformMatrix3x2fv");
glad_glProgramUniformMatrix3x4dv = (PFNGLPROGRAMUNIFORMMATRIX3X4DVPROC) load(userptr, "glProgramUniformMatrix3x4dv");
glad_glProgramUniformMatrix3x4fv = (PFNGLPROGRAMUNIFORMMATRIX3X4FVPROC) load(userptr, "glProgramUniformMatrix3x4fv");
glad_glProgramUniformMatrix4dv = (PFNGLPROGRAMUNIFORMMATRIX4DVPROC) load(userptr, "glProgramUniformMatrix4dv");
glad_glProgramUniformMatrix4fv = (PFNGLPROGRAMUNIFORMMATRIX4FVPROC) load(userptr, "glProgramUniformMatrix4fv");
glad_glProgramUniformMatrix4x2dv = (PFNGLPROGRAMUNIFORMMATRIX4X2DVPROC) load(userptr, "glProgramUniformMatrix4x2dv");
glad_glProgramUniformMatrix4x2fv = (PFNGLPROGRAMUNIFORMMATRIX4X2FVPROC) load(userptr, "glProgramUniformMatrix4x2fv");
glad_glProgramUniformMatrix4x3dv = (PFNGLPROGRAMUNIFORMMATRIX4X3DVPROC) load(userptr, "glProgramUniformMatrix4x3dv");
glad_glProgramUniformMatrix4x3fv = (PFNGLPROGRAMUNIFORMMATRIX4X3FVPROC) load(userptr, "glProgramUniformMatrix4x3fv");
glad_glReleaseShaderCompiler = (PFNGLRELEASESHADERCOMPILERPROC) load(userptr, "glReleaseShaderCompiler");
glad_glScissorArrayv = (PFNGLSCISSORARRAYVPROC) load(userptr, "glScissorArrayv");
glad_glScissorIndexed = (PFNGLSCISSORINDEXEDPROC) load(userptr, "glScissorIndexed");
glad_glScissorIndexedv = (PFNGLSCISSORINDEXEDVPROC) load(userptr, "glScissorIndexedv");
glad_glShaderBinary = (PFNGLSHADERBINARYPROC) load(userptr, "glShaderBinary");
glad_glUseProgramStages = (PFNGLUSEPROGRAMSTAGESPROC) load(userptr, "glUseProgramStages");
glad_glValidateProgramPipeline = (PFNGLVALIDATEPROGRAMPIPELINEPROC) load(userptr, "glValidateProgramPipeline");
glad_glVertexAttribL1d = (PFNGLVERTEXATTRIBL1DPROC) load(userptr, "glVertexAttribL1d");
glad_glVertexAttribL1dv = (PFNGLVERTEXATTRIBL1DVPROC) load(userptr, "glVertexAttribL1dv");
glad_glVertexAttribL2d = (PFNGLVERTEXATTRIBL2DPROC) load(userptr, "glVertexAttribL2d");
glad_glVertexAttribL2dv = (PFNGLVERTEXATTRIBL2DVPROC) load(userptr, "glVertexAttribL2dv");
glad_glVertexAttribL3d = (PFNGLVERTEXATTRIBL3DPROC) load(userptr, "glVertexAttribL3d");
glad_glVertexAttribL3dv = (PFNGLVERTEXATTRIBL3DVPROC) load(userptr, "glVertexAttribL3dv");
glad_glVertexAttribL4d = (PFNGLVERTEXATTRIBL4DPROC) load(userptr, "glVertexAttribL4d");
glad_glVertexAttribL4dv = (PFNGLVERTEXATTRIBL4DVPROC) load(userptr, "glVertexAttribL4dv");
glad_glVertexAttribLPointer = (PFNGLVERTEXATTRIBLPOINTERPROC) load(userptr, "glVertexAttribLPointer");
glad_glViewportArrayv = (PFNGLVIEWPORTARRAYVPROC) load(userptr, "glViewportArrayv");
glad_glViewportIndexedf = (PFNGLVIEWPORTINDEXEDFPROC) load(userptr, "glViewportIndexedf");
glad_glViewportIndexedfv = (PFNGLVIEWPORTINDEXEDFVPROC) load(userptr, "glViewportIndexedfv");
}
static void glad_gl_load_GL_VERSION_4_2( GLADuserptrloadfunc load, void* userptr) {
if(!GLAD_GL_VERSION_4_2) return;
glad_glBindImageTexture = (PFNGLBINDIMAGETEXTUREPROC) load(userptr, "glBindImageTexture");
glad_glDrawArraysInstancedBaseInstance = (PFNGLDRAWARRAYSINSTANCEDBASEINSTANCEPROC) load(userptr, "glDrawArraysInstancedBaseInstance");
glad_glDrawElementsInstancedBaseInstance = (PFNGLDRAWELEMENTSINSTANCEDBASEINSTANCEPROC) load(userptr, "glDrawElementsInstancedBaseInstance");
glad_glDrawElementsInstancedBaseVertexBaseInstance = (PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCEPROC) load(userptr, "glDrawElementsInstancedBaseVertexBaseInstance");
glad_glDrawTransformFeedbackInstanced = (PFNGLDRAWTRANSFORMFEEDBACKINSTANCEDPROC) load(userptr, "glDrawTransformFeedbackInstanced");
glad_glDrawTransformFeedbackStreamInstanced = (PFNGLDRAWTRANSFORMFEEDBACKSTREAMINSTANCEDPROC) load(userptr, "glDrawTransformFeedbackStreamInstanced");
glad_glGetActiveAtomicCounterBufferiv = (PFNGLGETACTIVEATOMICCOUNTERBUFFERIVPROC) load(userptr, "glGetActiveAtomicCounterBufferiv");
glad_glGetInternalformativ = (PFNGLGETINTERNALFORMATIVPROC) load(userptr, "glGetInternalformativ");
glad_glMemoryBarrier = (PFNGLMEMORYBARRIERPROC) load(userptr, "glMemoryBarrier");
glad_glTexStorage1D = (PFNGLTEXSTORAGE1DPROC) load(userptr, "glTexStorage1D");
glad_glTexStorage2D = (PFNGLTEXSTORAGE2DPROC) load(userptr, "glTexStorage2D");
glad_glTexStorage3D = (PFNGLTEXSTORAGE3DPROC) load(userptr, "glTexStorage3D");
}
static void glad_gl_load_GL_VERSION_4_3( GLADuserptrloadfunc load, void* userptr) {
if(!GLAD_GL_VERSION_4_3) return;
glad_glBindVertexBuffer = (PFNGLBINDVERTEXBUFFERPROC) load(userptr, "glBindVertexBuffer");
glad_glClearBufferData = (PFNGLCLEARBUFFERDATAPROC) load(userptr, "glClearBufferData");
glad_glClearBufferSubData = (PFNGLCLEARBUFFERSUBDATAPROC) load(userptr, "glClearBufferSubData");
glad_glCopyImageSubData = (PFNGLCOPYIMAGESUBDATAPROC) load(userptr, "glCopyImageSubData");
glad_glDebugMessageCallback = (PFNGLDEBUGMESSAGECALLBACKPROC) load(userptr, "glDebugMessageCallback");
glad_glDebugMessageControl = (PFNGLDEBUGMESSAGECONTROLPROC) load(userptr, "glDebugMessageControl");
glad_glDebugMessageInsert = (PFNGLDEBUGMESSAGEINSERTPROC) load(userptr, "glDebugMessageInsert");
glad_glDispatchCompute = (PFNGLDISPATCHCOMPUTEPROC) load(userptr, "glDispatchCompute");
glad_glDispatchComputeIndirect = (PFNGLDISPATCHCOMPUTEINDIRECTPROC) load(userptr, "glDispatchComputeIndirect");
glad_glFramebufferParameteri = (PFNGLFRAMEBUFFERPARAMETERIPROC) load(userptr, "glFramebufferParameteri");
glad_glGetDebugMessageLog = (PFNGLGETDEBUGMESSAGELOGPROC) load(userptr, "glGetDebugMessageLog");
glad_glGetFramebufferParameteriv = (PFNGLGETFRAMEBUFFERPARAMETERIVPROC) load(userptr, "glGetFramebufferParameteriv");
glad_glGetInternalformati64v = (PFNGLGETINTERNALFORMATI64VPROC) load(userptr, "glGetInternalformati64v");
glad_glGetObjectLabel = (PFNGLGETOBJECTLABELPROC) load(userptr, "glGetObjectLabel");
glad_glGetObjectPtrLabel = (PFNGLGETOBJECTPTRLABELPROC) load(userptr, "glGetObjectPtrLabel");
glad_glGetPointerv = (PFNGLGETPOINTERVPROC) load(userptr, "glGetPointerv");
glad_glGetProgramInterfaceiv = (PFNGLGETPROGRAMINTERFACEIVPROC) load(userptr, "glGetProgramInterfaceiv");
glad_glGetProgramResourceIndex = (PFNGLGETPROGRAMRESOURCEINDEXPROC) load(userptr, "glGetProgramResourceIndex");
glad_glGetProgramResourceLocation = (PFNGLGETPROGRAMRESOURCELOCATIONPROC) load(userptr, "glGetProgramResourceLocation");
glad_glGetProgramResourceLocationIndex = (PFNGLGETPROGRAMRESOURCELOCATIONINDEXPROC) load(userptr, "glGetProgramResourceLocationIndex");
glad_glGetProgramResourceName = (PFNGLGETPROGRAMRESOURCENAMEPROC) load(userptr, "glGetProgramResourceName");
glad_glGetProgramResourceiv = (PFNGLGETPROGRAMRESOURCEIVPROC) load(userptr, "glGetProgramResourceiv");
glad_glInvalidateBufferData = (PFNGLINVALIDATEBUFFERDATAPROC) load(userptr, "glInvalidateBufferData");
glad_glInvalidateBufferSubData = (PFNGLINVALIDATEBUFFERSUBDATAPROC) load(userptr, "glInvalidateBufferSubData");
glad_glInvalidateFramebuffer = (PFNGLINVALIDATEFRAMEBUFFERPROC) load(userptr, "glInvalidateFramebuffer");
glad_glInvalidateSubFramebuffer = (PFNGLINVALIDATESUBFRAMEBUFFERPROC) load(userptr, "glInvalidateSubFramebuffer");
glad_glInvalidateTexImage = (PFNGLINVALIDATETEXIMAGEPROC) load(userptr, "glInvalidateTexImage");
glad_glInvalidateTexSubImage = (PFNGLINVALIDATETEXSUBIMAGEPROC) load(userptr, "glInvalidateTexSubImage");
glad_glMultiDrawArraysIndirect = (PFNGLMULTIDRAWARRAYSINDIRECTPROC) load(userptr, "glMultiDrawArraysIndirect");
glad_glMultiDrawElementsIndirect = (PFNGLMULTIDRAWELEMENTSINDIRECTPROC) load(userptr, "glMultiDrawElementsIndirect");
glad_glObjectLabel = (PFNGLOBJECTLABELPROC) load(userptr, "glObjectLabel");
glad_glObjectPtrLabel = (PFNGLOBJECTPTRLABELPROC) load(userptr, "glObjectPtrLabel");
glad_glPopDebugGroup = (PFNGLPOPDEBUGGROUPPROC) load(userptr, "glPopDebugGroup");
glad_glPushDebugGroup = (PFNGLPUSHDEBUGGROUPPROC) load(userptr, "glPushDebugGroup");
glad_glShaderStorageBlockBinding = (PFNGLSHADERSTORAGEBLOCKBINDINGPROC) load(userptr, "glShaderStorageBlockBinding");
glad_glTexBufferRange = (PFNGLTEXBUFFERRANGEPROC) load(userptr, "glTexBufferRange");
glad_glTexStorage2DMultisample = (PFNGLTEXSTORAGE2DMULTISAMPLEPROC) load(userptr, "glTexStorage2DMultisample");
glad_glTexStorage3DMultisample = (PFNGLTEXSTORAGE3DMULTISAMPLEPROC) load(userptr, "glTexStorage3DMultisample");
glad_glTextureView = (PFNGLTEXTUREVIEWPROC) load(userptr, "glTextureView");
glad_glVertexAttribBinding = (PFNGLVERTEXATTRIBBINDINGPROC) load(userptr, "glVertexAttribBinding");
glad_glVertexAttribFormat = (PFNGLVERTEXATTRIBFORMATPROC) load(userptr, "glVertexAttribFormat");
glad_glVertexAttribIFormat = (PFNGLVERTEXATTRIBIFORMATPROC) load(userptr, "glVertexAttribIFormat");
glad_glVertexAttribLFormat = (PFNGLVERTEXATTRIBLFORMATPROC) load(userptr, "glVertexAttribLFormat");
glad_glVertexBindingDivisor = (PFNGLVERTEXBINDINGDIVISORPROC) load(userptr, "glVertexBindingDivisor");
}
static void glad_gl_load_GL_VERSION_4_4( GLADuserptrloadfunc load, void* userptr) {
if(!GLAD_GL_VERSION_4_4) return;
glad_glBindBuffersBase = (PFNGLBINDBUFFERSBASEPROC) load(userptr, "glBindBuffersBase");
glad_glBindBuffersRange = (PFNGLBINDBUFFERSRANGEPROC) load(userptr, "glBindBuffersRange");
glad_glBindImageTextures = (PFNGLBINDIMAGETEXTURESPROC) load(userptr, "glBindImageTextures");
glad_glBindSamplers = (PFNGLBINDSAMPLERSPROC) load(userptr, "glBindSamplers");
glad_glBindTextures = (PFNGLBINDTEXTURESPROC) load(userptr, "glBindTextures");
glad_glBindVertexBuffers = (PFNGLBINDVERTEXBUFFERSPROC) load(userptr, "glBindVertexBuffers");
glad_glBufferStorage = (PFNGLBUFFERSTORAGEPROC) load(userptr, "glBufferStorage");
glad_glClearTexImage = (PFNGLCLEARTEXIMAGEPROC) load(userptr, "glClearTexImage");
glad_glClearTexSubImage = (PFNGLCLEARTEXSUBIMAGEPROC) load(userptr, "glClearTexSubImage");
}
static void glad_gl_load_GL_VERSION_4_5( GLADuserptrloadfunc load, void* userptr) {
if(!GLAD_GL_VERSION_4_5) return;
glad_glBindTextureUnit = (PFNGLBINDTEXTUREUNITPROC) load(userptr, "glBindTextureUnit");
glad_glBlitNamedFramebuffer = (PFNGLBLITNAMEDFRAMEBUFFERPROC) load(userptr, "glBlitNamedFramebuffer");
glad_glCheckNamedFramebufferStatus = (PFNGLCHECKNAMEDFRAMEBUFFERSTATUSPROC) load(userptr, "glCheckNamedFramebufferStatus");
glad_glClearNamedBufferData = (PFNGLCLEARNAMEDBUFFERDATAPROC) load(userptr, "glClearNamedBufferData");
glad_glClearNamedBufferSubData = (PFNGLCLEARNAMEDBUFFERSUBDATAPROC) load(userptr, "glClearNamedBufferSubData");
glad_glClearNamedFramebufferfi = (PFNGLCLEARNAMEDFRAMEBUFFERFIPROC) load(userptr, "glClearNamedFramebufferfi");
glad_glClearNamedFramebufferfv = (PFNGLCLEARNAMEDFRAMEBUFFERFVPROC) load(userptr, "glClearNamedFramebufferfv");
glad_glClearNamedFramebufferiv = (PFNGLCLEARNAMEDFRAMEBUFFERIVPROC) load(userptr, "glClearNamedFramebufferiv");
glad_glClearNamedFramebufferuiv = (PFNGLCLEARNAMEDFRAMEBUFFERUIVPROC) load(userptr, "glClearNamedFramebufferuiv");
glad_glClipControl = (PFNGLCLIPCONTROLPROC) load(userptr, "glClipControl");
glad_glCompressedTextureSubImage1D = (PFNGLCOMPRESSEDTEXTURESUBIMAGE1DPROC) load(userptr, "glCompressedTextureSubImage1D");
glad_glCompressedTextureSubImage2D = (PFNGLCOMPRESSEDTEXTURESUBIMAGE2DPROC) load(userptr, "glCompressedTextureSubImage2D");
glad_glCompressedTextureSubImage3D = (PFNGLCOMPRESSEDTEXTURESUBIMAGE3DPROC) load(userptr, "glCompressedTextureSubImage3D");
glad_glCopyNamedBufferSubData = (PFNGLCOPYNAMEDBUFFERSUBDATAPROC) load(userptr, "glCopyNamedBufferSubData");
glad_glCopyTextureSubImage1D = (PFNGLCOPYTEXTURESUBIMAGE1DPROC) load(userptr, "glCopyTextureSubImage1D");
glad_glCopyTextureSubImage2D = (PFNGLCOPYTEXTURESUBIMAGE2DPROC) load(userptr, "glCopyTextureSubImage2D");
glad_glCopyTextureSubImage3D = (PFNGLCOPYTEXTURESUBIMAGE3DPROC) load(userptr, "glCopyTextureSubImage3D");
glad_glCreateBuffers = (PFNGLCREATEBUFFERSPROC) load(userptr, "glCreateBuffers");
glad_glCreateFramebuffers = (PFNGLCREATEFRAMEBUFFERSPROC) load(userptr, "glCreateFramebuffers");
glad_glCreateProgramPipelines = (PFNGLCREATEPROGRAMPIPELINESPROC) load(userptr, "glCreateProgramPipelines");
glad_glCreateQueries = (PFNGLCREATEQUERIESPROC) load(userptr, "glCreateQueries");
glad_glCreateRenderbuffers = (PFNGLCREATERENDERBUFFERSPROC) load(userptr, "glCreateRenderbuffers");
glad_glCreateSamplers = (PFNGLCREATESAMPLERSPROC) load(userptr, "glCreateSamplers");
glad_glCreateTextures = (PFNGLCREATETEXTURESPROC) load(userptr, "glCreateTextures");
glad_glCreateTransformFeedbacks = (PFNGLCREATETRANSFORMFEEDBACKSPROC) load(userptr, "glCreateTransformFeedbacks");
glad_glCreateVertexArrays = (PFNGLCREATEVERTEXARRAYSPROC) load(userptr, "glCreateVertexArrays");
glad_glDisableVertexArrayAttrib = (PFNGLDISABLEVERTEXARRAYATTRIBPROC) load(userptr, "glDisableVertexArrayAttrib");
glad_glEnableVertexArrayAttrib = (PFNGLENABLEVERTEXARRAYATTRIBPROC) load(userptr, "glEnableVertexArrayAttrib");
glad_glFlushMappedNamedBufferRange = (PFNGLFLUSHMAPPEDNAMEDBUFFERRANGEPROC) load(userptr, "glFlushMappedNamedBufferRange");
glad_glGenerateTextureMipmap = (PFNGLGENERATETEXTUREMIPMAPPROC) load(userptr, "glGenerateTextureMipmap");
glad_glGetCompressedTextureImage = (PFNGLGETCOMPRESSEDTEXTUREIMAGEPROC) load(userptr, "glGetCompressedTextureImage");
glad_glGetCompressedTextureSubImage = (PFNGLGETCOMPRESSEDTEXTURESUBIMAGEPROC) load(userptr, "glGetCompressedTextureSubImage");
glad_glGetGraphicsResetStatus = (PFNGLGETGRAPHICSRESETSTATUSPROC) load(userptr, "glGetGraphicsResetStatus");
glad_glGetNamedBufferParameteri64v = (PFNGLGETNAMEDBUFFERPARAMETERI64VPROC) load(userptr, "glGetNamedBufferParameteri64v");
glad_glGetNamedBufferParameteriv = (PFNGLGETNAMEDBUFFERPARAMETERIVPROC) load(userptr, "glGetNamedBufferParameteriv");
glad_glGetNamedBufferPointerv = (PFNGLGETNAMEDBUFFERPOINTERVPROC) load(userptr, "glGetNamedBufferPointerv");
glad_glGetNamedBufferSubData = (PFNGLGETNAMEDBUFFERSUBDATAPROC) load(userptr, "glGetNamedBufferSubData");
glad_glGetNamedFramebufferAttachmentParameteriv = (PFNGLGETNAMEDFRAMEBUFFERATTACHMENTPARAMETERIVPROC) load(userptr, "glGetNamedFramebufferAttachmentParameteriv");
glad_glGetNamedFramebufferParameteriv = (PFNGLGETNAMEDFRAMEBUFFERPARAMETERIVPROC) load(userptr, "glGetNamedFramebufferParameteriv");
glad_glGetNamedRenderbufferParameteriv = (PFNGLGETNAMEDRENDERBUFFERPARAMETERIVPROC) load(userptr, "glGetNamedRenderbufferParameteriv");
glad_glGetQueryBufferObjecti64v = (PFNGLGETQUERYBUFFEROBJECTI64VPROC) load(userptr, "glGetQueryBufferObjecti64v");
glad_glGetQueryBufferObjectiv = (PFNGLGETQUERYBUFFEROBJECTIVPROC) load(userptr, "glGetQueryBufferObjectiv");
glad_glGetQueryBufferObjectui64v = (PFNGLGETQUERYBUFFEROBJECTUI64VPROC) load(userptr, "glGetQueryBufferObjectui64v");
glad_glGetQueryBufferObjectuiv = (PFNGLGETQUERYBUFFEROBJECTUIVPROC) load(userptr, "glGetQueryBufferObjectuiv");
glad_glGetTextureImage = (PFNGLGETTEXTUREIMAGEPROC) load(userptr, "glGetTextureImage");
glad_glGetTextureLevelParameterfv = (PFNGLGETTEXTURELEVELPARAMETERFVPROC) load(userptr, "glGetTextureLevelParameterfv");
glad_glGetTextureLevelParameteriv = (PFNGLGETTEXTURELEVELPARAMETERIVPROC) load(userptr, "glGetTextureLevelParameteriv");
glad_glGetTextureParameterIiv = (PFNGLGETTEXTUREPARAMETERIIVPROC) load(userptr, "glGetTextureParameterIiv");
glad_glGetTextureParameterIuiv = (PFNGLGETTEXTUREPARAMETERIUIVPROC) load(userptr, "glGetTextureParameterIuiv");
glad_glGetTextureParameterfv = (PFNGLGETTEXTUREPARAMETERFVPROC) load(userptr, "glGetTextureParameterfv");
glad_glGetTextureParameteriv = (PFNGLGETTEXTUREPARAMETERIVPROC) load(userptr, "glGetTextureParameteriv");
glad_glGetTextureSubImage = (PFNGLGETTEXTURESUBIMAGEPROC) load(userptr, "glGetTextureSubImage");
glad_glGetTransformFeedbacki64_v = (PFNGLGETTRANSFORMFEEDBACKI64_VPROC) load(userptr, "glGetTransformFeedbacki64_v");
glad_glGetTransformFeedbacki_v = (PFNGLGETTRANSFORMFEEDBACKI_VPROC) load(userptr, "glGetTransformFeedbacki_v");
glad_glGetTransformFeedbackiv = (PFNGLGETTRANSFORMFEEDBACKIVPROC) load(userptr, "glGetTransformFeedbackiv");
glad_glGetVertexArrayIndexed64iv = (PFNGLGETVERTEXARRAYINDEXED64IVPROC) load(userptr, "glGetVertexArrayIndexed64iv");
glad_glGetVertexArrayIndexediv = (PFNGLGETVERTEXARRAYINDEXEDIVPROC) load(userptr, "glGetVertexArrayIndexediv");
glad_glGetVertexArrayiv = (PFNGLGETVERTEXARRAYIVPROC) load(userptr, "glGetVertexArrayiv");
glad_glGetnColorTable = (PFNGLGETNCOLORTABLEPROC) load(userptr, "glGetnColorTable");
glad_glGetnCompressedTexImage = (PFNGLGETNCOMPRESSEDTEXIMAGEPROC) load(userptr, "glGetnCompressedTexImage");
glad_glGetnConvolutionFilter = (PFNGLGETNCONVOLUTIONFILTERPROC) load(userptr, "glGetnConvolutionFilter");
glad_glGetnHistogram = (PFNGLGETNHISTOGRAMPROC) load(userptr, "glGetnHistogram");
glad_glGetnMapdv = (PFNGLGETNMAPDVPROC) load(userptr, "glGetnMapdv");
glad_glGetnMapfv = (PFNGLGETNMAPFVPROC) load(userptr, "glGetnMapfv");
glad_glGetnMapiv = (PFNGLGETNMAPIVPROC) load(userptr, "glGetnMapiv");
glad_glGetnMinmax = (PFNGLGETNMINMAXPROC) load(userptr, "glGetnMinmax");
glad_glGetnPixelMapfv = (PFNGLGETNPIXELMAPFVPROC) load(userptr, "glGetnPixelMapfv");
glad_glGetnPixelMapuiv = (PFNGLGETNPIXELMAPUIVPROC) load(userptr, "glGetnPixelMapuiv");
glad_glGetnPixelMapusv = (PFNGLGETNPIXELMAPUSVPROC) load(userptr, "glGetnPixelMapusv");
glad_glGetnPolygonStipple = (PFNGLGETNPOLYGONSTIPPLEPROC) load(userptr, "glGetnPolygonStipple");
glad_glGetnSeparableFilter = (PFNGLGETNSEPARABLEFILTERPROC) load(userptr, "glGetnSeparableFilter");
glad_glGetnTexImage = (PFNGLGETNTEXIMAGEPROC) load(userptr, "glGetnTexImage");
glad_glGetnUniformdv = (PFNGLGETNUNIFORMDVPROC) load(userptr, "glGetnUniformdv");
glad_glGetnUniformfv = (PFNGLGETNUNIFORMFVPROC) load(userptr, "glGetnUniformfv");
glad_glGetnUniformiv = (PFNGLGETNUNIFORMIVPROC) load(userptr, "glGetnUniformiv");
glad_glGetnUniformuiv = (PFNGLGETNUNIFORMUIVPROC) load(userptr, "glGetnUniformuiv");
glad_glInvalidateNamedFramebufferData = (PFNGLINVALIDATENAMEDFRAMEBUFFERDATAPROC) load(userptr, "glInvalidateNamedFramebufferData");
glad_glInvalidateNamedFramebufferSubData = (PFNGLINVALIDATENAMEDFRAMEBUFFERSUBDATAPROC) load(userptr, "glInvalidateNamedFramebufferSubData");
glad_glMapNamedBuffer = (PFNGLMAPNAMEDBUFFERPROC) load(userptr, "glMapNamedBuffer");
glad_glMapNamedBufferRange = (PFNGLMAPNAMEDBUFFERRANGEPROC) load(userptr, "glMapNamedBufferRange");
glad_glMemoryBarrierByRegion = (PFNGLMEMORYBARRIERBYREGIONPROC) load(userptr, "glMemoryBarrierByRegion");
glad_glNamedBufferData = (PFNGLNAMEDBUFFERDATAPROC) load(userptr, "glNamedBufferData");
glad_glNamedBufferStorage = (PFNGLNAMEDBUFFERSTORAGEPROC) load(userptr, "glNamedBufferStorage");
glad_glNamedBufferSubData = (PFNGLNAMEDBUFFERSUBDATAPROC) load(userptr, "glNamedBufferSubData");
glad_glNamedFramebufferDrawBuffer = (PFNGLNAMEDFRAMEBUFFERDRAWBUFFERPROC) load(userptr, "glNamedFramebufferDrawBuffer");
glad_glNamedFramebufferDrawBuffers = (PFNGLNAMEDFRAMEBUFFERDRAWBUFFERSPROC) load(userptr, "glNamedFramebufferDrawBuffers");
glad_glNamedFramebufferParameteri = (PFNGLNAMEDFRAMEBUFFERPARAMETERIPROC) load(userptr, "glNamedFramebufferParameteri");
glad_glNamedFramebufferReadBuffer = (PFNGLNAMEDFRAMEBUFFERREADBUFFERPROC) load(userptr, "glNamedFramebufferReadBuffer");
glad_glNamedFramebufferRenderbuffer = (PFNGLNAMEDFRAMEBUFFERRENDERBUFFERPROC) load(userptr, "glNamedFramebufferRenderbuffer");
glad_glNamedFramebufferTexture = (PFNGLNAMEDFRAMEBUFFERTEXTUREPROC) load(userptr, "glNamedFramebufferTexture");
glad_glNamedFramebufferTextureLayer = (PFNGLNAMEDFRAMEBUFFERTEXTURELAYERPROC) load(userptr, "glNamedFramebufferTextureLayer");
glad_glNamedRenderbufferStorage = (PFNGLNAMEDRENDERBUFFERSTORAGEPROC) load(userptr, "glNamedRenderbufferStorage");
glad_glNamedRenderbufferStorageMultisample = (PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLEPROC) load(userptr, "glNamedRenderbufferStorageMultisample");
glad_glReadnPixels = (PFNGLREADNPIXELSPROC) load(userptr, "glReadnPixels");
glad_glTextureBarrier = (PFNGLTEXTUREBARRIERPROC) load(userptr, "glTextureBarrier");
glad_glTextureBuffer = (PFNGLTEXTUREBUFFERPROC) load(userptr, "glTextureBuffer");
glad_glTextureBufferRange = (PFNGLTEXTUREBUFFERRANGEPROC) load(userptr, "glTextureBufferRange");
glad_glTextureParameterIiv = (PFNGLTEXTUREPARAMETERIIVPROC) load(userptr, "glTextureParameterIiv");
glad_glTextureParameterIuiv = (PFNGLTEXTUREPARAMETERIUIVPROC) load(userptr, "glTextureParameterIuiv");
glad_glTextureParameterf = (PFNGLTEXTUREPARAMETERFPROC) load(userptr, "glTextureParameterf");
glad_glTextureParameterfv = (PFNGLTEXTUREPARAMETERFVPROC) load(userptr, "glTextureParameterfv");
glad_glTextureParameteri = (PFNGLTEXTUREPARAMETERIPROC) load(userptr, "glTextureParameteri");
glad_glTextureParameteriv = (PFNGLTEXTUREPARAMETERIVPROC) load(userptr, "glTextureParameteriv");
glad_glTextureStorage1D = (PFNGLTEXTURESTORAGE1DPROC) load(userptr, "glTextureStorage1D");
glad_glTextureStorage2D = (PFNGLTEXTURESTORAGE2DPROC) load(userptr, "glTextureStorage2D");
glad_glTextureStorage2DMultisample = (PFNGLTEXTURESTORAGE2DMULTISAMPLEPROC) load(userptr, "glTextureStorage2DMultisample");
glad_glTextureStorage3D = (PFNGLTEXTURESTORAGE3DPROC) load(userptr, "glTextureStorage3D");
glad_glTextureStorage3DMultisample = (PFNGLTEXTURESTORAGE3DMULTISAMPLEPROC) load(userptr, "glTextureStorage3DMultisample");
glad_glTextureSubImage1D = (PFNGLTEXTURESUBIMAGE1DPROC) load(userptr, "glTextureSubImage1D");
glad_glTextureSubImage2D = (PFNGLTEXTURESUBIMAGE2DPROC) load(userptr, "glTextureSubImage2D");
glad_glTextureSubImage3D = (PFNGLTEXTURESUBIMAGE3DPROC) load(userptr, "glTextureSubImage3D");
glad_glTransformFeedbackBufferBase = (PFNGLTRANSFORMFEEDBACKBUFFERBASEPROC) load(userptr, "glTransformFeedbackBufferBase");
glad_glTransformFeedbackBufferRange = (PFNGLTRANSFORMFEEDBACKBUFFERRANGEPROC) load(userptr, "glTransformFeedbackBufferRange");
glad_glUnmapNamedBuffer = (PFNGLUNMAPNAMEDBUFFERPROC) load(userptr, "glUnmapNamedBuffer");
glad_glVertexArrayAttribBinding = (PFNGLVERTEXARRAYATTRIBBINDINGPROC) load(userptr, "glVertexArrayAttribBinding");
glad_glVertexArrayAttribFormat = (PFNGLVERTEXARRAYATTRIBFORMATPROC) load(userptr, "glVertexArrayAttribFormat");
glad_glVertexArrayAttribIFormat = (PFNGLVERTEXARRAYATTRIBIFORMATPROC) load(userptr, "glVertexArrayAttribIFormat");
glad_glVertexArrayAttribLFormat = (PFNGLVERTEXARRAYATTRIBLFORMATPROC) load(userptr, "glVertexArrayAttribLFormat");
glad_glVertexArrayBindingDivisor = (PFNGLVERTEXARRAYBINDINGDIVISORPROC) load(userptr, "glVertexArrayBindingDivisor");
glad_glVertexArrayElementBuffer = (PFNGLVERTEXARRAYELEMENTBUFFERPROC) load(userptr, "glVertexArrayElementBuffer");
glad_glVertexArrayVertexBuffer = (PFNGLVERTEXARRAYVERTEXBUFFERPROC) load(userptr, "glVertexArrayVertexBuffer");
glad_glVertexArrayVertexBuffers = (PFNGLVERTEXARRAYVERTEXBUFFERSPROC) load(userptr, "glVertexArrayVertexBuffers");
}
static void glad_gl_load_GL_VERSION_4_6( GLADuserptrloadfunc load, void* userptr) {
if(!GLAD_GL_VERSION_4_6) return;
glad_glMultiDrawArraysIndirectCount = (PFNGLMULTIDRAWARRAYSINDIRECTCOUNTPROC) load(userptr, "glMultiDrawArraysIndirectCount");
glad_glMultiDrawElementsIndirectCount = (PFNGLMULTIDRAWELEMENTSINDIRECTCOUNTPROC) load(userptr, "glMultiDrawElementsIndirectCount");
glad_glPolygonOffsetClamp = (PFNGLPOLYGONOFFSETCLAMPPROC) load(userptr, "glPolygonOffsetClamp");
glad_glSpecializeShader = (PFNGLSPECIALIZESHADERPROC) load(userptr, "glSpecializeShader");
}
static void glad_gl_load_GL_ARB_multisample( GLADuserptrloadfunc load, void* userptr) {
if(!GLAD_GL_ARB_multisample) return;
glad_glSampleCoverageARB = (PFNGLSAMPLECOVERAGEARBPROC) load(userptr, "glSampleCoverageARB");
}
static void glad_gl_load_GL_ARB_robustness( GLADuserptrloadfunc load, void* userptr) {
if(!GLAD_GL_ARB_robustness) return;
glad_glGetGraphicsResetStatusARB = (PFNGLGETGRAPHICSRESETSTATUSARBPROC) load(userptr, "glGetGraphicsResetStatusARB");
glad_glGetnColorTableARB = (PFNGLGETNCOLORTABLEARBPROC) load(userptr, "glGetnColorTableARB");
glad_glGetnCompressedTexImageARB = (PFNGLGETNCOMPRESSEDTEXIMAGEARBPROC) load(userptr, "glGetnCompressedTexImageARB");
glad_glGetnConvolutionFilterARB = (PFNGLGETNCONVOLUTIONFILTERARBPROC) load(userptr, "glGetnConvolutionFilterARB");
glad_glGetnHistogramARB = (PFNGLGETNHISTOGRAMARBPROC) load(userptr, "glGetnHistogramARB");
glad_glGetnMapdvARB = (PFNGLGETNMAPDVARBPROC) load(userptr, "glGetnMapdvARB");
glad_glGetnMapfvARB = (PFNGLGETNMAPFVARBPROC) load(userptr, "glGetnMapfvARB");
glad_glGetnMapivARB = (PFNGLGETNMAPIVARBPROC) load(userptr, "glGetnMapivARB");
glad_glGetnMinmaxARB = (PFNGLGETNMINMAXARBPROC) load(userptr, "glGetnMinmaxARB");
glad_glGetnPixelMapfvARB = (PFNGLGETNPIXELMAPFVARBPROC) load(userptr, "glGetnPixelMapfvARB");
glad_glGetnPixelMapuivARB = (PFNGLGETNPIXELMAPUIVARBPROC) load(userptr, "glGetnPixelMapuivARB");
glad_glGetnPixelMapusvARB = (PFNGLGETNPIXELMAPUSVARBPROC) load(userptr, "glGetnPixelMapusvARB");
glad_glGetnPolygonStippleARB = (PFNGLGETNPOLYGONSTIPPLEARBPROC) load(userptr, "glGetnPolygonStippleARB");
glad_glGetnSeparableFilterARB = (PFNGLGETNSEPARABLEFILTERARBPROC) load(userptr, "glGetnSeparableFilterARB");
glad_glGetnTexImageARB = (PFNGLGETNTEXIMAGEARBPROC) load(userptr, "glGetnTexImageARB");
glad_glGetnUniformdvARB = (PFNGLGETNUNIFORMDVARBPROC) load(userptr, "glGetnUniformdvARB");
glad_glGetnUniformfvARB = (PFNGLGETNUNIFORMFVARBPROC) load(userptr, "glGetnUniformfvARB");
glad_glGetnUniformivARB = (PFNGLGETNUNIFORMIVARBPROC) load(userptr, "glGetnUniformivARB");
glad_glGetnUniformuivARB = (PFNGLGETNUNIFORMUIVARBPROC) load(userptr, "glGetnUniformuivARB");
glad_glReadnPixelsARB = (PFNGLREADNPIXELSARBPROC) load(userptr, "glReadnPixelsARB");
}
static void glad_gl_load_GL_KHR_debug( GLADuserptrloadfunc load, void* userptr) {
if(!GLAD_GL_KHR_debug) return;
glad_glDebugMessageCallback = (PFNGLDEBUGMESSAGECALLBACKPROC) load(userptr, "glDebugMessageCallback");
glad_glDebugMessageControl = (PFNGLDEBUGMESSAGECONTROLPROC) load(userptr, "glDebugMessageControl");
glad_glDebugMessageInsert = (PFNGLDEBUGMESSAGEINSERTPROC) load(userptr, "glDebugMessageInsert");
glad_glGetDebugMessageLog = (PFNGLGETDEBUGMESSAGELOGPROC) load(userptr, "glGetDebugMessageLog");
glad_glGetObjectLabel = (PFNGLGETOBJECTLABELPROC) load(userptr, "glGetObjectLabel");
glad_glGetObjectPtrLabel = (PFNGLGETOBJECTPTRLABELPROC) load(userptr, "glGetObjectPtrLabel");
glad_glGetPointerv = (PFNGLGETPOINTERVPROC) load(userptr, "glGetPointerv");
glad_glObjectLabel = (PFNGLOBJECTLABELPROC) load(userptr, "glObjectLabel");
glad_glObjectPtrLabel = (PFNGLOBJECTPTRLABELPROC) load(userptr, "glObjectPtrLabel");
glad_glPopDebugGroup = (PFNGLPOPDEBUGGROUPPROC) load(userptr, "glPopDebugGroup");
glad_glPushDebugGroup = (PFNGLPUSHDEBUGGROUPPROC) load(userptr, "glPushDebugGroup");
}
#if defined(GL_ES_VERSION_3_0) || defined(GL_VERSION_3_0)
#define GLAD_GL_IS_SOME_NEW_VERSION 1
#else
#define GLAD_GL_IS_SOME_NEW_VERSION 0
#endif
static int glad_gl_get_extensions( int version, const char **out_exts, unsigned int *out_num_exts_i, char ***out_exts_i) {
#if GLAD_GL_IS_SOME_NEW_VERSION
if(GLAD_VERSION_MAJOR(version) < 3) {
#else
(void) version;
(void) out_num_exts_i;
(void) out_exts_i;
#endif
if (glad_glGetString == NULL) {
return 0;
}
*out_exts = (const char *)glad_glGetString(GL_EXTENSIONS);
#if GLAD_GL_IS_SOME_NEW_VERSION
} else {
unsigned int index = 0;
unsigned int num_exts_i = 0;
char **exts_i = NULL;
if (glad_glGetStringi == NULL || glad_glGetIntegerv == NULL) {
return 0;
}
glad_glGetIntegerv(GL_NUM_EXTENSIONS, (int*) &num_exts_i);
if (num_exts_i > 0) {
exts_i = (char **) malloc(num_exts_i * (sizeof *exts_i));
}
if (exts_i == NULL) {
return 0;
}
for(index = 0; index < num_exts_i; index++) {
const char *gl_str_tmp = (const char*) glad_glGetStringi(GL_EXTENSIONS, index);
size_t len = strlen(gl_str_tmp) + 1;
char *local_str = (char*) malloc(len * sizeof(char));
if(local_str != NULL) {
memcpy(local_str, gl_str_tmp, len * sizeof(char));
}
exts_i[index] = local_str;
}
*out_num_exts_i = num_exts_i;
*out_exts_i = exts_i;
}
#endif
return 1;
}
static void glad_gl_free_extensions(char **exts_i, unsigned int num_exts_i) {
if (exts_i != NULL) {
unsigned int index;
for(index = 0; index < num_exts_i; index++) {
free((void *) (exts_i[index]));
}
free((void *)exts_i);
exts_i = NULL;
}
}
static int glad_gl_has_extension(int version, const char *exts, unsigned int num_exts_i, char **exts_i, const char *ext) {
if(GLAD_VERSION_MAJOR(version) < 3 || !GLAD_GL_IS_SOME_NEW_VERSION) {
const char *extensions;
const char *loc;
const char *terminator;
extensions = exts;
if(extensions == NULL || ext == NULL) {
return 0;
}
while(1) {
loc = strstr(extensions, ext);
if(loc == NULL) {
return 0;
}
terminator = loc + strlen(ext);
if((loc == extensions || *(loc - 1) == ' ') &&
(*terminator == ' ' || *terminator == '\0')) {
return 1;
}
extensions = terminator;
}
} else {
unsigned int index;
for(index = 0; index < num_exts_i; index++) {
const char *e = exts_i[index];
if(strcmp(e, ext) == 0) {
return 1;
}
}
}
return 0;
}
static GLADapiproc glad_gl_get_proc_from_userptr(void *userptr, const char* name) {
return (GLAD_GNUC_EXTENSION (GLADapiproc (*)(const char *name)) userptr)(name);
}
static int glad_gl_find_extensions_gl( int version) {
const char *exts = NULL;
unsigned int num_exts_i = 0;
char **exts_i = NULL;
if (!glad_gl_get_extensions(version, &exts, &num_exts_i, &exts_i)) return 0;
GLAD_GL_ARB_multisample = glad_gl_has_extension(version, exts, num_exts_i, exts_i, "GL_ARB_multisample");
GLAD_GL_ARB_robustness = glad_gl_has_extension(version, exts, num_exts_i, exts_i, "GL_ARB_robustness");
GLAD_GL_KHR_debug = glad_gl_has_extension(version, exts, num_exts_i, exts_i, "GL_KHR_debug");
glad_gl_free_extensions(exts_i, num_exts_i);
return 1;
}
static int glad_gl_find_core_gl(void) {
int i;
const char* version;
const char* prefixes[] = {
"OpenGL ES-CM ",
"OpenGL ES-CL ",
"OpenGL ES ",
"OpenGL SC ",
NULL
};
int major = 0;
int minor = 0;
version = (const char*) glad_glGetString(GL_VERSION);
if (!version) return 0;
for (i = 0; prefixes[i]; i++) {
const size_t length = strlen(prefixes[i]);
if (strncmp(version, prefixes[i], length) == 0) {
version += length;
break;
}
}
GLAD_IMPL_UTIL_SSCANF(version, "%d.%d", &major, &minor);
GLAD_GL_VERSION_1_0 = (major == 1 && minor >= 0) || major > 1;
GLAD_GL_VERSION_1_1 = (major == 1 && minor >= 1) || major > 1;
GLAD_GL_VERSION_1_2 = (major == 1 && minor >= 2) || major > 1;
GLAD_GL_VERSION_1_3 = (major == 1 && minor >= 3) || major > 1;
GLAD_GL_VERSION_1_4 = (major == 1 && minor >= 4) || major > 1;
GLAD_GL_VERSION_1_5 = (major == 1 && minor >= 5) || major > 1;
GLAD_GL_VERSION_2_0 = (major == 2 && minor >= 0) || major > 2;
GLAD_GL_VERSION_2_1 = (major == 2 && minor >= 1) || major > 2;
GLAD_GL_VERSION_3_0 = (major == 3 && minor >= 0) || major > 3;
GLAD_GL_VERSION_3_1 = (major == 3 && minor >= 1) || major > 3;
GLAD_GL_VERSION_3_2 = (major == 3 && minor >= 2) || major > 3;
GLAD_GL_VERSION_3_3 = (major == 3 && minor >= 3) || major > 3;
GLAD_GL_VERSION_4_0 = (major == 4 && minor >= 0) || major > 4;
GLAD_GL_VERSION_4_1 = (major == 4 && minor >= 1) || major > 4;
GLAD_GL_VERSION_4_2 = (major == 4 && minor >= 2) || major > 4;
GLAD_GL_VERSION_4_3 = (major == 4 && minor >= 3) || major > 4;
GLAD_GL_VERSION_4_4 = (major == 4 && minor >= 4) || major > 4;
GLAD_GL_VERSION_4_5 = (major == 4 && minor >= 5) || major > 4;
GLAD_GL_VERSION_4_6 = (major == 4 && minor >= 6) || major > 4;
return GLAD_MAKE_VERSION(major, minor);
}
int gladLoadGLUserPtr( GLADuserptrloadfunc load, void *userptr) {
int version;
glad_glGetString = (PFNGLGETSTRINGPROC) load(userptr, "glGetString");
if(glad_glGetString == NULL) return 0;
if(glad_glGetString(GL_VERSION) == NULL) return 0;
version = glad_gl_find_core_gl();
glad_gl_load_GL_VERSION_1_0(load, userptr);
glad_gl_load_GL_VERSION_1_1(load, userptr);
glad_gl_load_GL_VERSION_1_2(load, userptr);
glad_gl_load_GL_VERSION_1_3(load, userptr);
glad_gl_load_GL_VERSION_1_4(load, userptr);
glad_gl_load_GL_VERSION_1_5(load, userptr);
glad_gl_load_GL_VERSION_2_0(load, userptr);
glad_gl_load_GL_VERSION_2_1(load, userptr);
glad_gl_load_GL_VERSION_3_0(load, userptr);
glad_gl_load_GL_VERSION_3_1(load, userptr);
glad_gl_load_GL_VERSION_3_2(load, userptr);
glad_gl_load_GL_VERSION_3_3(load, userptr);
glad_gl_load_GL_VERSION_4_0(load, userptr);
glad_gl_load_GL_VERSION_4_1(load, userptr);
glad_gl_load_GL_VERSION_4_2(load, userptr);
glad_gl_load_GL_VERSION_4_3(load, userptr);
glad_gl_load_GL_VERSION_4_4(load, userptr);
glad_gl_load_GL_VERSION_4_5(load, userptr);
glad_gl_load_GL_VERSION_4_6(load, userptr);
if (!glad_gl_find_extensions_gl(version)) return 0;
glad_gl_load_GL_ARB_multisample(load, userptr);
glad_gl_load_GL_ARB_robustness(load, userptr);
glad_gl_load_GL_KHR_debug(load, userptr);
return version;
}
int gladLoadGL( GLADloadfunc load) {
return gladLoadGLUserPtr( glad_gl_get_proc_from_userptr, GLAD_GNUC_EXTENSION (void*) load);
}
#ifdef __cplusplus
}
#endif
#endif /* GLAD_GL_IMPLEMENTATION */
|
resetius/graphtoys
|
opengl/render.c
|
#include <stdlib.h>
#include <ktx.h>
#define GLFW_INCLUDE_NONE
#include <GLFW/glfw3.h>
#define GLAD_GL_IMPLEMENTATION
#include <glad/gl.h>
#include <render/render.h>
#include <render/char.h>
#include <render/pipeline.h>
#include <ft2build.h>
#include FT_FREETYPE_H
#include <lib/verify.h>
struct Program* prog_opengl_new();
struct BufferManager* buf_mgr_opengl_new(struct Render* r);
struct CharImpl {
struct Char base;
GLuint tex_id;
};
struct RenderImpl {
struct Render base;
struct RenderConfig cfg;
GLFWwindow* window;
GLint major;
GLint minor;
};
static void GLAPIENTRY
message_callback( GLenum source,
GLenum type,
GLuint id,
GLenum severity,
GLsizei length,
const GLchar* message,
const void* userParam )
{
fprintf( stderr, "GL CALLBACK: %s source = 0x%x, type = 0x%x, severity = 0x%x, message = %s\n",
( type == GL_DEBUG_TYPE_ERROR ? "** GL ERROR **" : "" ),
source, type, severity, message );
}
static void* char_texture_(struct Char* ch) {
return & (((struct CharImpl*)ch)->tex_id);
}
static void char_free_(struct Char* ch) {
if (ch) {
struct CharImpl* c = (struct CharImpl*)ch;
glDeleteTextures(1, &c->tex_id);
free(c);
}
}
static struct Char* rend_char_new_(struct Render* r, wchar_t ch, void* bm) {
struct CharImpl* c = calloc(1, sizeof(*c));
FT_Face face = (FT_Face)bm;
FT_Bitmap bitmap = face->glyph->bitmap;
struct Char base = {
.texture = char_texture_,
.free = char_free_
};
c->base = base;
c->base.ch = ch;
c->base.w = bitmap.width;
c->base.h = bitmap.rows;
c->base.left = face->glyph->bitmap_left;
c->base.top = face->glyph->bitmap_top;
c->base.advance = face->glyph->advance.x;
if (bitmap.width*bitmap.rows == 0) {
free(c);
return NULL;
}
glGenTextures(1, &c->tex_id);
glBindTexture(GL_TEXTURE_2D, c->tex_id);
glPixelStorei(GL_UNPACK_ROW_LENGTH, bitmap.pitch);
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
glTexImage2D(
GL_TEXTURE_2D, 0,
GL_RED,
bitmap.width,
bitmap.rows, 0,
GL_RED,
GL_UNSIGNED_BYTE,
bitmap.buffer);
return (struct Char*)c;
};
static void rend_free_(struct Render* r1) {
struct RenderImpl* r = (struct RenderImpl*)r1;
free(r);
}
static void set_view_entity_(struct Render* r, void* data) {
GLFWwindow* window = data;
((struct RenderImpl*)r)->window = window;
glfwMakeContextCurrent(window);
}
static void set_viewport(struct Render* r, int w, int h) {
glViewport(0, 0, w, h);
}
static void draw_begin_(struct Render* r) {
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
}
static void draw_end_(struct Render* r) {
glfwSwapBuffers(((struct RenderImpl*)r)->window);
}
static void gl_info() {
const GLubyte* renderer = glGetString(GL_RENDERER);
const GLubyte* version = glGetString(GL_VERSION);
printf("Renderer: %s\n", renderer);
printf("OpenGL version supported %s\n", version);
//GLint count = 0;
//glGetIntegerv(GL_NUM_SHADER_BINARY_FORMATS, &count);
//printf("Binary formats: %d\n", count);
}
static void init_(struct Render* r1) {
struct RenderImpl* r = (struct RenderImpl*)r1;
gladLoadGL(glfwGetProcAddress);
// glEnable(GL_DEPTH_TEST);
glEnable(GL_TEXTURE_2D);
// glEnable(GL_BLEND);
// glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
// glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ZERO);
gl_info();
glGetIntegerv(GL_MAJOR_VERSION, &r->major);
glGetIntegerv(GL_MINOR_VERSION, &r->minor);
if (r->major > 4 || (r->major == 4 && r->minor >= 3)) {
glEnable(GL_DEBUG_OUTPUT);
glDebugMessageCallback(message_callback, 0);
}
glfwSwapInterval(r->cfg.vsync != 0); // vsync
GLint n_extensions = 0;
glGetIntegerv(GL_NUM_EXTENSIONS, &n_extensions);
for (int i = 0; i < n_extensions; i++) {
printf("Ext: '%s'\n", glGetStringi(GL_EXTENSIONS, i));
}
}
ktxTexture* ktx_ASTC2RGB(ktxTexture* tex);
static struct Texture* tex_new(struct Render* r, void* data, enum TexType tex_type)
{
// TODO: check tex_type
ktxTexture* texture = data;
KTX_error_code result = KTX_SUCCESS;
GLenum glError = 0;
GLuint* tex_id = calloc(1, sizeof(tex_id)); // TODO
GLenum target = 0; // TODO
result = ktxTexture_GLUpload(texture, tex_id, &target, &glError);
if (result != KTX_SUCCESS) {
texture = ktx_ASTC2RGB(texture);
result = ktxTexture_GLUpload(texture, tex_id, &target, &glError);
ktxTexture_Destroy(texture);
}
verify (result == KTX_SUCCESS);
return (struct Texture*)tex_id;
}
struct PipelineBuilder* pipeline_builder_opengl(struct Render*);
struct Render* rend_opengl_new(struct RenderConfig cfg)
{
struct RenderImpl* r = calloc(1, sizeof(*r));
struct Render base = {
.free = rend_free_,
.char_new = rend_char_new_,
.set_view_entity = set_view_entity_,
.draw_begin = draw_begin_,
.draw_end = draw_end_,
.init = init_,
.pipeline = pipeline_builder_opengl,
.set_viewport = set_viewport,
.buffer_manager = buf_mgr_opengl_new,
.tex_new = tex_new,
};
r->base = base;
r->cfg = cfg;
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
#ifdef __APPLE__
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 1);
#else
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 6);
#endif
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, 1);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
return (struct Render*)r;
}
|
resetius/graphtoys
|
vulkan/buffer.c
|
#include <stdlib.h>
#include <assert.h>
#include <string.h>
#include <stdio.h>
#include <render/buffer.h>
#include <render/render.h>
#include "render_impl.h"
#include "buffer.h"
#include "tools.h"
struct BufferManagerImpl {
struct BufferManagerBase base;
struct RenderImpl* r;
};
static int create(
struct BufferManager* mgr,
enum BufferType type,
enum BufferMemoryType mem_type,
const void* data,
int size)
{
struct BufferManagerImpl* b = (struct BufferManagerImpl*)mgr;
struct RenderImpl* r = b->r;
struct BufferImpl* buf = (struct BufferImpl*)b->base.iface.acquire(mgr, size);
int i;
buf->size = size;
buf->n_buffers = 1;
VkBuffer stagingBuffer;
VkDeviceMemory stagingBufferMemory;
uint32_t vk_type = VK_BUFFER_USAGE_VERTEX_BUFFER_BIT;
if (type == BUFFER_UNIFORM) {
vk_type = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT;
buf->n_buffers = r->sc.n_images;
}
if (type == BUFFER_SHADER_STORAGE) {
vk_type = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT;
}
if (type == BUFFER_INDEX) {
vk_type = VK_BUFFER_USAGE_INDEX_BUFFER_BIT;
}
for (i = 0; i < buf->n_buffers; i++) {
create_buffer(
r->memory_properties, r->log_dev,
buf->size,
VK_BUFFER_USAGE_TRANSFER_SRC_BIT | vk_type,
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
//VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
&stagingBuffer,
&stagingBufferMemory);
assert(data || mem_type == MEMORY_DYNAMIC);
if (data) {
void* dst;
vkMapMemory(r->log_dev, stagingBufferMemory, 0, size, 0, &dst);
memcpy(dst, data, size);
vkUnmapMemory(r->log_dev, stagingBufferMemory);
}
if (mem_type == MEMORY_DYNAMIC) {
buf->buffer[i] = stagingBuffer;
buf->memory[i] = stagingBufferMemory;
} else {
create_buffer(
r->memory_properties, r->log_dev,
size,
VK_BUFFER_USAGE_TRANSFER_DST_BIT|vk_type,
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
&buf->buffer[i],
&buf->memory[i]);
copy_buffer(
r->graphics_family,
r->g_queue, r->log_dev,
stagingBuffer,
buf->buffer[i], size);
vkDestroyBuffer(r->log_dev, stagingBuffer, NULL);
vkFreeMemory(r->log_dev, stagingBufferMemory, NULL);
}
}
return buf->base.id;
}
static void update(
struct BufferManager* mgr,
int id,
const void* data,
int offset,
int size)
{
struct BufferManagerImpl* b = (struct BufferManagerImpl*)mgr;
struct BufferImpl* buf = (struct BufferImpl*)mgr->get(mgr, id);
struct RenderImpl* r = b->r;
void* dest;
int i = (buf->n_buffers == 1)
? 0
: r->image_index;
vkMapMemory(r->log_dev, buf->memory[i], offset, size, 0, &dest);
memcpy(dest, data, size);
vkUnmapMemory(r->log_dev, buf->memory[i]);
}
static void release(struct BufferManager* mgr, void* buf1) {
int i;
struct BufferManagerImpl* b = (struct BufferManagerImpl*)mgr;
struct BufferImpl* buf = (struct BufferImpl*)buf1;
struct RenderImpl* r = b->r;
for (i = 0; i < buf->n_buffers; i++) {
vkDestroyBuffer(r->log_dev, buf->buffer[i], NULL);
vkFreeMemory(r->log_dev, buf->memory[i], NULL);
}
}
struct BufferManager* buf_mgr_vulkan_new(struct Render* r) {
struct BufferManagerImpl* b = calloc(1, sizeof(*b));
buffermanager_base_ctor(&b->base, sizeof(struct BufferImpl));
b->base.iface.create = create;
b->base.iface.release = release;
b->base.iface.update = update;
b->r = (struct RenderImpl*)r;
return (struct BufferManager*)b;
}
|
resetius/graphtoys
|
models/particles_data.h
|
<reponame>resetius/graphtoys
#pragma once
struct ParticlesData {
float* coords;
float* vels;
float* accel;
int* indices;
int n_particles;
};
struct Config;
void particles_data_init(struct ParticlesData* data, struct Config* cfg);
void particles_data_destroy(struct ParticlesData* data);
|
resetius/graphtoys
|
vulkan/device.c
|
<gh_stars>0
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "device.h"
void device_new(struct Device* dev, VkPhysicalDevice gpu, const char** enable, int n_enable, const VkDeviceQueueCreateInfo* queue_info, int n_queue_info) {
memset(dev, 0, sizeof(*dev));
vkEnumerateDeviceExtensionProperties(gpu, NULL, &dev->n_extensions, NULL);
dev->extensions = malloc(dev->n_extensions*sizeof(VkExtensionProperties));
dev->enabled_extensions = malloc(dev->n_extensions*sizeof(const char*));
vkEnumerateDeviceExtensionProperties(gpu, NULL, &dev->n_extensions, dev->extensions);
for (int i = 0; i < dev->n_extensions; i++) {
for (int j = 0; j < n_enable; j++) {
if (!strcmp(dev->extensions[i].extensionName, enable[j])) {
dev->enabled_extensions[dev->n_enabled_extensions++] = dev->extensions[i].extensionName;
break;
}
}
printf("'%s'\n", dev->extensions[i].extensionName);
}
printf("enabling the following (%d of %d):\n", dev->n_enabled_extensions, n_enable);
for (int i = 0; i < dev->n_enabled_extensions; i++) {
printf("'%s'\n", dev->enabled_extensions[i]);
}
VkPhysicalDeviceFeatures features = {
//.samplerAnisotropy = VK_TRUE,
.vertexPipelineStoresAndAtomics = VK_TRUE,
.largePoints = VK_TRUE,
};
VkDeviceCreateInfo info = {
.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,
.pQueueCreateInfos = queue_info,
.queueCreateInfoCount = n_queue_info,
.pEnabledFeatures = &features,
.enabledExtensionCount = dev->n_enabled_extensions,
.ppEnabledExtensionNames = dev->enabled_extensions,
.enabledLayerCount = 0
};
if (vkCreateDevice(gpu, &info, NULL, &dev->dev) != VK_SUCCESS) {
fprintf(stderr, "Cannot create logical device\n");
exit(-1);
}
}
int device_ext_is_enabled(struct Device* dev, const char* name) {
for (int i = 0; i < dev->n_enabled_extensions; i++) {
if (!strcmp(dev->enabled_extensions[i], name)) {
return 1;
}
}
return 0;
}
void device_free(struct Device* dev) {
free(dev->extensions);
free(dev->enabled_extensions);
}
|
resetius/graphtoys
|
test/config.c
|
#include <stdarg.h>
#include <stddef.h>
#include <setjmp.h>
#include <cmocka.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <lib/config.h>
static void get_config_fname(char* out, int size, const char* dir, const char* config) {
memset(out, 0, size);
strncpy(out, dir, size-256);
strcat(out, config);
}
static void test_parse(void** state)
{
char buf[10240];
get_config_fname(buf, sizeof(buf), (char*)*state, "config1.ini");
struct Config* cfg = cfg_new(buf, 0, NULL);
//cfg_print(cfg);
assert_string_equal(cfg_gets(cfg, "section1:key1"), "value");
assert_int_equal(cfg_geti(cfg, "section1:key2"), 1234);
assert_float_equal(cfg_getf_def(cfg, "section1:key3", 0), 1234.567, 1e-15);
assert_string_equal(cfg_gets_def(cfg, "section2:key0", "value1"), "value1");
assert_int_equal(cfg_geti(cfg, "section2:key2"), 4321);
assert_int_equal(cfg_geti_def(cfg, "section2:key0", -1), -1);
cfg_free(cfg);
}
static void test_rewrite(void** state)
{
char buf[10240];
char* argv[] = {"--section1:key1=value2", "--section1:key3=5431.1"};
get_config_fname(buf, sizeof(buf), (char*)*state, "config1.ini");
struct Config* cfg = cfg_new(buf, sizeof(argv)/sizeof(argv[0]), argv);
//cfg_print(cfg);
assert_string_equal(cfg_gets(cfg, "section1:key1"), "value2");
assert_float_equal(cfg_getf_def(cfg, "section1:key3", 0), 5431.1, 1e-15);
cfg_free(cfg);
}
static void test_newkey(void** state)
{
char buf[10240];
char* argv[] = {"--section1:key6=value2", "--section1:key7=5431.1"};
get_config_fname(buf, sizeof(buf), (char*)*state, "config1.ini");
struct Config* cfg = cfg_new(buf, sizeof(argv)/sizeof(argv[0]), argv);
//cfg_print(cfg);
assert_string_equal(cfg_gets(cfg, "section1:key6"), "value2");
assert_float_equal(cfg_getf_def(cfg, "section1:key7", 0), 5431.1, 1e-15);
cfg_free(cfg);
}
int main(int argc, char** argv) {
char dir[10240] = {0};
if (argc > 1) {
strncpy(dir, argv[1], sizeof(dir)-1);
strcat(dir, "/test/");
}
const struct CMUnitTest tests[] = {
cmocka_unit_test_prestate(test_parse, dir),
cmocka_unit_test_prestate(test_rewrite, dir),
cmocka_unit_test_prestate(test_newkey, dir),
};
return cmocka_run_group_tests(tests, NULL, NULL);
}
|
resetius/graphtoys
|
models/gltf.c
|
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <lib/formats/gltf.h>
#include <lib/object.h>
#include <lib/linmath.h>
#include <lib/camera.h>
#include <lib/config.h>
#include <lib/event.h>
#include <render/pipeline.h>
#include <models/base.frag.h>
#include <models/base.vert.h>
#include <models/base.frag.spv.h>
#include <models/base.vert.spv.h>
double glfwGetTime();
struct Vertex {
vec2 tex;
vec3 col;
vec3 pos;
vec3 norm;
};
struct UniformBlock {
mat4x4 mv;
mat4x4 mvp;
mat4x4 norm;
vec4 light;
};
struct Node {
struct UniformBlock uniform;
struct Pipeline* pl;
int n_vertices;
int index_byte_size;
int index;
int model;
int uniform_id;
mat4x4 matrix;
int skip;
void* tex;
};
struct Model {
struct Object base;
struct BufferManager* b;
struct Camera cam;
struct CameraEventConsumer cons;
vec4 light;
struct Node* nodes;
int cap_nodes;
int n_nodes;
float scale;
};
static void draw_node(struct Model* t, struct Node* n, mat4x4 v, mat4x4 p) {
mat4x4 m, mv, mvp;
mat4x4_identity(m);
memcpy(m, n->matrix, sizeof(n->matrix));
mat4x4_scale(m, m, t->scale);
m[3][3] = 1;
mat4x4_mul(mv, v, m);
mat4x4_mul(mvp, p, mv);
mat4x4 norm;
memcpy(norm, mv, sizeof(norm));
norm[3][0] = norm[3][1] = norm[3][2] = 0;
norm[0][3] = norm[1][3] = norm[2][3] = 0;
norm[3][3] = 1;
memcpy(n->uniform.mvp, mvp, sizeof(mvp));
memcpy(n->uniform.mv, mv, sizeof(mv));
memcpy(n->uniform.norm, norm, sizeof(norm));
mat4x4_mul_vec4(n->uniform.light, v, t->light);
n->pl->start(n->pl);
if (n->tex) {
n->pl->use_texture(n->pl, n->tex);
}
buffer_update(t->b, n->uniform_id, &n->uniform, 0, sizeof(n->uniform));
n->pl->draw_indexed(n->pl, n->model, n->index, n->index_byte_size);
}
static void t_draw(struct Object* obj, struct DrawContext* ctx) {
struct Model* t = (struct Model*)obj;
mat4x4 v, p;
t->cam.aspect = ctx->ratio;
cam_update(v, p, &t->cam);
for (int i = 0; i < t->n_nodes; i++) {
if (!t->nodes[i].skip) {
draw_node(t, &t->nodes[i], v, p);
}
}
}
static void t_free(struct Object* obj) {
struct Model* t = (struct Model*)obj;
for (int i = 0; i < t->n_nodes; i++) {
if (!t->nodes[i].skip) {
t->nodes[i].pl->free(t->nodes[i].pl);
}
}
free(t->nodes);
t->b->free(t->b);
free(t);
}
#include <glad/gl.h>
#include <lib/verify.h>
static int el_size(int type) {
switch (type) {
case GL_FLOAT: return 4;
case GL_UNSIGNED_SHORT: return 2;
case GL_UNSIGNED_INT: return 4;
case GL_UNSIGNED_BYTE: return 1;
};
printf("type: %d\n", type);
verify(type == -1);
return -1;
}
void load_node(struct Render* r, struct BufferManager* b, struct Node* n, int i, struct Gltf* gltf, void** images, struct ShaderCode* vertex_shader, struct ShaderCode* fragment_shader) {
// TODO
int mesh = gltf->nodes[i].mesh;
memcpy(n->matrix, gltf->nodes[i].matrix, sizeof(n->matrix));
n->skip = 0;
int nvertices = gltf->accessors[gltf->meshes[mesh].primitives[0].indices].count;
int npos = gltf->accessors[gltf->meshes[mesh].primitives[0].position].count;
struct Vertex* vertices = malloc(npos*sizeof(struct Vertex));
// TODO: loop on primitives
int normal = gltf->meshes[mesh].primitives[0].normal;
int ind_view = gltf->accessors[gltf->meshes[mesh].primitives[0].indices].view;
int pos_view = gltf->accessors[gltf->meshes[mesh].primitives[0].position].view;
int norm_view = normal >= 0 ? gltf->accessors[normal].view : -1;
int material_id = gltf->meshes[mesh].primitives[0].material;
struct GltfMaterial* material = material_id >= 0
? &gltf->materials[material_id]
: NULL;
int tex_view = -1;
int tex_components = -1;
int tex_type = -1;
int tex_stride = -1;
int tex_size = -1;
if (gltf->meshes[mesh].primitives[0].texcoord[0] >= 0) {
tex_view = gltf->accessors[gltf->meshes[mesh].primitives[0].texcoord[0]].view;
tex_components = gltf->accessors[gltf->meshes[mesh].primitives[0].texcoord[0]].components;
tex_type = gltf->accessors[gltf->meshes[mesh].primitives[0].texcoord[0]].component_type;
tex_size = tex_components*el_size(tex_type);
tex_stride = gltf->views[tex_view].stride
? gltf->views[tex_view].stride
: tex_size;
}
int pos_components = gltf->accessors[gltf->meshes[mesh].primitives[0].position].components;
int norm_components = normal >= 0 ? gltf->accessors[normal].components : -1;
int ind_type = gltf->accessors[gltf->meshes[mesh].primitives[0].indices].component_type;
int pos_type = gltf->accessors[gltf->meshes[mesh].primitives[0].position].component_type;
int norm_type = normal >= 0 ? gltf->accessors[normal].component_type : -1;
char* pos_data = gltf->views[pos_view].data +
gltf->accessors[gltf->meshes[mesh].primitives[0].position].offset;
char* norm_data = norm_view >= 0 ? gltf->views[norm_view].data +
gltf->accessors[normal].offset : NULL;
char* tex_data = NULL;
if (tex_view >= 0) {
tex_data = gltf->views[tex_view].data +
gltf->accessors[gltf->meshes[mesh].primitives[0].texcoord[0]].offset;
}
int pos_size = pos_components*el_size(pos_type);
int norm_size = norm_components*el_size(norm_type);
int ind_size = nvertices*el_size(ind_type);
int pos_stride = gltf->views[pos_view].stride
? gltf->views[pos_view].stride
: pos_size;
int norm_stride = norm_view >= 0 ?
(gltf->views[norm_view].stride
? gltf->views[norm_view].stride
: norm_size)
: -1;
printf("indview: %d\n", ind_view);
char* indices = gltf->views[ind_view].data+gltf->accessors[gltf->meshes[mesh].primitives[0].indices].offset;
n->index_byte_size = el_size(gltf->accessors[gltf->meshes[mesh].primitives[0].indices].component_type);
if (material
&& material->has_pbr_metallic_roughness
&& material->pbr_metallic_roughness.has_base_color_texture
&& material->pbr_metallic_roughness.base_color_texture.tex_coord == 0 /*TODO*/)
{
int index = material->pbr_metallic_roughness.base_color_texture.index;
int source = gltf->textures[index].source;
printf("Use %d '%s' %p\n", source, gltf->images[source].name, gltf->images[source].texture); fflush(stdout);
n->tex = images[source];
} else if (material && images[mesh]) {
n->tex = images[mesh];
} else {
n->tex = NULL;
}
if (n->index_byte_size == 1) {
n->index_byte_size = 2;
unsigned short* new_indices = malloc(ind_size*2);
for (int i = 0; i < ind_size; i++) {
new_indices[i] = (unsigned char)indices[i];
}
n->index = buffer_create(b, BUFFER_INDEX, MEMORY_STATIC, new_indices, ind_size*2);
free(new_indices);
} else {
n->index = buffer_create(b, BUFFER_INDEX, MEMORY_STATIC, indices, ind_size);
}
printf("> nvertices: %d %d %d\n", npos, nvertices, ind_size);
printf("> pos size/stride: %d %d\n", pos_size, pos_stride);
printf("> norm size/stride: %d %d\n", norm_size, norm_stride);
int k = 0;
for (int i = 0; i < npos; i ++) {
memcpy(vertices[k].pos, &pos_data[i*pos_stride], pos_size);
if (normal >= 0) {
memcpy(vertices[k].norm, &norm_data[i*norm_stride], norm_size);
} else {
// TODO: calc normal
vertices[k].norm[0] = 0.0; vertices[k].norm[1] = 0.0; vertices[k].norm[2] = 1.0;
}
if (tex_data) {
memcpy(vertices[k].tex, &tex_data[i*tex_stride], tex_size);
}
if (n->tex) {
// TODO
vertices[k].col[0] = 0.0;
vertices[k].col[1] = 0.0;
vertices[k].col[2] = 0.0;
} else if (material && material->has_pbr_metallic_roughness) {
memcpy(vertices[k].col, material->pbr_metallic_roughness.base_color_factor,
3*sizeof(float));
} else {
vertices[k].col[0] = 1.0;
vertices[k].col[1] = 0.0;
vertices[k].col[2] = 1.0;
}
//printf("%f %f %f %f %f %f %d\n",
// vertices[k].pos[0], vertices[k].pos[1], vertices[k].pos[2],
// vertices[k].norm[0], vertices[k].norm[1], vertices[k].norm[2],
// indices[i]
// );
k++;
}
if (normal < 0) {
int sz = ind_size / nvertices;
for (int i = 0; i < nvertices; i+=3) {
unsigned x, y, z;
x = y = z = 0;
memcpy(&x, &indices[i*sz], sz);
memcpy(&y, &indices[(i+1)*sz], sz);
memcpy(&z, &indices[(i+2)*sz], sz);
vec3 a,b,n;
vec3_sub(a, vertices[z].pos, vertices[x].pos);
vec3_sub(b, vertices[y].pos, vertices[x].pos);
vec3_mul_cross(n, a, b);
vec3_norm(n, n);
memcpy(vertices[x].norm, n, sizeof(n));
memcpy(vertices[y].norm, n, sizeof(n));
memcpy(vertices[z].norm, n, sizeof(n));
}
}
// TODO: use indices
struct PipelineBuilder* pl = r->pipeline(r);
n->pl = pl
->set_bmgr(pl, b)
->begin_program(pl)
->add_vs(pl, *vertex_shader)
->add_fs(pl, *fragment_shader)
->end_program(pl)
->uniform_add(pl, 0, "MatrixBlock")
->begin_buffer(pl, sizeof(struct Vertex))
->buffer_attribute(pl, 4, 2, DATA_FLOAT, offsetof(struct Vertex, tex))
->buffer_attribute(pl, 3, 3, DATA_FLOAT, offsetof(struct Vertex, col))
->buffer_attribute(pl, 2, 3, DATA_FLOAT, offsetof(struct Vertex, norm))
->buffer_attribute(pl, 1, 3, DATA_FLOAT, offsetof(struct Vertex, pos))
->end_buffer(pl)
->begin_sampler(pl, 0)
// TODO: read sampler properties from Glft
->sampler_min_filter(pl, FILTER_LINEAR_MIPMAP_LINEAR)
->sampler_wrap_s(pl, WRAP_REPEAT)
->sampler_wrap_t(pl, WRAP_REPEAT)
->end_sampler(pl)
->enable_depth(pl)
->build(pl);
n->uniform_id = buffer_create(b, BUFFER_UNIFORM, MEMORY_DYNAMIC, NULL, sizeof(struct UniformBlock));
n->pl->uniform_assign(n->pl, 0, n->uniform_id);
int model_buffer_id = buffer_create(b, BUFFER_ARRAY, MEMORY_STATIC, vertices, k*sizeof(struct Vertex));
n->model = pl_buffer_assign(n->pl, 0, model_buffer_id);
free(vertices);
}
//char* gltf_file_by_name(struct Gltf* gltf, const char* name, int64_t* size); // TODO
void* gltf_load_image_uri(const char* fname); // TODO
struct Object* CreateGltf(struct Render* r, struct Config* cfg, struct EventProducer* events) {
struct Model* t = calloc(1, sizeof(struct Model));
struct Object base = {
.draw = t_draw,
.free = t_free,
};
struct ShaderCode vertex_shader = {
.glsl = models_base_vert,
.spir_v = models_base_vert_spv,
.size = models_base_vert_spv_size,
};
struct ShaderCode fragment_shader = {
.glsl = models_base_frag,
.spir_v = models_base_frag_spv,
.size = models_base_frag_spv_size,
};
t->base = base;
vec4 light = {0, -40, 0, 1};
vec4_dup(t->light, light);
const char* fn = cfg_gets_def(cfg, "name", "./assets/khr/scenes/sponza/Sponza01.gltf");
t->scale = cfg_getf_def(cfg, "scale", 1.0);
t->b = r->buffer_manager(r);
struct Gltf gltf;
gltf_ctor(&gltf, fn);
t->cam.fov = 70*M_PI/180;
t->cam.aspect = 1.77;
t->cam.znear = 0.001;
t->cam.zfar = 100000;
cam_init(&t->cam);
vec3 tr = {0, 0.5, 0};
t->cam.znear = 0.001;
cam_translate(&t->cam, tr);
double t1 = glfwGetTime();
void** images = malloc(gltf.n_images * sizeof(void*));
for (int i = 0; i < gltf.n_images; i++) {
printf("Loading '%s'\n", gltf.images[i].name); fflush(stdout);
images[i] = r->tex_new(r, gltf.images[i].texture, TEX_KTX);
}
if (gltf.n_images == 0) {
// load by mesh name
images = realloc(images, gltf.n_meshes * sizeof(void*));
char buf[10240];
strcpy(buf, gltf.fsbase);
int l = strlen(buf);
for (int i = 0; i < gltf.n_meshes; i++) {
strncat(buf, gltf.meshes[i].name, sizeof(buf)-10-l);
strcat(buf, ".ktx");
printf("Loading '%s'\n", buf);
char* img = gltf_load_image_uri(buf); // gltf_file_by_name(&gltf, buf, &size);
images[i] = img ? r->tex_new(r, img, TEX_KTX) : NULL;
buf[l] = 0;
}
}
printf("Loaded in %f\n", glfwGetTime() - t1);
//exit(1);
for (int i = 0; i < gltf.n_nodes; i++) {
if (gltf.nodes[i].camera >= 0) {
// TODO: multiple cameras
struct GltfCamera* c = &gltf.cameras[gltf.nodes[i].camera];
if (c->is_perspective) {
printf("Load camera\n");
t->cam.fov = c->perspective.yfov;
t->cam.aspect = c->perspective.aspect;
t->cam.znear = c->perspective.znear;
t->cam.zfar = c->perspective.zfar;
cam_init(&t->cam);
cam_rotate(&t->cam, gltf.nodes[i].rotation);
cam_translate(&t->cam, gltf.nodes[i].translation);
}
}
if (! (gltf.nodes[i].mesh >= 0 && gltf.meshes[gltf.nodes[i].mesh].n_primitives > 0) ) {
continue;
}
if (t->n_nodes >= t->cap_nodes) {
t->cap_nodes = (1+t->cap_nodes)*2;
t->nodes = realloc(t->nodes, t->cap_nodes*sizeof(struct Node));
}
load_node(r, t->b, &t->nodes[t->n_nodes++], i, &gltf, images,
&vertex_shader, &fragment_shader);
}
vec3_scale(t->cam.eye, t->cam.eye, t->scale);
vec3_scale(t->cam.center, t->cam.center, t->scale);
gltf_dtor(&gltf);
free(images); // TODO
cam_event_consumer_init(&t->cons, &t->cam);
events->subscribe(events, (struct EventConsumer*) &t->cons);
return (struct Object*)t;
}
|
resetius/graphtoys
|
vulkan/render_impl.h
|
#pragma once
#include "vk.h"
#define GLFW_INCLUDE_NONE
#include <GLFW/glfw3.h>
#include <render/render.h>
#include "swapchain.h"
#include "renderpass.h"
#include "rendertarget.h"
#include "commandbuffer.h"
#include "device.h"
#include "frame.h"
struct Texture {
VkImage tex;
VkDeviceMemory memory;
VkImageView view;
// TODO: remove it from here
VkDescriptorSet set;
int has_set;
};
struct RenderImpl {
struct Render base;
struct RenderConfig cfg;
VkInstance instance;
VkSurfaceKHR surface;
// Physical Device
VkPhysicalDevice phy_dev;
VkSurfaceCapabilitiesKHR caps;
VkSurfaceFormatKHR* formats;
uint32_t n_formats;
VkPresentModeKHR* modes;
uint32_t n_modes;
int graphics_family;
int present_family;
int compute_family;
// Logical Device
struct Device device;
VkDevice log_dev;
VkQueue g_queue;
VkQueue p_queue;
// GLFW specific
GLFWwindow* window;
// gpu
VkPhysicalDeviceFeatures features;
VkPhysicalDeviceMemoryProperties memory_properties;
VkPhysicalDeviceProperties properties;
//
struct SwapChain sc;
struct RenderPass rp;
struct RenderTarget rt;
struct Frame frames[5];
struct Frame* frame;
//
uint32_t image_index;
VkCommandBuffer buffer;
VkSemaphore recycled_semaphores[10];
int n_recycled_semaphores;
//
VkViewport viewport;
VkRect2D scissor;
int update_viewport;
struct VkStats* stats;
};
|
resetius/graphtoys
|
vulkan/tools.c
|
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <lib/verify.h>
#include "tools.h"
#include "render_impl.h"
#include <ktxvulkan.h>
static uint32_t findMemoryTypeIndex(VkPhysicalDeviceMemoryProperties* props, uint32_t typeFilter, VkMemoryPropertyFlags flags)
{
for (uint32_t i = 0; i < props->memoryTypeCount; i++) {
if ((typeFilter & (1 << i)) &&
(props->memoryTypes[i].propertyFlags & flags) == flags)
{
return i;
}
}
fprintf(stderr, "Failed to find suitable memory type\n");
exit(-1);
return 0;
}
void create_buffer(
VkPhysicalDeviceMemoryProperties props,
VkDevice logicalDevice,
VkDeviceSize size,
VkBufferUsageFlags usage,
VkMemoryPropertyFlags properties,
VkBuffer* buffer,
VkDeviceMemory* bufferMemory)
{
VkBufferCreateInfo bufferInfo = {
.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
.size = size,
.usage = usage,
.sharingMode = VK_SHARING_MODE_EXCLUSIVE
};
assert(size);
if (vkCreateBuffer(logicalDevice, &bufferInfo, NULL, buffer) != VK_SUCCESS) {
fprintf(stderr, "Failed to create vertex buffer\n");
exit(-1);
}
VkMemoryRequirements memrequirements;
vkGetBufferMemoryRequirements(logicalDevice, *buffer, &memrequirements);
VkMemoryAllocateInfo allocInfo = {
.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
.allocationSize = memrequirements.size,
.memoryTypeIndex = findMemoryTypeIndex(&props, memrequirements.memoryTypeBits, properties)
};
if (vkAllocateMemory(logicalDevice, &allocInfo, NULL, bufferMemory) != VK_SUCCESS) {
fprintf(stderr, "Failed to allocate vertex buffer memory\n");
exit(-1);
}
vkBindBufferMemory(logicalDevice, *buffer, *bufferMemory, 0);
}
static VkCommandBuffer beginSingleTimeCommands(VkDevice logicalDevice, VkCommandPool commandPool) {
VkCommandBufferAllocateInfo allocInfo = {
.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY,
.commandPool = commandPool,
.commandBufferCount = 1
};
VkCommandBuffer commandBuffer;
vkAllocateCommandBuffers(logicalDevice, &allocInfo, &commandBuffer);
VkCommandBufferBeginInfo beginInfo = {
.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT
};
vkBeginCommandBuffer(commandBuffer, &beginInfo);
return commandBuffer;
}
static void endSingleTimeCommands(VkDevice logicalDevice, VkQueue g_queue, VkCommandBuffer commandBuffer, VkCommandPool commandPool)
{
vkEndCommandBuffer(commandBuffer);
VkSubmitInfo submitInfo = {
.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO,
.commandBufferCount = 1,
.pCommandBuffers = &commandBuffer
};
vkQueueSubmit(g_queue, 1, &submitInfo, VK_NULL_HANDLE);
vkQueueWaitIdle(g_queue);
vkFreeCommandBuffers(logicalDevice, commandPool, 1, &commandBuffer);
}
void copy_buffer(
int graphics_family,
VkQueue g_queue,
VkDevice logicalDevice,
VkBuffer srcBuffer,
VkBuffer dstBuffer,
VkDeviceSize size)
{
// Create Command Pool
VkCommandPool commandPool;
VkCommandPoolCreateInfo cpInfo = {
.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,
.queueFamilyIndex = graphics_family,
.flags = 0
};
if (vkCreateCommandPool(logicalDevice, &cpInfo, NULL, &commandPool) != VK_SUCCESS) {
fprintf(stderr, "Failed to create command pool\n");
exit(-1);
}
VkCommandBuffer commandBuffer = beginSingleTimeCommands(logicalDevice, commandPool);
VkBufferCopy copyregion = {
copyregion.srcOffset = 0,
copyregion.dstOffset = 0,
copyregion.size = size
};
vkCmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, 1, ©region);
endSingleTimeCommands(logicalDevice, g_queue, commandBuffer, commandPool);
vkDestroyCommandPool(logicalDevice, commandPool, NULL);
}
void create_image(
VkPhysicalDeviceMemoryProperties props,
VkDevice device,
uint32_t width,
uint32_t height,
VkFormat format,
VkImageTiling tiling,
VkImageUsageFlags usage,
VkMemoryPropertyFlags properties,
VkImage* image,
VkDeviceMemory* imageMemory)
{
VkImageCreateInfo imageInfo = {
.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
.imageType = VK_IMAGE_TYPE_2D,
.extent.width = width,
.extent.height = height,
.extent.depth = 1,
.mipLevels = 1,
.arrayLayers = 1,
.format = format,
.tiling = tiling,
.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED,
.usage = usage,
.samples = VK_SAMPLE_COUNT_1_BIT,
.sharingMode = VK_SHARING_MODE_EXCLUSIVE,
};
if (vkCreateImage(device, &imageInfo, NULL, image) != VK_SUCCESS) {
fprintf(stderr, "Failed to create image\n");
exit(-1);
}
VkMemoryRequirements memRequirements;
vkGetImageMemoryRequirements(device, *image, &memRequirements);
VkMemoryAllocateInfo allocInfo = {
.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
.allocationSize = memRequirements.size,
.memoryTypeIndex = findMemoryTypeIndex(
&props, memRequirements.memoryTypeBits, properties)
};
if (vkAllocateMemory(device, &allocInfo, NULL, imageMemory) != VK_SUCCESS) {
fprintf(stderr, "Failed to allocate image memory\n");
exit(-1);
}
vkBindImageMemory(device, *image, *imageMemory, 0);
}
VkImageView create_image_view(
VkDevice logDev, VkImage image, VkFormat format, VkImageAspectFlags aspectFlags)
{
VkImageViewCreateInfo viewInfo = {
.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
.image = image,
.viewType = VK_IMAGE_VIEW_TYPE_2D,
.format = format,
.subresourceRange.aspectMask = aspectFlags,
.subresourceRange.baseMipLevel = 0,
.subresourceRange.levelCount = 1,
.subresourceRange.baseArrayLayer = 0,
.subresourceRange.layerCount = 1
};
VkImageView imageView;
if (vkCreateImageView(logDev, &viewInfo, NULL, &imageView) != VK_SUCCESS)
{
fprintf(stderr, "Failed to create texture image view\n");
exit(-1);
}
return imageView;
}
void transition_image_layout(
int graphics_family,
VkQueue g_queue,
VkDevice logicalDevice,
VkImage image, VkFormat format, VkImageLayout oldLayout, VkImageLayout newLayout)
{
// Create Command Pool
VkCommandPool commandPool;
VkCommandPoolCreateInfo cpInfo = {
.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,
.queueFamilyIndex = graphics_family,
.flags = 0
};
if (vkCreateCommandPool(logicalDevice, &cpInfo, NULL, &commandPool) != VK_SUCCESS) {
fprintf(stderr, "Failed to create command pool\n");
exit(-1);
}
VkCommandBuffer commandBuffer = beginSingleTimeCommands(logicalDevice, commandPool);
VkImageMemoryBarrier barrier = {
.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
.oldLayout = oldLayout,
.newLayout = newLayout,
.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
.image = image,
.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
.subresourceRange.baseMipLevel = 0,
.subresourceRange.levelCount = 1,
.subresourceRange.baseArrayLayer = 0,
.subresourceRange.layerCount = 1,
};
VkPipelineStageFlags sourceStage;
VkPipelineStageFlags destinationStage;
if (oldLayout == VK_IMAGE_LAYOUT_UNDEFINED && newLayout == VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL) {
barrier.srcAccessMask = 0;
barrier.dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
sourceStage = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
destinationStage = VK_PIPELINE_STAGE_TRANSFER_BIT;
} else if (oldLayout == VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL && newLayout == VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL) {
barrier.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
barrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT;
sourceStage = VK_PIPELINE_STAGE_TRANSFER_BIT;
destinationStage = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
} else {
fprintf(stderr, "Unsupported layout transition\n");
exit(-1);
}
vkCmdPipelineBarrier(
commandBuffer,
sourceStage, destinationStage,
0,
0, NULL,
0, NULL,
1, &barrier
);
endSingleTimeCommands(logicalDevice, g_queue, commandBuffer, commandPool);
vkDestroyCommandPool(logicalDevice, commandPool, NULL);
}
void copy_buffer_to_image(
int graphics_family,
VkQueue g_queue,
VkDevice logicalDevice,
VkBuffer buffer, VkImage image, uint32_t width, uint32_t height)
{
VkCommandPool commandPool;
VkCommandPoolCreateInfo cpInfo = {
.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,
.queueFamilyIndex = graphics_family,
.flags = 0
};
if (vkCreateCommandPool(logicalDevice, &cpInfo, NULL, &commandPool) != VK_SUCCESS) {
fprintf(stderr, "Failed to create command pool\n");
exit(-1);
}
VkCommandBuffer commandBuffer = beginSingleTimeCommands(logicalDevice, commandPool);
VkBufferImageCopy region = {
.bufferOffset = 0,
.bufferRowLength = 0,
.bufferImageHeight = 0,
.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
.imageSubresource.mipLevel = 0,
.imageSubresource.baseArrayLayer = 0,
.imageSubresource.layerCount = 1,
.imageOffset = {0, 0, 0},
.imageExtent = {
width,
height,
1
}
};
vkCmdCopyBufferToImage(commandBuffer, buffer, image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, ®ion);
endSingleTimeCommands(logicalDevice, g_queue, commandBuffer, commandPool);
vkDestroyCommandPool(logicalDevice, commandPool, NULL);
}
ktxTexture* ktx_ASTC2RGB(ktxTexture* tex);
struct Texture* vk_tex_new(struct Render* r1, void* data, enum TexType tex_type)
{
struct RenderImpl* r = (struct RenderImpl*)r1;
ktxVulkanDeviceInfo vdi;
VkCommandPool commandPool;
struct Texture* tex = calloc(1, sizeof(*tex));
VkCommandPoolCreateInfo cpInfo = {
.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,
.queueFamilyIndex = r->graphics_family,
.flags = 0
};
if (vkCreateCommandPool(r->log_dev, &cpInfo, NULL, &commandPool) != VK_SUCCESS) {
fprintf(stderr, "Failed to create command pool\n");
exit(-1);
}
ktxVulkanDeviceInfo_Construct(
&vdi,
r->phy_dev,
r->log_dev,
r->g_queue,
commandPool,
NULL);
ktxVulkanTexture vkTexture;
ktxTexture* t = data;
if (ktxTexture_VkUpload(t, &vdi, &vkTexture) != KTX_SUCCESS) {
t = ktx_ASTC2RGB(t);
// TODO: optimize
verify(ktxTexture_VkUpload(t, &vdi, &vkTexture) == KTX_SUCCESS);
ktxTexture_Destroy(t);
}
tex->tex = vkTexture.image;
tex->memory = vkTexture.deviceMemory;
VkImageViewCreateInfo viewInfo = {
.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
.image = tex->tex,
.viewType = vkTexture.viewType,
.format = vkTexture.imageFormat,
.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
.subresourceRange.levelCount = vkTexture.levelCount,
.subresourceRange.layerCount = vkTexture.layerCount,
};
if (vkCreateImageView(r->log_dev, &viewInfo, NULL, &tex->view) != VK_SUCCESS)
{
fprintf(stderr, "Failed to create texture image view\n");
exit(-1);
}
//printf("Level: %d\n", vkTexture.levelCount);
//vkDestroyCommandPool(r->log_dev, commandPool, NULL);
ktxVulkanDeviceInfo_Destruct(&vdi);
return tex;
}
|
resetius/graphtoys
|
models/torus.c
|
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <lib/object.h>
#include "torus.h"
#include <render/pipeline.h>
#include <render/buffer.h>
#include <lib/linmath.h>
#include <models/triangle.frag.h>
#include <models/torus.vert.h>
#include <models/triangle.frag.spv.h>
#include <models/torus.vert.spv.h>
// x = (R+r cos(psi)) cos phi
// y = (R+r cos(psi)) sin phi
// z = r sin phi
// psi in [0,2pi)
// phi in [-pi,pi)
struct Vertex {
vec3 col;
vec3 norm;
vec3 pos;
};
struct UniformBlock {
mat4x4 mv;
mat4x4 mvp;
mat4x4 norm;
};
struct Torus {
struct Object base;
struct UniformBlock uniform;
struct Pipeline* pl;
struct BufferManager* b;
int uniform_buffer_id;
int model_buffer_id;
int model; // vao
};
static struct Vertex* init (int* nvertices) {
float R = 0.5;
float r = 0.25;
int i,j,k;
#define N 50
#define M 50
int n = N;
int m = M;
struct Vertex A[N][M];
struct Vertex* vertices = calloc(n*m*3*2, sizeof(struct Vertex));
for (i = 0; i < n; i++) {
float phi = 2.f*M_PI*i/n;
for (j = 0; j < m; j++) {
float psi = 2.f*M_PI*j/m-M_PI/2.;
vec3 v;
v[0] = (R+r*cosf(psi))*cosf(phi);
v[1] = (R+r*cosf(psi))*sinf(phi);
v[2] = r*sinf(psi);
vec3 v1;
v1[0] = (R+(r+.1f)*cosf(psi))*cosf(phi);
v1[1] = (R+(r+.1f)*cosf(psi))*sinf(phi);
v1[2] = (r+.1f)*sinf(psi);
vec3_sub(v1, v1, v);
vec3_scale(v1, v1, 10.f);
memcpy(A[i][j].pos, v, sizeof(vec3));
memcpy(A[i][j].norm, v1, sizeof(vec3));
}
}
k = 0;
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
/*
{i,j},{i,j+1}
{i+1,j}
{i,j+1}
{i+1,j},{i+1,j+1}
*/
memcpy(&vertices[k++], &A[(i+1)%n][j], sizeof(struct Vertex));
memcpy(&vertices[k++], &A[i][(j+1)%m], sizeof(struct Vertex));
memcpy(&vertices[k++], &A[i][j], sizeof(struct Vertex));
memcpy(&vertices[k++], &A[i][(j+1)%m], sizeof(struct Vertex));
memcpy(&vertices[k++], &A[(i+1)%n][j], sizeof(struct Vertex));
memcpy(&vertices[k++], &A[(i+1)%n][(j+1)%m], sizeof(struct Vertex));
}
}
for (i = 0; i < k; i++) {
vec3 col = {
rand()/(float)RAND_MAX,
rand()/(float)RAND_MAX,
rand()/(float)RAND_MAX
};
memcpy(vertices[i].col, col, sizeof(col));
//vertices[i].col[0] = fmax(0, vertices[i].pos[2]);
}
printf("nvertices %d\n", k);
#undef N
#undef M
*nvertices = k;
return vertices;
}
static void t_draw(struct Object* obj, struct DrawContext* ctx) {
struct Torus* t = (struct Torus*)obj;
mat4x4 m, v, p, mv, mvp;
mat4x4_identity(m);
mat4x4_rotate_X(m, m, ctx->time);
mat4x4_rotate_Y(m, m, ctx->time);
mat4x4_rotate_Z(m, m, ctx->time);
vec3 eye = {.0f, .0f, 2.f};
vec3 center = {.0f, .0f, .0f};
vec3 up = {.0f, 1.f, .0f};
mat4x4_look_at(v, eye, center, up);
mat4x4_mul(mv, v, m);
//mat4x4_ortho(p, -ctx->ratio, ctx->ratio, -1.f, 1.f, 1.f, -1.f);
//mat4x4_identity(p);
mat4x4_perspective(p, 70.*M_PI/180, ctx->ratio, 0.3f, 100.f);
mat4x4_mul(mvp, p, mv);
mat4x4 norm;
//mat4x4_invert(norm4, mv);
//mat4x4_transpose(norm4, norm4);
//mat3x3 norm;
//mat3x3_from_mat4x4(norm, norm4);
//mat3x3_from_mat4x4(norm, mv);
memcpy(norm, mv, sizeof(norm));
norm[3][0] = norm[3][1] = norm[3][2] = 0;
norm[0][3] = norm[1][3] = norm[2][3] = 0;
norm[3][3] = 1;
memcpy(t->uniform.mvp, mvp, sizeof(mvp));
memcpy(t->uniform.mv, mv, sizeof(mv));
memcpy(t->uniform.norm, norm, sizeof(norm));
t->pl->start(t->pl);
t->b->update(t->b, t->uniform_buffer_id, &t->uniform, 0, sizeof(t->uniform));
t->pl->draw(t->pl, t->model);
}
static void t_free(struct Object* obj) {
struct Torus* t = (struct Torus*)obj;
t->pl->free(t->pl);
t->b->free(t->b);
free(t);
}
struct Object* CreateTorus(struct Render* r, struct Config* cfg) {
struct Torus* t = calloc(1, sizeof(struct Torus));
struct Object base = {
.draw = t_draw,
.free = t_free
};
struct Vertex* vertices;
int nvertices;
struct ShaderCode vertex_shader = {
.glsl = models_torus_vert,
.spir_v = models_torus_vert_spv,
.size = models_torus_vert_spv_size,
};
struct ShaderCode fragment_shader = {
.glsl = models_triangle_frag,
.spir_v = models_triangle_frag_spv,
.size = models_triangle_frag_spv_size,
};
t->base = base;
t->b = r->buffer_manager(r);
vertices = init(&nvertices);
struct PipelineBuilder* pl = r->pipeline(r);
t->pl = pl
->set_bmgr(pl, t->b)
->begin_program(pl)
->add_vs(pl, vertex_shader)
->add_fs(pl, fragment_shader)
->end_program(pl)
->uniform_add(pl, 0, "MatrixBlock")
->begin_buffer(pl, sizeof(struct Vertex))
->buffer_attribute(pl, 3, 3, DATA_FLOAT, offsetof(struct Vertex, col))
->buffer_attribute(pl, 2, 3, DATA_FLOAT, offsetof(struct Vertex, norm))
->buffer_attribute(pl, 1, 3, DATA_FLOAT, offsetof(struct Vertex, pos))
->end_buffer(pl)
->enable_depth(pl)
->enable_cull(pl, CULL_BACK)
->build(pl);
t->uniform_buffer_id = t->b->create(t->b, BUFFER_UNIFORM, MEMORY_DYNAMIC, NULL, sizeof(struct UniformBlock));
t->pl->uniform_assign(t->pl, 0, t->uniform_buffer_id);
t->model_buffer_id = t->b->create(t->b, BUFFER_ARRAY, MEMORY_STATIC, vertices, nvertices*sizeof(struct Vertex));
t->model = t->pl->buffer_assign(t->pl, 0, t->model_buffer_id);
free(vertices);
return (struct Object*)t;
}
|
resetius/graphtoys
|
lib/formats/base64.c
|
<gh_stars>0
#include "base64.h"
#include <lib/verify.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
static char enc_table[] = {
'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',
'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',
'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
'w', 'x', 'y', 'z', '0', '1', '2', '3',
'4', '5', '6', '7', '8', '9', '+', '/'
};
static unsigned char dec_table[] = {
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,62,0,0,0,63,
52,53,54,55,56,57,58,59,60,61,0,0,0,0,0,0,
0,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,
15,16,17,18,19,20,21,22,23,24,25,0,0,0,0,0,
0,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,
41,42,43,44,45,46,47,48,49,50,51,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
};
char* base64_decode(const char* input, int64_t size, int64_t* output_size) {
uint32_t part = 0;
int i=3,j;
char* output = malloc((size + 3) / 4 * 3 + 10);
int64_t len = 0;
for (j = 0; j < size && input[j] != '='; j++) {
part |= ((uint32_t)dec_table[(uint8_t)input[j]]) << (i*6);
if (i == 0) {
output[len++] = (part >> 2*8) & 0xFF;
output[len++] = (part >> 1*8) & 0xFF;
output[len++] = (part >> 0*8) & 0xFF;
part = 0;
}
i = (4+i-1)%4;
}
if (i != 3) {
output[len++] = (part >> 2*8) & 0xFF;
output[len++] = (part >> 1*8) & 0xFF;
output[len++] = (part >> 0*8) & 0xFF;
}
while (size > 0 && input[size-1] == '=') {
len--; size --;
}
output[len] = 0;
*output_size = len;
return output;
}
char* base64_encode(const char* input, int64_t size, int64_t* output_size) {
int i,j=0;
char* output = malloc(4 * ((size + 2) / 3) + 10);
uint32_t part = 0;
int len = 0;
j = 2;
for (i = 0; i < size; i++) {
part |= ((uint8_t)input[i]) << (j*8);
if (j == 0) {
output[len++] = enc_table[(part >> 3*6) & 0x3F];
output[len++] = enc_table[(part >> 2*6) & 0x3F];
output[len++] = enc_table[(part >> 1*6) & 0x3F];
output[len++] = enc_table[(part >> 0*6) & 0x3F];
part = 0;
}
j = (3+j-1)%3;
}
if (j != 2) {
output[len++] = enc_table[(part >> 3*6) & 0x3F];
output[len++] = enc_table[(part >> 2*6) & 0x3F];
output[len++] = enc_table[(part >> 1*6) & 0x3F];
output[len++] = enc_table[(part >> 0*6) & 0x3F];
}
if (size % 3 == 1) {
output[len - 1] = output[len - 2] = '=';
} else if (size % 3 == 2) {
output[len - 1] = '=';
}
output[len] = 0;
*output_size = len;
return output;
}
static void test_dec(const char* str, const char* dst) {
int64_t size;
char* out = base64_decode(str, strlen(str), &size);
printf("'%s'\n", out);
verify(!strcmp(out, dst));
verify(size == strlen(dst));
free(out);
}
static void test_enc(const char* str, const char* dst) {
int64_t size;
char* out = base64_encode(str, strlen(str), &size);
printf("'%s'\n", out);
verify(!strcmp(out, dst), out);
free(out);
}
int base64_test(int argc, char** argv) {
test_dec("dGVzdA==", "test");
test_dec("bG9uZyBsb25nIGxvbmcgdGV4dCB0ZXN0", "long long long text test");
test_dec("0YDRg9GB0YHQutC40Lkg0YLQtdC60YHRgg==", "русский текст");
test_enc("русский текст", "0YDRg9GB0YHQutC40Lkg0YLQtdC60YHRgg==");
test_enc("test", "dGVzdA==");
test_enc("long long long text test", "bG9uZyBsb25nIGxvbmcgdGV4dCB0ZXN0");
return 0;
}
#ifdef BASE64_TEST
int main(int argc, char** argv) {
return base64_test(argc, argv);
}
#endif
|
resetius/graphtoys
|
lib/camera.c
|
<reponame>resetius/graphtoys
#include <stdio.h>
#include "camera.h"
void cam_init(struct Camera* cam) {
vec3 eye = {0.0f, 0.0f, 0.f};
vec3 center = {.0f, .0f, -1.0f};
vec3 up = {.0f, 1.f, .0f};
memcpy(cam->eye, eye, sizeof(eye));
memcpy(cam->center, center, sizeof(center));
memcpy(cam->up, up, sizeof(up));
cam->fov = 70*M_PI/180.;
cam->aspect = 1.77;
cam->znear = 0.3;
cam->zfar = 100000;
}
void cam_update(mat4x4 v, mat4x4 p, struct Camera* cam) {
mat4x4_look_at(v, cam->eye, cam->center, cam->up);
mat4x4_perspective(p, cam->fov, cam->aspect, cam->znear, cam->zfar);
}
void cam_rotate(struct Camera* cam, quat q) {
vec3 v = {0.0, 0.0, 0.0};
float len;
vec3_sub(v, cam->center, cam->eye);
len = vec3_len(v);
quat_mul_vec3(v, q, v);
if (fabs(vec3_mul_inner(v, cam->up) / len / vec3_len(cam->up)) > 0.95) {
return;
}
vec3_add(cam->center, cam->center, v);
// preserve eye->center len
// v = center-eye, center = eye+v
vec3_sub(v, cam->center, cam->eye);
vec3_norm(v, v);
vec3_scale(v, v, len);
vec3_add(cam->center, cam->eye, v);
}
void cam_translate(struct Camera* cam, vec3 t) {
memcpy(cam->eye, t, sizeof(cam->eye));
}
#define GLFW_INCLUDE_NONE
#include <GLFW/glfw3.h>
static void rotate_x(struct Camera* cam, float angle) {
quat rot1;
quat_identity(rot1);
quat_rotate(rot1, angle, cam->up);
cam_rotate(cam, rot1);
}
static void rotate_y(struct Camera* cam, float angle) {
vec3 dir;
vec3_sub(dir, cam->center, cam->eye);
vec3 dir2;
vec3_mul_cross(dir2, dir, cam->up);
vec3_norm(dir2, dir2);
quat rot1;
quat_identity(rot1);
quat_rotate(rot1, angle, dir2);
cam_rotate(cam, rot1);
}
static void process_key(struct Camera* cam, int key)
{
vec3 dir;
vec3 dir1;
vec3_sub(dir, cam->center, cam->eye);
float len = vec3_len(dir);
vec3_scale(dir1, dir, 1.0/len);
float step = 10000/len;
vec3 dir2;
vec3_mul_cross(dir2, dir, cam->up);
vec3_norm(dir2, dir2);
vec3 dir3;
vec3_norm(dir3, cam->up);
float angle = -10*M_PI/180;
switch (key) {
case GLFW_KEY_S:
step = -step;
case GLFW_KEY_W:
vec3_scale(dir1, dir1, step);
vec3_add(cam->center, cam->center, dir1);
vec3_add(cam->eye, cam->eye, dir1);
break;
case GLFW_KEY_A:
step = -step;
case GLFW_KEY_D:
vec3_scale(dir2, dir2, step);
vec3_add(cam->center, cam->center, dir2);
vec3_add(cam->eye, cam->eye, dir2);
break;
case GLFW_KEY_C:
step = -step;
case GLFW_KEY_SPACE:
vec3_scale(dir3, dir3, step);
vec3_add(cam->center, cam->center, dir3);
vec3_add(cam->eye, cam->eye, dir3);
break;
case GLFW_KEY_LEFT:
angle = -angle;
case GLFW_KEY_RIGHT:
rotate_x(cam, angle);
break;
case GLFW_KEY_UP:
angle = -angle;
case GLFW_KEY_DOWN:
rotate_y(cam, angle);
default:
break;
}
}
static void cam_key_event(struct EventConsumer* cons, struct InputEvent* ev)
{
struct Camera* cam = ((struct CameraEventConsumer*)cons)->cam;
// TODO: keys remapping
//printf("%f %f %f %f %f %f %f %f %f\n",
// cam->center[0], cam->center[1], cam->center[2],
// cam->eye[0], cam->eye[1], cam->eye[2],
// cam->up[0], cam->up[1], cam->up[2]);
if (ev->action == GLFW_RELEASE) {
return;
}
int check[] = {
GLFW_KEY_S, GLFW_KEY_W, GLFW_KEY_D, GLFW_KEY_A,
GLFW_KEY_SPACE, GLFW_KEY_LEFT, GLFW_KEY_RIGHT,
GLFW_KEY_UP, GLFW_KEY_DOWN, GLFW_KEY_C
};
for (int i = 0; i < sizeof(check)/sizeof(check[0]); i++) {
if (ev->mask[check[i]]) {
process_key(cam, check[i]);
}
}
}
static void mouse_move_event(struct EventConsumer* cons, struct InputEvent* ev)
{
struct Camera* cam = ((struct CameraEventConsumer*)cons)->cam;
int check[] = {
GLFW_KEY_S, GLFW_KEY_W, GLFW_KEY_D, GLFW_KEY_A,
GLFW_KEY_SPACE, GLFW_KEY_LEFT, GLFW_KEY_RIGHT,
GLFW_KEY_UP, GLFW_KEY_DOWN, GLFW_KEY_C
};
rotate_x(cam, -0.1*ev->dx);
rotate_y(cam, -0.1*ev->dy);
for (int i = 0; i < sizeof(check)/sizeof(check[0]); i++) {
if (ev->mask[check[i]]) {
process_key(cam, check[i]);
}
}
}
void cam_event_consumer_init(struct CameraEventConsumer* cons, struct Camera* cam) {
struct EventConsumer base = {
.key_event = cam_key_event,
.mouse_move_event = mouse_move_event
};
cons->base = base;
cons->cam = cam;
}
|
resetius/graphtoys
|
lib/formats/base64.h
|
#pragma once
#include <stdint.h>
char* base64_decode(const char* input, int64_t size, int64_t* output_size);
char* base64_encode(const char* input, int64_t size, int64_t* output_size);
int base64_test(int argc, char** argv);
|
resetius/graphtoys
|
vulkan/buffer.h
|
#pragma once
#include <render/buffer.h>
#include "vk.h"
struct BufferImpl {
struct BufferBase base;
VkBuffer buffer[10]; // buffer per swapchain image
VkDeviceMemory memory[10]; // used for uniform buffers
int n_buffers;
VkDeviceSize size;
};
struct Render;
struct BufferManager* buf_mgr_vulkan_new(struct Render* r);
|
resetius/graphtoys
|
lib/ref.c
|
<filename>lib/ref.c
#include "ref.h"
void ref(struct Ref* r) {
atomic_fetch_add(&r->counter, 1);
}
void unref(struct Ref* r) {
if (atomic_fetch_sub(&r->counter, 1) == 1) {
r->free(r);
}
}
|
resetius/graphtoys
|
vulkan/stats.h
|
<reponame>resetius/graphtoys
#pragma once
struct VkStats;
struct RenderImpl;
struct VkStats* vk_stats_new(struct RenderImpl*);
void vk_stats_free(struct VkStats* );
|
resetius/graphtoys
|
lib/config.h
|
#pragma once
struct Config;
struct Config* cfg_new(const char* file, int argc, char** argv);
void cfg_free(struct Config*);
struct Config* cfg_section(struct Config*, const char* section);
long cfg_geti(struct Config*, const char* name);
long cfg_geti_def(struct Config*, const char* name, long def);
double cfg_getf_def(struct Config*, const char* name, double def);
const char* cfg_gets(struct Config*, const char* name);
const char* cfg_gets_def(struct Config*, const char* name, const char* def);
void cfg_print(struct Config*);
|
resetius/graphtoys
|
lib/config.c
|
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <string.h>
#include <limits.h>
#include "config.h"
static struct Config* cfg_key_node(struct Config* root, const char* name);
struct Config {
char* section;
char* key;
char* value;
struct Config* next_key;
struct Config* next_section;
};
static int is_comment(const char* s) {
while (*s && isspace(*s)) {
s++;
}
return *s == ';';
}
static const char* get_section(char* s) {
const char* ret;
while (*s && isspace(*s)) {
s++;
}
if (*s != '[') {
return NULL;
}
s++;
while (*s && isspace(*s)) {
s++;
}
if (!*s) {
return NULL;
}
ret = s;
while (*s && !isspace(*s) && *s != ']') {
s++;
}
if (!*s) {
return NULL;
}
*s = 0;
return ret;
}
static int get_key_value(char* s, char const** k, char const** v) {
const char* sep = "; =\n\t";
const char* key;
const char* val;
if (!(key = strtok(s, sep))) {
return 0;
}
if (!(val = strtok(NULL, sep))) {
return 0;
}
*k = key;
*v = val;
return 1;
}
static void cfg_rewrite(struct Config* root, int argc, char** argv) {
int i;
const char* colon, *eq;
char* sect_name = NULL, *key = NULL, *val = NULL;
struct Config* sect, *key_node;
for (i = 0; i < argc; i++) {
if (strstr(argv[i], "--") == argv[i] && (colon = strchr(argv[i], ':'))) {
if ((eq = strchr(argv[i], '=')) && (eq > colon)) {
sect_name = strdup(argv[i]+2);
sect_name[colon - argv[i] - 2] = 0;
key = strdup(colon + 1);
key[eq - colon - 1] = 0;
val = strdup(eq+1);
sect = cfg_section(root, sect_name);
if (!sect) {
sect = calloc(1, sizeof(*sect));
sect->section = sect_name; sect_name = NULL;
sect->next_section = root->next_section;
root->next_section = sect;
}
key_node = cfg_key_node(sect, key);
if (!key_node) {
key_node = calloc(1, sizeof(*key_node));
key_node->next_key = sect->next_key;
sect->next_key = key_node;
}
free(key_node->key); key_node->key = key; key = NULL;
free(key_node->value); key_node->value = val; val = NULL;
}
}
free(sect_name); free(key); free(val);
sect_name = key = val = NULL;
}
}
struct Config* cfg_new(const char* file, int argc, char** argv) {
FILE* f = fopen(file, "rb");
char buf[32768];
struct Config* root;
struct Config* section = NULL;
struct Config* kv = NULL;
const char* k, * v;
const char* section_name;
if (!f) {
printf("Cannot open config '%s'\n", file);
}
root = calloc(1, sizeof(*root));
while (f && fgets(buf, sizeof(buf), f)) {
if (is_comment(buf)) {
continue;
}
if ((section_name = get_section(buf))) {
section = calloc(1, sizeof(*section));
section->section = strdup(section_name);
section->next_section = root->next_section;
root->next_section = section;
} else if (get_key_value(buf, &k, &v) && section) {
kv = calloc(1, sizeof(*kv));
kv->key = strdup(k);
kv->value = strdup(v);
kv->next_key = section->next_key;
section->next_key = kv;
} else {
printf("Bad config syntax\n");
exit(1);
}
}
if (f) {
fclose(f);
}
cfg_rewrite(root, argc, argv);
return root;
}
void cfg_free(struct Config* c) {
if (c) {
free(c->section);
free(c->key);
free(c->value);
cfg_free(c->next_key);
cfg_free(c->next_section);
free(c);
}
}
void cfg_print(struct Config* c) {
if (c) {
if (c->section) {
printf("['%s']\n", c->section);
}
if (c->key) {
printf("'%s' = '%s'\n", c->key, c->value);
}
cfg_print(c->next_key);
cfg_print(c->next_section);
}
}
static struct Config* cfg_key_node(struct Config* root, const char* name) {
struct Config* node = root ? root->next_key : NULL;
while (node && strcmp(node->key, name)) {
node = node->next_key;
}
return node;
}
struct Config* cfg_section(struct Config* root, const char* section) {
struct Config* node = root->next_section;
struct Config* prev = NULL;
struct Config* sect = NULL;
while (node) {
struct Config* next = node->next_section;
if (!strcmp(node->section, section)) {
if (sect == NULL) {
prev = node;
sect = node;
} else {
// merge
struct Config* last = sect->next_key;
if (!last) {
printf("1\n");
sect->next_key = node->next_key;
} else {
while (last->next_key) {
last = last->next_key;
}
last->next_key = node->next_key;
}
free(node->section);
free(node);
prev->next_section = node->next_section;
}
} else {
prev = node;
}
node = next;
}
return sect;
}
long cfg_geti(struct Config* root, const char* name) {
const char* s = cfg_gets(root, name);
char* end;
long res;
if (!s) {
return LONG_MIN;
}
res = strtol(s, &end, 10);
if (s == end) {
return LONG_MIN;
}
return res;
}
static const char* cfg_get_key(struct Config* root, const char* name) {
struct Config* node = cfg_key_node(root, name);
return node ? node->value : NULL;
}
const char* cfg_gets(struct Config* root, const char* name) {
const char* sep = ": \t\n";
const char* section_name;
const char* key;
char* copy;
const char* result = NULL;
struct Config* section;
if (root->section) {
return cfg_get_key(root, name);
}
copy = strdup(name);
if (!(section_name = strtok(copy, sep))) {
goto noresult;
}
if (!(key = strtok(NULL, sep))) {
goto noresult;
}
if (!(section = cfg_section(root, section_name))) {
goto noresult;
}
result = cfg_get_key(section, key);
noresult:
free(copy);
return result;
}
const char* cfg_gets_def(struct Config* root, const char* name, const char* def) {
const char* r = root ? cfg_gets(root, name) : NULL;
return r ? r : def;
}
long cfg_geti_def(struct Config* root, const char* name, long def) {
if (!root) {
return def;
}
long r = cfg_geti(root, name);
return r == LONG_MIN ? def : r;
}
double cfg_getf_def(struct Config* root, const char* name, double def) {
char buf[1024];
snprintf(buf, sizeof(buf), "%.16le", def);
const char* str = cfg_gets_def(root, name, buf);
double ret;
sscanf(str, "%lf", &ret);
return ret;
}
|
resetius/graphtoys
|
vulkan/vk.h
|
#pragma once
#define VK_NO_PROTOTYPES
#include <vulkan/vulkan.h>
#define DECL_FUNC(name) \
extern PFN_##name name;
#define L0_FUNC(name) DECL_FUNC(name)
#define L1_FUNC(name) DECL_FUNC(name)
#define L2_FUNC(name) DECL_FUNC(name)
#include "symbols.h"
#undef DECL_FUNC
#undef L0_FUNC
#undef L1_FUNC
#undef L2_FUNC
|
resetius/graphtoys
|
vulkan/pipeline.c
|
<reponame>resetius/graphtoys<filename>vulkan/pipeline.c
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <assert.h>
#include <render/pipeline.h>
#include <render/render.h>
#include <lib/verify.h>
#include "render_impl.h"
#include "tools.h"
#include "buffer.h"
struct BufferDescriptor {
int stride;
VkVertexInputBindingDescription descr;
VkVertexInputAttributeDescription attr[20];
int n_attr;
};
struct Buffer {
struct BufferImpl base;
int stride;
int n_vertices;
int binding;
};
struct UniformBlock {
struct BufferImpl base;
VkDescriptorSetLayoutBinding layoutBinding;
};
struct PipelineImpl {
struct Pipeline base;
struct RenderImpl* r;
struct UniformBlock* uniforms;
int n_uniforms;
struct BufferDescriptor* buf_descr;
int n_buf_descr;
struct Buffer* buffers;
int n_buffers;
int buf_cap;
VkPipelineLayout pipelineLayout;
VkPipeline graphicsPipeline;
VkPipeline computePipeline;
VkDescriptorSet* descriptorSets;
int* descriptorSetFlags;
VkDescriptorSet* currentDescriptorSet;
int n_descriptor_sets;
VkSampler* samplers;
int n_samplers;
VkDescriptorPool descriptorPool;
VkDescriptorSetLayout layout;
VkDescriptorSetLayout texLayout;
struct BufferManager* b; // TODO: remove me
};
struct Sampler {
struct VkSamplerCreateInfo info;
VkDescriptorSetLayoutBinding layoutBinding;
int binding;
};
struct PipelineBuilderImpl {
struct PipelineBuilder base;
struct RenderImpl* r;
struct UniformBlock uniforms[100];
int n_uniforms;
struct UniformBlock* cur_uniform;
VkShaderModule vert_shaders[100];
int n_vert_shaders;
VkShaderModule frag_shaders[100];
int n_frag_shaders;
VkShaderModule comp_shaders[100];
int n_comp_shaders;
struct BufferDescriptor buffers[100];
struct BufferDescriptor* cur_buffer;
int n_buffers;
struct Buffer allocated[100];
int n_allocated;
struct Sampler samplers[100];
int n_samplers;
VkPipelineShaderStageCreateInfo* shader_stages;
VkVertexInputBindingDescription* binding_descrs;
VkVertexInputAttributeDescription* attr_descrs;
int n_attrs;
VkDescriptorSetLayoutBinding* layout_bindings;
VkDescriptorSetLayoutBinding* texture_layout_bindings;
int enable_depth;
int enable_blend;
enum GeometryType geometry;
VkCullModeFlagBits cull_mode;
struct BufferManager* b; // TODO: remove me
};
static uint32_t primitive_topology(enum GeometryType geometry) {
uint32_t ret = -1;
switch (geometry) {
case GEOM_TRIANGLES:
ret = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
break;
case GEOM_POINTS:
ret = VK_PRIMITIVE_TOPOLOGY_POINT_LIST;
break;
default:
assert(0);
break;
}
return ret;
}
static int buffer_assign(struct Pipeline* p1, int id, int buffer_id) {
struct PipelineImpl* p = (struct PipelineImpl*)p1;
assert(id < p->n_buf_descr);
struct BufferDescriptor* descr = &p->buf_descr[id];
if (p->n_buffers >= p->buf_cap) {
p->buf_cap = (p->buf_cap+1)*2;
p->buffers = realloc(p->buffers, p->buf_cap*sizeof(struct Buffer));
}
int logical_id = p->n_buffers++; // logical id
struct Buffer* buf = &p->buffers[logical_id];
memset(buf, 0, sizeof(*buf));
memcpy(&buf->base, p->b->get(p->b, buffer_id), sizeof(buf->base));
buf->stride = descr->stride;
buf->n_vertices = buf->base.size / descr->stride;
buf->binding = id; // ?
return logical_id;
}
static void uniform_assign(struct Pipeline* p1, int uniform_id, int buffer_id)
{
struct PipelineImpl* p = (struct PipelineImpl*)p1;
int i;
assert(uniform_id < p->n_uniforms);
for (i = 0; i < p->r->sc.n_images; i++) {
p->descriptorSetFlags[i] = 0; // rebuild descriptor set
}
memcpy(&p->uniforms[uniform_id].base,
p->b->get(p->b, buffer_id),
sizeof(p->uniforms[uniform_id].base));
}
static void use_texture(struct Pipeline* p1, void* texture) {
struct PipelineImpl* pl = (struct PipelineImpl*)p1;
struct RenderImpl* r = pl->r;
struct Texture* tex = (struct Texture*)texture;
pl->currentDescriptorSet = &tex->set;
if (tex->has_set) {
return;
}
tex->has_set = 1;
VkDescriptorSetAllocateInfo allocInfo = {
.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO,
.descriptorPool = pl->descriptorPool,
.descriptorSetCount = 1,
.pSetLayouts = &pl->texLayout,
};
if (vkAllocateDescriptorSets(r->log_dev, &allocInfo, &tex->set) != VK_SUCCESS) {
fprintf(stderr, "failed to allocate texture descriptor set\n");
exit(-1);
}
VkDescriptorImageInfo imageInfo = {
.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
.imageView = tex->view,
.sampler = pl->samplers[0] // TODO
};
VkWriteDescriptorSet descriptorWrites = {
.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
.dstSet = tex->set,
.dstBinding = 0, // TODO
.dstArrayElement = 0,
.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
.descriptorCount = 1,
.pImageInfo = &imageInfo,
};
vkUpdateDescriptorSets(r->log_dev, 1, &descriptorWrites, 0, NULL);
}
static void start(struct Pipeline* p1) {
struct PipelineImpl* p = (struct PipelineImpl*)p1;
struct RenderImpl* r = p->r;
VkCommandBuffer buffer = r->buffer;
vkCmdBindPipeline(buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, p->graphicsPipeline);
}
static void storage_swap(struct Pipeline* p1, int dst, int src) {
struct PipelineImpl* p = (struct PipelineImpl*)p1;
int i;
// TODO performance
for (i = 0; i < p->r->sc.n_images; i++) {
p->descriptorSetFlags[i] = 0; // rebuild descriptor set
}
int t = p->uniforms[dst].layoutBinding.binding;
p->uniforms[dst].layoutBinding.binding = p->uniforms[src].layoutBinding.binding;
p->uniforms[src].layoutBinding.binding = t;
}
static void start_compute(struct Pipeline* p1, int sx, int sy, int sz) {
struct PipelineImpl* p = (struct PipelineImpl*)p1;
struct RenderImpl* r = p->r;
VkCommandBuffer buffer = r->buffer; // use different command buffer?
vkCmdBindPipeline(buffer, VK_PIPELINE_BIND_POINT_COMPUTE, p->computePipeline);
}
static VkDescriptorSet currentDescriptorSet(struct PipelineImpl* p)
{
struct RenderImpl* r = p->r;
int i = r->image_index;
if (!p->descriptorSetFlags[i]) {
for (int j = 0; j < p->n_uniforms; j++) {
int idx = p->uniforms[j].base.n_buffers > 1
? i
: 0;
VkDescriptorBufferInfo info = {
.buffer = p->uniforms[j].base.buffer[idx],
.offset = 0,
.range = p->uniforms[j].base.size
};
VkWriteDescriptorSet uboDescWrites = {
.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
.pNext = NULL,
.dstSet = p->descriptorSets[i],
.dstBinding = p->uniforms[j].layoutBinding.binding,
.dstArrayElement = 0,
.descriptorType = p->uniforms[j].layoutBinding.descriptorType,
.descriptorCount = 1,
.pBufferInfo = &info,
.pImageInfo = NULL,
.pTexelBufferView = NULL,
};
VkWriteDescriptorSet descWrites[] = {uboDescWrites};
vkUpdateDescriptorSets(
r->log_dev,
1,
descWrites,
0,
NULL);
}
p->descriptorSetFlags[i] = 1;
}
return p->descriptorSets[i];
}
static void draw(struct Pipeline* p1, int id) {
struct PipelineImpl* p = (struct PipelineImpl*)p1;
struct RenderImpl* r = p->r;
VkCommandBuffer buffer = r->buffer;
if (id < p->n_buffers) {
VkDeviceSize offset = 0;
struct Buffer* buf = &p->buffers[id];
//printf("Draw %d %d\n", id, buf->n_vertices);
VkDescriptorSet curSet = currentDescriptorSet(p);
VkDescriptorSet textureDescriptorSet = NULL;
int n_sets = 1;
if (p->currentDescriptorSet) {
textureDescriptorSet = *p->currentDescriptorSet;
n_sets = 2;
}
VkDescriptorSet use [] = { curSet, textureDescriptorSet };
vkCmdBindDescriptorSets(
buffer,
VK_PIPELINE_BIND_POINT_GRAPHICS,
p->pipelineLayout,
0,
n_sets,
use, 0, NULL);
vkCmdBindVertexBuffers(
buffer,
buf->binding,
1,
&buf->base.buffer[0],
&offset);
//printf("Use %p\n", p->currentDescriptorSet);
//printf("vertices: %d\n", buf->n_vertices);
vkCmdDraw(
buffer,
buf->n_vertices, // vertices
1, // instance count -- just the 1
0, // vertex offet -- any offsets to add
0);// first instance -- since no instancing, is set to 0
}
}
static void draw_indexed(struct Pipeline* p1, int id, int index, int index_byte_size) {
struct PipelineImpl* p = (struct PipelineImpl*)p1;
struct RenderImpl* r = p->r;
VkCommandBuffer buffer = r->buffer;
assert(index_byte_size == 2 || index_byte_size == 4 || index_byte_size == 1);
if (id < p->n_buffers /*&& index_byte_size > 1*/) {
VkDeviceSize offset = 0;
struct Buffer* buf = &p->buffers[id];
struct BufferImpl* ibuf = (struct BufferImpl*)p->b->get(p->b, index);
int n_vertices = ibuf->size / index_byte_size;
//printf("Draw %d %d\n", id, n_vertices);
VkDescriptorSet curSet = currentDescriptorSet(p);
VkDescriptorSet textureDescriptorSet = NULL;
int n_sets = 1;
if (p->currentDescriptorSet) {
textureDescriptorSet = *p->currentDescriptorSet;
n_sets = 2;
}
VkDescriptorSet use [] = { curSet, textureDescriptorSet };
vkCmdBindDescriptorSets(
buffer,
VK_PIPELINE_BIND_POINT_GRAPHICS,
p->pipelineLayout,
0,
n_sets,
use, 0, NULL);
//printf("bytes: %d\n", index_byte_size);
int type = VK_INDEX_TYPE_UINT32;
if (index_byte_size == 2) {
type = VK_INDEX_TYPE_UINT16;
} else if (index_byte_size == 1) {
type = VK_INDEX_TYPE_UINT8_EXT;
}
vkCmdBindIndexBuffer(
buffer, ibuf->buffer[0], 0,
type);
vkCmdBindVertexBuffers(
buffer,
buf->binding,
1,
&buf->base.buffer[0],
&offset);
//printf("Use %p\n", p->currentDescriptorSet);
//printf("vertices: %d\n", buf->n_vertices);
vkCmdDrawIndexed(
buffer,
n_vertices, // vertices
1, // instance count -- just the 1
0,
0, // vertex offet -- any offsets to add
0);// first instance -- since no instancing, is set to 0
}
}
static int vk_filter(enum FilterType filter_type) {
switch (filter_type) {
case FILTER_NEAREST: return VK_FILTER_NEAREST;
case FILTER_LINEAR: return VK_FILTER_LINEAR;
case FILTER_NEAREST_MIPMAP_NEAREST: return VK_FILTER_NEAREST;
case FILTER_LINEAR_MIPMAP_NEAREST: return VK_FILTER_NEAREST;
case FILTER_NEAREST_MIPMAP_LINEAR: return VK_FILTER_NEAREST;
case FILTER_LINEAR_MIPMAP_LINEAR: return VK_FILTER_LINEAR;
default: verify(0);
}
return -1;
}
static int vk_mipmap(enum FilterType filter_type) {
switch (filter_type) {
case FILTER_NEAREST: return VK_SAMPLER_MIPMAP_MODE_NEAREST;
case FILTER_LINEAR: return VK_SAMPLER_MIPMAP_MODE_NEAREST;
case FILTER_NEAREST_MIPMAP_NEAREST: return VK_SAMPLER_MIPMAP_MODE_NEAREST;
case FILTER_LINEAR_MIPMAP_NEAREST: return VK_SAMPLER_MIPMAP_MODE_NEAREST;
case FILTER_NEAREST_MIPMAP_LINEAR: return VK_SAMPLER_MIPMAP_MODE_LINEAR;
case FILTER_LINEAR_MIPMAP_LINEAR: return VK_SAMPLER_MIPMAP_MODE_LINEAR;
default: verify(0);
}
return -1;
}
static int vk_wrap(enum WrapType wrap_type) {
switch (wrap_type) {
case WRAP_REPEAT: return VK_SAMPLER_ADDRESS_MODE_REPEAT;
case WRAP_MIRRORED_REPEAT: return VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT;
case WRAP_CLAMP_TO_EDGE: return VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
case WRAP_CLAMP_TO_BORDER: return VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER;
default: verify(0); break;
}
return -1;
}
static struct PipelineBuilder* begin_sampler(struct PipelineBuilder*p1, int binding)
{
struct PipelineBuilderImpl* p = (struct PipelineBuilderImpl*)p1;
struct RenderImpl* r = p->r;
VkSamplerCreateInfo samplerInfo = {
.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,
.magFilter = VK_FILTER_LINEAR,
.minFilter = VK_FILTER_LINEAR,
.addressModeU = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER,
.addressModeV = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER,
.addressModeW = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER,
.anisotropyEnable = VK_FALSE,
.maxAnisotropy = r->properties.limits.maxSamplerAnisotropy,
.borderColor = VK_BORDER_COLOR_INT_OPAQUE_BLACK,
.unnormalizedCoordinates = VK_FALSE,
.compareEnable = VK_FALSE,
.compareOp = VK_COMPARE_OP_ALWAYS,
.mipmapMode = VK_SAMPLER_MIPMAP_MODE_LINEAR
};
VkDescriptorSetLayoutBinding samplerLayoutBinding = {
.binding = 0, // TODO
.descriptorCount = 1,
.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
.pImmutableSamplers = NULL,
.stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT
};
struct Sampler* sampler = &p->samplers[p->n_samplers++];
sampler->info = samplerInfo;
sampler->layoutBinding = samplerLayoutBinding;
sampler->binding = binding;
return p1;
}
static struct PipelineBuilder* sampler_mag_filter(struct PipelineBuilder* p1, enum FilterType filter_type) {
struct PipelineBuilderImpl* p = (struct PipelineBuilderImpl*)p1;
struct Sampler* s = &p->samplers[p->n_samplers-1];
s->info.magFilter = vk_filter(filter_type);
return p1;
}
static struct PipelineBuilder* sampler_min_filter(struct PipelineBuilder* p1, enum FilterType filter_type) {
struct PipelineBuilderImpl* p = (struct PipelineBuilderImpl*)p1;
struct Sampler* s = &p->samplers[p->n_samplers-1];
s->info.minFilter = vk_filter(filter_type);
s->info.mipmapMode = vk_mipmap(filter_type);
s->info.maxLod = 11;
return p1;
}
static struct PipelineBuilder* sampler_wrap_s(struct PipelineBuilder* p1, enum WrapType wrap_type) {
struct PipelineBuilderImpl* p = (struct PipelineBuilderImpl*)p1;
struct Sampler* s = &p->samplers[p->n_samplers-1];
s->info.addressModeU = vk_wrap(wrap_type);
return p1;
}
static struct PipelineBuilder* sampler_wrap_t(struct PipelineBuilder* p1, enum WrapType wrap_type) {
struct PipelineBuilderImpl* p = (struct PipelineBuilderImpl*)p1;
struct Sampler* s = &p->samplers[p->n_samplers-1];
s->info.addressModeV = vk_wrap(wrap_type);
return p1;
}
static struct PipelineBuilder* end_sampler(struct PipelineBuilder*p1)
{
return p1;
}
static struct PipelineBuilder* uniform_or_storage_add(
struct PipelineBuilder*p1,
int binding,
uint32_t type)
{
struct PipelineBuilderImpl* p = (struct PipelineBuilderImpl*)p1;
assert(p->cur_uniform == NULL);
p->cur_uniform = &p->uniforms[p->n_uniforms++];
VkDescriptorSetLayoutBinding uboLayoutBinding = {
.binding = binding,
.descriptorCount = 1,
.descriptorType = type,
.pImmutableSamplers = NULL,
.stageFlags = VK_SHADER_STAGE_COMPUTE_BIT|VK_SHADER_STAGE_VERTEX_BIT|VK_SHADER_STAGE_FRAGMENT_BIT // TODO
};
p->cur_uniform->layoutBinding = uboLayoutBinding;
p->cur_uniform = NULL;
return p1;
}
static struct PipelineBuilder* storage_add(
struct PipelineBuilder*p1,
int binding,
const char* name)
{
return uniform_or_storage_add(p1, binding, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER);
}
static struct PipelineBuilder* uniform_add(
struct PipelineBuilder*p1,
int binding,
const char* name)
{
return uniform_or_storage_add(p1, binding, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER);
}
static struct PipelineBuilder* begin_program(struct PipelineBuilder* p) {
return p;
}
static struct PipelineBuilder* end_program(struct PipelineBuilder* p) {
return p;
}
static VkShaderModule add_shader(VkDevice device, struct ShaderCode shader) {
VkShaderModuleCreateInfo info = {
.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO,
.codeSize = shader.size,
.pCode = (const uint32_t*)(shader.spir_v)
};
VkShaderModule result;
if (vkCreateShaderModule(device, &info, NULL, &result) != VK_SUCCESS) {
fprintf(stderr, "Failed to create shader module\n");
exit(-1);
}
return result;
}
static struct PipelineBuilder* add_vs(struct PipelineBuilder* p1,struct ShaderCode shader)
{
struct PipelineBuilderImpl* p = (struct PipelineBuilderImpl*)p1;
p->vert_shaders[p->n_vert_shaders++] = add_shader(p->r->log_dev, shader);
return p1;
}
static struct PipelineBuilder* add_fs(struct PipelineBuilder* p1,struct ShaderCode shader)
{
struct PipelineBuilderImpl* p = (struct PipelineBuilderImpl*)p1;
p->frag_shaders[p->n_frag_shaders++] = add_shader(p->r->log_dev, shader);
return p1;
}
static struct PipelineBuilder* add_cs(struct PipelineBuilder* p1,struct ShaderCode shader)
{
struct PipelineBuilderImpl* p = (struct PipelineBuilderImpl*)p1;
p->comp_shaders[p->n_comp_shaders++] = add_shader(p->r->log_dev, shader);
return p1;
}
static struct PipelineBuilder* begin_buffer(struct PipelineBuilder* p1, int stride)
{
struct PipelineBuilderImpl* p = (struct PipelineBuilderImpl*)p1;
VkVertexInputBindingDescription descr = {
.binding = p->n_buffers,
.stride = stride,
.inputRate = VK_VERTEX_INPUT_RATE_VERTEX
};
// TODO: check ptr
p->cur_buffer = &p->buffers[p->n_buffers++];
p->cur_buffer->stride = stride;
p->cur_buffer->descr = descr;
return p1;
}
static int get_format(int channels, enum DataType data_type) {
int fmt = 0;
switch (data_type) {
case DATA_FLOAT:
if (channels == 1) {
fmt = VK_FORMAT_R32_SFLOAT;
} else if (channels == 2) {
fmt = VK_FORMAT_R32G32_SFLOAT;
} else if (channels == 3) {
fmt = VK_FORMAT_R32G32B32_SFLOAT;
} else if (channels == 4) {
fmt = VK_FORMAT_R32G32B32A32_SFLOAT;
} else {
fprintf(stderr, "Wrong number of channels\n");
exit(-1);
}
break;
case DATA_INT:
if (channels == 1) {
fmt = VK_FORMAT_R32_SINT;
} else if (channels == 2) {
fmt = VK_FORMAT_R32G32_SINT;
} else if (channels == 3) {
fmt = VK_FORMAT_R32G32B32_SINT;
} else if (channels == 4) {
fmt = VK_FORMAT_R32G32B32A32_SINT;
} else {
fprintf(stderr, "Wrong number of channels\n");
exit(-1);
}
break;
default:
fprintf(stderr, "Wrong data type %d\n", data_type);
exit(-1);
break;
}
return fmt;
}
struct PipelineBuilder* buffer_attribute(
struct PipelineBuilder* p1,
int location,
int channels,
enum DataType data_type,
uint64_t offset)
{
struct PipelineBuilderImpl* p = (struct PipelineBuilderImpl*)p1;
VkVertexInputAttributeDescription attr = {
.binding = p->cur_buffer->descr.binding,
.location = location,
.format = get_format(channels, data_type),
.offset = offset
};
p->cur_buffer->attr[p->cur_buffer->n_attr++] = attr;
return p1;
}
struct PipelineBuilder* end_buffer(struct PipelineBuilder* p1)
{
struct PipelineBuilderImpl* p = (struct PipelineBuilderImpl*)p1;
p->n_attrs += p->cur_buffer->n_attr;
p->cur_buffer = 0;
return p1;
}
static VkPipelineShaderStageCreateInfo* get_shader_stages(struct PipelineBuilderImpl* p)
{
VkPipelineShaderStageCreateInfo* infos = malloc(
(p->n_comp_shaders+p->n_vert_shaders+p->n_frag_shaders)*
sizeof(VkPipelineShaderStageCreateInfo));
int i, k;
k = 0;
for (i = 0; i < p->n_comp_shaders; i++) {
VkPipelineShaderStageCreateInfo info = {
.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
.stage = VK_SHADER_STAGE_COMPUTE_BIT,
.module = p->comp_shaders[i],
.pName = "main"
};
infos[k++] = info;
}
for (i = 0; i < p->n_vert_shaders; i++) {
VkPipelineShaderStageCreateInfo info = {
.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
.stage = VK_SHADER_STAGE_VERTEX_BIT,
.module = p->vert_shaders[i],
.pName = "main"
};
infos[k++] = info;
}
for (i = 0; i < p->n_frag_shaders; i++) {
VkPipelineShaderStageCreateInfo info = {
.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
.stage = VK_SHADER_STAGE_FRAGMENT_BIT,
.module = p->frag_shaders[i],
.pName = "main"
};
infos[k++] = info;
}
return (p->shader_stages = infos);
}
static VkVertexInputBindingDescription* get_binding_descrs(struct PipelineBuilderImpl* p)
{
VkVertexInputBindingDescription* descrs = malloc(p->n_buffers*sizeof(VkVertexInputBindingDescription));
int i;
for (i = 0; i < p->n_buffers; i++) {
descrs[i] = p->buffers[i].descr;
}
return (p->binding_descrs = descrs);
}
static VkVertexInputAttributeDescription* get_attr_descrs(struct PipelineBuilderImpl* p)
{
VkVertexInputAttributeDescription* descrs = malloc(p->n_attrs*sizeof(VkVertexInputAttributeDescription));
int i,j,k;
k = 0;
for (i = 0; i < p->n_buffers; i++) {
for (j = 0; j < p->buffers[i].n_attr; j++) {
descrs[k++] = p->buffers[i].attr[j];
}
}
return (p->attr_descrs = descrs);
}
struct VkDescriptorSetLayoutBinding* get_layout_bindings(struct PipelineBuilderImpl*p)
{
VkDescriptorSetLayoutBinding* infos = malloc(p->n_uniforms*sizeof(VkDescriptorSetLayoutBinding));
int k = 0, i;
for (i = 0; i < p->n_uniforms; i++) {
infos[k++] = p->uniforms[i].layoutBinding;
}
return (p->layout_bindings = infos);
}
struct VkDescriptorSetLayoutBinding* get_texture_layout_bindings(struct PipelineBuilderImpl*p)
{
VkDescriptorSetLayoutBinding* infos = malloc(p->n_samplers*sizeof(VkDescriptorSetLayoutBinding));
int k = 0, i;
for (i = 0; i < p->n_samplers; i++) {
infos[k++] = p->samplers[i].layoutBinding;
}
return (p->texture_layout_bindings = infos);
}
static void builder_free(struct PipelineBuilderImpl* p) {
int i;
for (i = 0; i < p->n_vert_shaders; i++) {
vkDestroyShaderModule(p->r->log_dev, p->vert_shaders[i], NULL);
}
for (i = 0; i < p->n_frag_shaders; i++) {
vkDestroyShaderModule(p->r->log_dev, p->frag_shaders[i], NULL);
}
free(p->shader_stages);
free(p->attr_descrs);
free(p->binding_descrs);
free(p->layout_bindings);
free(p->texture_layout_bindings);
free(p);
}
static void pipeline_free(struct Pipeline* p1) {
struct PipelineImpl* p = (struct PipelineImpl*)p1;
struct RenderImpl* r = p->r;
int i;
vkDeviceWaitIdle(r->log_dev);
free(p->uniforms); p->uniforms = NULL; p->n_uniforms = 0;
free(p->buffers); p->n_buffers = 0;
p->buffers = NULL;
vkDestroyDescriptorPool(r->log_dev, p->descriptorPool, NULL);
vkDestroyDescriptorSetLayout(r->log_dev, p->layout, NULL);
if (p->n_samplers) {
vkDestroyDescriptorSetLayout(r->log_dev, p->texLayout, NULL);
}
for (i = 0; i < p->n_samplers; i++) {
vkDestroySampler(r->log_dev, p->samplers[i], NULL);
}
free(p->samplers); p->samplers = NULL; p->n_samplers = 0;
free(p->buf_descr); p->n_buf_descr = 0; p->buf_descr = NULL;
vkDestroyPipeline(r->log_dev, p->graphicsPipeline, NULL);
vkDestroyPipelineLayout(r->log_dev, p->pipelineLayout, NULL);
free(p->descriptorSets); p->descriptorSets = NULL; p->n_descriptor_sets = 0;
free(p->descriptorSetFlags); p->descriptorSetFlags = NULL;
free(p);
}
static struct PipelineBuilder* enable_depth(struct PipelineBuilder* p1) {
struct PipelineBuilderImpl* p = (struct PipelineBuilderImpl*)p1;
p->enable_depth = 1;
return p1;
}
static struct PipelineBuilder* enable_blend(struct PipelineBuilder* p1) {
struct PipelineBuilderImpl* p = (struct PipelineBuilderImpl*)p1;
p->enable_blend = 1;
return p1;
}
static struct PipelineBuilder* enable_cull(struct PipelineBuilder* p1, enum CullType cull) {
struct PipelineBuilderImpl* p = (struct PipelineBuilderImpl*)p1;
switch (cull) {
case CULL_FRONT:
p->cull_mode = VK_CULL_MODE_FRONT_BIT;
break;
case CULL_BACK:
p->cull_mode = VK_CULL_MODE_BACK_BIT;
break;
case CULL_BOTH:
p->cull_mode = VK_CULL_MODE_FRONT_AND_BACK;
break;
default:
assert(0);
break;
}
return p1;
}
static struct PipelineBuilder* set_bmgr(struct PipelineBuilder* p1, struct BufferManager* b)
{
struct PipelineBuilderImpl* p = (struct PipelineBuilderImpl*)p1;
p->b = b;
return p1;
}
static struct PipelineBuilder* set_geometry(struct PipelineBuilder* p1, enum GeometryType geometry)
{
struct PipelineBuilderImpl* p = (struct PipelineBuilderImpl*)p1;
p->geometry = geometry;
return p1;
}
static struct Pipeline* build(struct PipelineBuilder* p1) {
struct PipelineBuilderImpl* p = (struct PipelineBuilderImpl*)p1;
struct PipelineImpl* pl = calloc(1, sizeof(*pl));
struct RenderImpl* r = p->r;
struct Pipeline base = {
.buffer_assign = buffer_assign,
.storage_swap = storage_swap,
.storage_assign = uniform_assign,
.uniform_assign = uniform_assign,
.free = pipeline_free,
.start_compute = start_compute,
.start = start,
.use_texture = use_texture,
.draw = draw,
.draw_indexed = draw_indexed,
};
pl->base = base;
pl->r = r;
// TODO: check end state
// Create samplers
pl->samplers = malloc(p->n_samplers*sizeof(VkSampler));
pl->n_samplers = p->n_samplers;
for (int i = 0; i < p->n_samplers; i++) {
if (vkCreateSampler(r->log_dev, &p->samplers[i].info, NULL, &pl->samplers[i]) != VK_SUCCESS) {
fprintf(stderr, "Failed to create texture sampler\n");
exit(-1);
}
}
// Vertex input State
VkPipelineVertexInputStateCreateInfo vertexInputInfo = {
.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,
.vertexBindingDescriptionCount = p->n_buffers,
.pVertexBindingDescriptions = get_binding_descrs(p),
.vertexAttributeDescriptionCount = p->n_attrs,
.pVertexAttributeDescriptions = get_attr_descrs(p)
};
// Vertex Input assembly State
VkPipelineInputAssemblyStateCreateInfo inputAssemblyInfo = {
.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO,
.topology = primitive_topology(p->geometry),
.primitiveRestartEnable = VK_FALSE
};
// Rasterization State
VkPipelineRasterizationStateCreateInfo rastStateCreateInfo = {
.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO,
.depthClampEnable = VK_FALSE,
.rasterizerDiscardEnable = VK_FALSE,
.polygonMode = VK_POLYGON_MODE_FILL,
.lineWidth = 1.0f,
.cullMode = p->cull_mode,
.frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE, //VK_FRONT_FACE_CLOCKWISE,
.depthBiasEnable = VK_FALSE,
.depthBiasConstantFactor = 0.0f,
.depthBiasClamp = 0.0f,
.depthBiasSlopeFactor = 0.0f
};
// Multisampling State
VkPipelineMultisampleStateCreateInfo msStateInfo = {
.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,
.sampleShadingEnable = VK_FALSE,
.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT,
.minSampleShading = 1.0f,
.pSampleMask = NULL,
.alphaToCoverageEnable = VK_FALSE,
.alphaToOneEnable = VK_FALSE,
};
// Color Blend State
VkPipelineColorBlendAttachmentState cbAttach = {
.colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT,
.blendEnable = p->enable_blend,
.colorBlendOp = VK_BLEND_OP_ADD,
.srcColorBlendFactor = VK_BLEND_FACTOR_ONE,
.dstColorBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA,
.alphaBlendOp = VK_BLEND_OP_ADD,
.srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE,
.dstAlphaBlendFactor = VK_BLEND_FACTOR_ZERO,
};
VkPipelineColorBlendStateCreateInfo cbCreateInfo = {
.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO,
.logicOpEnable = VK_FALSE,
.logicOp = VK_LOGIC_OP_COPY,
.attachmentCount = 1,
.pAttachments = &cbAttach
};
VkPipelineViewportStateCreateInfo vpStateInfo = {
.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO,
.viewportCount = 1,
.pViewports = NULL,
.scissorCount = 1,
.pScissors = NULL
};
// Descriptor
VkDescriptorSetLayout descriptorSetLayout;
VkDescriptorSetLayout textureDescriptorSetLayout;
VkDescriptorSetLayoutCreateInfo layoutCreateInfo = {
.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
.bindingCount = p->n_uniforms,
.pBindings = get_layout_bindings(p)
};
if (vkCreateDescriptorSetLayout(r->log_dev, &layoutCreateInfo, NULL, &descriptorSetLayout) != VK_SUCCESS)
{
fprintf(stderr, "Failed to create descriptor set layout\n");
exit(-1);
}
pl->layout = descriptorSetLayout;
if (p->n_samplers) {
VkDescriptorSetLayoutCreateInfo info = {
.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
.bindingCount = p->n_samplers,
.pBindings = get_texture_layout_bindings(p)
};
if (vkCreateDescriptorSetLayout(r->log_dev, &info, NULL, &textureDescriptorSetLayout) != VK_SUCCESS)
{
fprintf(stderr, "Failed to create descriptor set layout\n");
exit(-1);
}
pl->texLayout = textureDescriptorSetLayout;
}
VkDescriptorPoolSize storagePool = {
.type = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
.descriptorCount = 10*r->sc.n_images
};
VkDescriptorPoolSize uniformPool = {
.type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
.descriptorCount = 10*r->sc.n_images
};
VkDescriptorPoolSize samplerPool = {
.type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
.descriptorCount = 100*r->sc.n_images
};
VkDescriptorPoolSize poolSizes[] = {
storagePool, uniformPool, samplerPool
};
VkDescriptorPoolCreateInfo poolInfo = {
.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO,
.poolSizeCount = sizeof(poolSizes)/sizeof(VkDescriptorPoolSize),
.pPoolSizes = poolSizes,
.maxSets = uniformPool.descriptorCount+samplerPool.descriptorCount
};
if (vkCreateDescriptorPool(r->log_dev, &poolInfo, NULL, &pl->descriptorPool) != VK_SUCCESS) {
fprintf(stderr, "Failed to create descriptor pool\n");
exit(-1);
}
// create vector of 2 decriptorSetLayout with the layouts
VkDescriptorSetLayout* layouts = malloc(r->sc.n_images*sizeof(VkDescriptorSetLayout));
for (int i = 0; i < r->sc.n_images;i++) {
layouts[i] = descriptorSetLayout;
}
VkDescriptorSetAllocateInfo allocInfo = {
.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO,
.descriptorPool = pl->descriptorPool,
.descriptorSetCount = r->sc.n_images,
.pSetLayouts = layouts
};
pl->n_descriptor_sets = allocInfo.descriptorSetCount;
pl->descriptorSets = malloc(pl->n_descriptor_sets*sizeof(VkDescriptorSet));
pl->descriptorSetFlags = calloc(pl->n_descriptor_sets, sizeof(int));
if (vkAllocateDescriptorSets(r->log_dev, &allocInfo, pl->descriptorSets) != VK_SUCCESS) {
fprintf(stderr, "failed to allocate descriptor sets\n");
exit(-1);
}
free(layouts);
VkDescriptorSetLayout activeLayouts [] = {
pl->layout, pl->texLayout
};
VkPipelineLayoutCreateInfo pipelineLayoutInfo = {
.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
.setLayoutCount = p->n_samplers == 0 ? 1 : 2,
.pSetLayouts = activeLayouts
};
if (vkCreatePipelineLayout(r->log_dev, &pipelineLayoutInfo, NULL, &pl->pipelineLayout) != VK_SUCCESS) {
fprintf(stderr, "Failed to create pieline layout\n");
exit(-1);
}
VkPipelineDepthStencilStateCreateInfo depthStencil = {
.sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO,
.depthTestEnable = p->enable_depth,
.depthWriteEnable = p->enable_depth,
.depthCompareOp = VK_COMPARE_OP_LESS,
.depthBoundsTestEnable = VK_FALSE,
.minDepthBounds = 0.0f, // Optional
.maxDepthBounds = 1.0f, // Optional
.stencilTestEnable = VK_FALSE,
.front = {},
.back = {}
};
VkDynamicState dynamicStates[] = {VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR};
VkPipelineDynamicStateCreateInfo dynamicStateInfo = {
.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO,
.pDynamicStates = dynamicStates,
.dynamicStateCount = 2,
.flags = 0
};
// Create Graphics Pipeline
assert(p->n_comp_shaders * p->n_vert_shaders == 0);
if (p->n_comp_shaders) {
assert(p->n_comp_shaders == 1);
VkComputePipelineCreateInfo compInfo = {
.sType = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO,
.stage = *get_shader_stages(p),
.layout = pl->pipelineLayout,
.basePipelineHandle = VK_NULL_HANDLE,
.basePipelineIndex = -1
};
if (vkCreateComputePipelines(r->log_dev, VK_NULL_HANDLE, 1, &compInfo, NULL, &pl->computePipeline) != VK_SUCCESS) {
fprintf(stderr, "Failed to create compute pipeline\n");
exit(-1);
}
} else {
VkGraphicsPipelineCreateInfo gpInfo = {
.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,
.stageCount = p->n_comp_shaders+p->n_frag_shaders+p->n_vert_shaders,
.pStages = get_shader_stages(p),
.pVertexInputState = &vertexInputInfo,
.pInputAssemblyState = &inputAssemblyInfo,
.pViewportState = &vpStateInfo,
.pRasterizationState = &rastStateCreateInfo,
.pMultisampleState = &msStateInfo,
.pDepthStencilState = &depthStencil,
.pColorBlendState = &cbCreateInfo,
.pDynamicState = &dynamicStateInfo,
.layout = pl->pipelineLayout,
.renderPass = r->rp.rp,
.subpass = 0,
.basePipelineHandle = VK_NULL_HANDLE,
.basePipelineIndex = -1
};
if (vkCreateGraphicsPipelines(r->log_dev, VK_NULL_HANDLE, 1, &gpInfo, NULL, &pl->graphicsPipeline) != VK_SUCCESS) {
fprintf(stderr, "Failed to create graphics pipeline\n");
exit(-1);
}
}
pl->n_uniforms = p->n_uniforms;
pl->uniforms = malloc(pl->n_uniforms*sizeof(struct UniformBlock));
memcpy(pl->uniforms, p->uniforms, p->n_uniforms*sizeof(struct UniformBlock));
pl->buffers = malloc(p->n_allocated*sizeof(struct Buffer));
memcpy(pl->buffers, p->allocated, p->n_allocated*sizeof(struct Buffer));
pl->n_buffers = pl->buf_cap = p->n_allocated;
pl->buf_descr = malloc(p->n_buffers*sizeof(struct BufferDescriptor));
memcpy(pl->buf_descr, p->buffers, p->n_buffers*sizeof(struct BufferDescriptor));
pl->n_buf_descr = p->n_buffers;
pl->b = p->b;
builder_free(p);
return (struct Pipeline*)pl;
}
struct PipelineBuilder* pipeline_builder_vulkan(struct Render* r) {
struct PipelineBuilderImpl* p = calloc(1, sizeof(*p));
struct PipelineBuilder base = {
.set_bmgr = set_bmgr,
.storage_add = storage_add,
.uniform_add = uniform_add,
.begin_program = begin_program,
.end_program = end_program,
.add_vs = add_vs,
.add_fs = add_fs,
.add_cs = add_cs,
.begin_buffer = begin_buffer,
.buffer_attribute = buffer_attribute,
.end_buffer = end_buffer,
.enable_depth = enable_depth,
.enable_blend = enable_blend,
.enable_cull = enable_cull,
.begin_sampler = begin_sampler,
.sampler_min_filter = sampler_min_filter,
.sampler_mag_filter = sampler_mag_filter,
.sampler_wrap_s = sampler_wrap_s,
.sampler_wrap_t = sampler_wrap_t,
.end_sampler = end_sampler,
.geometry = set_geometry,
.build = build,
};
p->base = base;
p->r = (struct RenderImpl*)r;
p->geometry = GEOM_TRIANGLES;
return (struct PipelineBuilder*)p;
}
|
resetius/graphtoys
|
models/particles2.c
|
<reponame>resetius/graphtoys<filename>models/particles2.c<gh_stars>0
#include <stdlib.h>
#include <stdio.h>
#include <render/render.h>
#include <render/pipeline.h>
#include <lib/linmath.h>
#include <lib/config.h>
#include <models/particles2.vert.h>
#include <models/particles2.frag.h>
#include <models/particles2.vert.spv.h>
#include <models/particles2.frag.spv.h>
#include "particles2.h"
#include "particles_data.h"
struct UniformBlock {
mat4x4 mvp;
int32_t particles;
};
struct Particles {
struct Object base;
struct Pipeline* pl;
struct BufferManager* b;
int particles;
int pos;
int new_pos;
int accel;
int vel;
int uniform;
int indices;
int indices_vao;
int model;
float z;
quat q;
double ax, ay, az;
int dirty;
};
const int clear_frames = 5;
// TODO: copy-paste
static void transform(struct Particles* t) {
vec3 ox = {1,0,0};
vec3 oy = {0,1,0};
vec3 oz = {0,0,1};
quat ox1 = {1,0,0,0};
quat oy1 = {0,1,0,0};
quat oz1 = {0,0,1,0};
quat qx, qy, qz, q;
quat_conj(q, t->q);
quat_mul(ox1, ox1, t->q);
quat_mul(ox1, q, ox1);
memcpy(ox, ox1, sizeof(vec3));
quat_mul(oy1, oy1, t->q);
quat_mul(oy1, q, oy1);
memcpy(oy, oy1, sizeof(vec3));
quat_mul(oz1, oz1, t->q);
quat_mul(oz1, q, oz1);
memcpy(oz, oz1, sizeof(vec3));
quat_rotate(qx, t->ax, ox);
quat_rotate(qy, t->ay, oy);
quat_rotate(qz, t->az, oz);
quat_mul(t->q, t->q, qx);
quat_mul(t->q, t->q, qy);
quat_mul(t->q, t->q, qz);
t->ax = t->ay = t->az = 0;
t->dirty = clear_frames;
}
static void move_left(struct Object* obj, int mods) {
struct Particles* t = (struct Particles*)obj;
t->az += -5*M_PI/360;
transform(t);
}
static void move_right(struct Object* obj, int mods) {
struct Particles* t = (struct Particles*)obj;
t->az += 5*M_PI/360;
transform(t);
}
static void move_up(struct Object* obj, int mods) {
struct Particles* t = (struct Particles*)obj;
t->ax += -5*M_PI/360;
transform(t);
}
static void move_down(struct Object* obj, int mods) {
struct Particles* t = (struct Particles*)obj;
t->ax += 5*M_PI/360;
transform(t);
}
static void zoom_in(struct Object* obj, int mods) {
struct Particles* t = (struct Particles*)obj;
t->dirty = clear_frames;
if (mods & 1) {
t->z /= 2;
printf("%f\n", t->z);
} else {
t->ay -= 5*M_PI/360;
transform(t);
}
}
static void zoom_out(struct Object* obj, int mods) {
struct Particles* t = (struct Particles*)obj;
t->dirty = clear_frames;
if (mods & 1) {
t->z *= 2;
printf("%f\n", t->z);
} else {
t->ay += 5*M_PI/360;
transform(t);
}
}
static void draw_(struct Object* obj, struct DrawContext* ctx) {
struct Particles* t = (struct Particles*)obj;
mat4x4 m, p, v, mv, mvp;
mat4x4_identity(m);
mat4x4_from_quat(m, t->q);
//mat4x4_scale(m, m, 10000);
//mat4x4_rotate_X(m, m, ctx->time);
//mat4x4_rotate_Y(m, m, ctx->time);
//mat4x4_rotate_Z(m, m, ctx->time);
/*for (int i = 0; i < 4; i++) {
for (int j = 0; j < 4; j++) {
printf("%f ", m[i][j]);
}
printf("\n");
}
printf("\n");*/
//mat4x4_ortho(p, -ctx->ratio, ctx->ratio, -1.f, 1.f, 1.f, -1.f);
//mat4x4_mul(mvp, p, m);
//vec3 eye = {.0f, .0f, 10.f};
vec3 eye = {.0f, .0f, t->z};
vec3 center = {.0f, .0f, .0f};
//vec3 up = {.0f, 1.f, .0f};
vec3 up = {.0f, 1.f, .0f};
mat4x4_look_at(v, eye, center, up);
mat4x4_mul(mv, v, m);
mat4x4_perspective(p, 70./2./M_PI, ctx->ratio, 0.3f, 1000.f);
mat4x4_mul(mvp, p, mv);
//printf("particles %d\n", t->particles);
t->pl->start(t->pl);
if (t->dirty) {
struct UniformBlock block;
block.particles = t->particles;
memcpy(block.mvp, mvp, sizeof(mvp));
buffer_update(t->b, t->uniform, &block, 0, sizeof(block));
t->dirty--;
}
t->pl->draw(t->pl, t->indices_vao);
t->pl->storage_swap(t->pl, 1, 4);
}
static void free_(struct Object* obj) {
struct Particles* t = (struct Particles*)obj;
t->pl->free(t->pl);
t->b->free(t->b);
free(obj);
}
struct Object* CreateParticles2(struct Render* r, struct Config* cfg) {
struct Particles* t = calloc(1, sizeof(struct Particles));
struct Object base = {
.move_left = move_left,
.move_right = move_right,
.move_up = move_up,
.move_down = move_down,
.zoom_in = zoom_in,
.zoom_out = zoom_out,
.draw = draw_,
.free = free_
};
t->base = base;
struct PipelineBuilder* pl = r->pipeline(r);
struct ShaderCode vertex_shader = {
.glsl = models_particles2_vert,
.spir_v = models_particles2_vert_spv,
.size = models_particles2_vert_spv_size,
};
struct ShaderCode fragment_shader = {
.glsl = models_particles2_frag,
.spir_v = models_particles2_frag_spv,
.size = models_particles2_frag_spv_size,
};
t->b = r->buffer_manager(r);
pl = r->pipeline(r);
t->pl = pl
->set_bmgr(pl, t->b)
->begin_program(pl)
->add_vs(pl, vertex_shader)
->add_fs(pl, fragment_shader)
->end_program(pl)
->uniform_add(pl, 0, "MatrixBlock")
->storage_add(pl, 1, "Pos")
->storage_add(pl, 2, "Vel")
->storage_add(pl, 3, "Tmp")
->storage_add(pl, 4, "NewPos")
->begin_buffer(pl, 4)
->buffer_attribute(pl, 1, 1, DATA_INT, 0)
->end_buffer(pl)
->geometry(pl, GEOM_POINTS)
->build(pl);
quat_identity(t->q);
struct ParticlesData data;
particles_data_init(&data, cfg);
t->z = 1.0f;
t->particles = data.n_particles;
int size = t->particles*4*sizeof(float);
t->dirty = clear_frames;
t->indices = t->b->create(t->b, BUFFER_ARRAY, MEMORY_STATIC, data.indices, t->particles*sizeof(int));
t->uniform = t->b->create(t->b, BUFFER_UNIFORM, MEMORY_DYNAMIC, NULL, sizeof(struct UniformBlock));
t->pos = t->b->create(t->b, BUFFER_SHADER_STORAGE, MEMORY_STATIC, data.coords, size);
t->vel = t->b->create(t->b, BUFFER_SHADER_STORAGE, MEMORY_STATIC, data.vels, size);
t->accel = t->b->create(t->b, BUFFER_SHADER_STORAGE, MEMORY_STATIC, data.accel, size);
t->new_pos = t->b->create(t->b, BUFFER_SHADER_STORAGE, MEMORY_STATIC, data.coords, size);
t->indices_vao = t->pl->buffer_assign(t->pl, 0, t->indices);
t->pl->uniform_assign(t->pl, 0, t->uniform);
t->pl->storage_assign(t->pl, 1, t->pos);
t->pl->storage_assign(t->pl, 2, t->vel);
t->pl->storage_assign(t->pl, 3, t->accel);
t->pl->storage_assign(t->pl, 4, t->new_pos);
particles_data_destroy(&data);
return (struct Object*)t;
}
|
resetius/graphtoys
|
models/triangle.c
|
#include <stdlib.h>
#include <stdio.h>
#include <render/render.h>
#include <render/pipeline.h>
#include "triangle.h"
#include <lib/linmath.h>
#include <models/triangle.vert.h>
#include <models/triangle.frag.h>
#include <models/triangle.vert.spv.h>
#include <models/triangle.frag.spv.h>
typedef struct Vertex
{
vec2 pos;
vec3 col;
} Vertex;
static const Vertex vertices[3] =
{
{ { -0.6f, -0.4f }, { 1.f, 0.f, 0.f } },
{ { 0.6f, -0.4f }, { 0.f, 1.f, 0.f } },
{ { 0.f, 0.6f }, { 0.f, 0.f, 1.f } }
};
struct Triangle {
struct Object base;
struct Pipeline* pl;
struct BufferManager* b;
int model_buffer_id;
int model;
int uniform_id;
};
void tr_draw(struct Object* obj, struct DrawContext* ctx) {
struct Triangle* tr = (struct Triangle*)obj;
mat4x4 m, p, mvp;
mat4x4_identity(m);
mat4x4_rotate_Z(m, m, ctx->time);
mat4x4_ortho(p, -ctx->ratio, ctx->ratio, -1.f, 1.f, 1.f, -1.f);
mat4x4_mul(mvp, p, m);
tr->pl->start(tr->pl);
buffer_update(tr->b, tr->uniform_id, &mvp[0][0], 0, sizeof(mat4x4));
tr->pl->draw(tr->pl, tr->model);
}
void tr_free(struct Object* obj) {
struct Triangle* tr = (struct Triangle*)obj;
tr->pl->free(tr->pl);
free(obj);
}
struct Object* CreateTriangle(struct Render* r, struct Config* cfg) {
struct Triangle* tr = calloc(1, sizeof(struct Triangle));
struct Object base = {
.draw = tr_draw,
.free = tr_free
};
tr->base = base;
struct PipelineBuilder* pl = r->pipeline(r);
struct ShaderCode vertex_shader = {
.glsl = models_triangle_vert,
.spir_v = models_triangle_vert_spv,
.size = models_triangle_vert_spv_size,
};
struct ShaderCode fragment_shader = {
.glsl = models_triangle_frag,
.spir_v = models_triangle_frag_spv,
.size = models_triangle_frag_spv_size,
};
tr->b = r->buffer_manager(r);
tr->pl = pl
->set_bmgr(pl, tr->b)
->begin_program(pl)
->add_vs(pl, vertex_shader)
->add_fs(pl, fragment_shader)
->end_program(pl)
->uniform_add(pl, 0, "MatrixBlock")
->begin_buffer(pl, sizeof(Vertex))
->buffer_attribute(pl, 2, 3, DATA_FLOAT, offsetof(Vertex, col)) // vCol
->buffer_attribute(pl, 1, 2, DATA_FLOAT, offsetof(Vertex, pos)) // vPos
->end_buffer(pl)
->build(pl);
tr->uniform_id = buffer_create(tr->b, BUFFER_UNIFORM, MEMORY_DYNAMIC, NULL, sizeof(mat4x4));
pl_uniform_assign(tr->pl, 0, tr->uniform_id);
tr->model_buffer_id = buffer_create(tr->b, BUFFER_ARRAY, MEMORY_STATIC, vertices, sizeof(vertices));
tr->model = pl_buffer_assign(tr->pl, 0, tr->model_buffer_id);
return (struct Object*)tr;
}
|
resetius/graphtoys
|
opengl/buffer.c
|
#include <stdlib.h>
#include <assert.h>
#include <string.h>
#include <stdio.h>
#include <glad/gl.h>
#include <render/buffer.h>
#include <render/render.h>
#include "buffer.h"
struct BufferManagerImpl {
struct BufferManagerBase base;
};
static GLenum buffer_type(enum BufferType type) {
GLenum ret = -1;
switch (type) {
case BUFFER_ARRAY:
ret = GL_ARRAY_BUFFER;
break;
case BUFFER_SHADER_STORAGE:
ret = GL_SHADER_STORAGE_BUFFER;
break;
case BUFFER_UNIFORM:
ret = GL_UNIFORM_BUFFER;
break;
case BUFFER_INDEX:
ret = GL_ELEMENT_ARRAY_BUFFER;
break;
default:
assert(0);
break;
}
return ret;
}
static GLenum memory_type(enum BufferMemoryType type) {
GLenum ret = -1;
switch (type) {
case MEMORY_STATIC:
ret = GL_STATIC_DRAW;
break;
case MEMORY_DYNAMIC:
ret = GL_DYNAMIC_DRAW;
break;
case MEMORY_DYNAMIC_COPY:
ret = GL_DYNAMIC_COPY;
break;
default:
assert(0);
break;
}
return ret;
}
static int create(
struct BufferManager* mgr,
enum BufferType type,
enum BufferMemoryType mem_type,
const void* data,
int size)
{
struct BufferManagerImpl* b = (struct BufferManagerImpl*)mgr;
struct BufferImpl* buf = (struct BufferImpl*)b->base.iface.acquire(mgr, size);
int btype = buffer_type(type);
int mtype = memory_type(mem_type);
buf->type = btype;
buf->mtype = mtype;
buf->size = size;
glGenBuffers(1, &buf->buffer);
glBindBuffer(buf->type, buf->buffer);
glBufferData(buf->type, size, data, buf->mtype);
glBindBuffer(buf->type, 0);
return buf->base.id;
}
static void update(
struct BufferManager* mgr,
int id,
const void* data,
int offset,
int size)
{
struct BufferImpl* buf = (struct BufferImpl*)mgr->get(mgr, id);
glBindBuffer(buf->type, buf->buffer);
glBufferSubData(buf->type, offset, size, data);
glBindBuffer(buf->type, 0);
}
static void release(struct BufferManager* mgr, void* buf1) {
struct BufferImpl* buf = buf1;
if (buf->base.valid) {
glDeleteBuffers(1, &buf->buffer);
}
}
struct BufferManager* buf_mgr_opengl_new(struct Render* r) {
struct BufferManagerImpl* b = calloc(1, sizeof(*b));
buffermanager_base_ctor(&b->base, sizeof(struct BufferImpl));
b->base.iface.create = create;
b->base.iface.release = release;
b->base.iface.update = update;
return (struct BufferManager*)b;
}
|
resetius/graphtoys
|
render/char.h
|
<filename>render/char.h<gh_stars>0
#pragma once
struct Char {
wchar_t ch;
int w;
int h;
int left;
int top;
int advance;
void* (*texture)(struct Char* ch);
void (*free)(struct Char* ch);
};
|
resetius/graphtoys
|
vulkan/commandbuffer.c
|
<reponame>resetius/graphtoys
#include <stdio.h>
#include <stdlib.h>
#include "commandbuffer.h"
#include "render_impl.h"
void cb_init(struct CommandBuffer* d, struct RenderImpl* r) {
VkCommandPoolCreateInfo cpInfo = {
.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,
.queueFamilyIndex = r->graphics_family,
.flags = VK_COMMAND_POOL_CREATE_TRANSIENT_BIT
};
if (vkCreateCommandPool(r->log_dev, &cpInfo, NULL, &d->pool) != VK_SUCCESS) {
fprintf(stderr, "Failed to create command pool\n");
exit(-1);
}
d->dev = r->log_dev;
}
VkCommandBuffer cb_acquire(struct CommandBuffer* d) {
VkCommandBuffer buffer;
VkCommandBufferAllocateInfo info = {
.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
.commandPool = d->pool,
.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY,
.commandBufferCount = 1
};
if (vkAllocateCommandBuffers(d->dev, &info, &buffer) != VK_SUCCESS) {
fprintf(stderr, "Failed to allocate command buffers\n");
exit(-1);
}
return buffer;
}
void cb_destroy(struct CommandBuffer* d) {
vkDestroyCommandPool(d->dev, d->pool, NULL);
}
void cb_begin(struct CommandBuffer* d, VkCommandBuffer buffer) {
VkCommandBufferBeginInfo cbBeginInfo = {
.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,
.pInheritanceInfo = NULL
};
if (vkBeginCommandBuffer(buffer, &cbBeginInfo) != VK_SUCCESS) {
fprintf(stderr, "Failed to begin command buffer\n");
exit(-1);
}
}
void cb_end(struct CommandBuffer* d, VkCommandBuffer buffer) {
if (vkEndCommandBuffer(buffer) != VK_SUCCESS) {
fprintf(stderr, "Failed to record command buffer");
exit(-1);
}
}
void cb_reset(struct CommandBuffer* d) {
vkResetCommandPool(d->dev, d->pool, 0);
}
|
resetius/graphtoys
|
opengl/program.h
|
<reponame>resetius/graphtoys<gh_stars>0
#pragma once
#include <lib/linmath.h>
struct Program {
void (*free)(struct Program*);
int (*link)(struct Program*);
int (*use)(struct Program*);
int (*validate)(struct Program*);
// vertex shader
int (*add_vs)(struct Program* p, const char* shader);
// fragment shader
int (*add_fs)(struct Program* p, const char* shader);
// compute shader
int (*add_cs)(struct Program* p, const char* shader);
int (*set_mat3x3)(struct Program*, const char* name, const mat3x3* mat);
int (*set_mat4x4)(struct Program*, const char* name, const mat4x4* mat);
int (*set_vec3)(struct Program*, const char* name, const vec3* vec);
int (*set_int)(struct Program*, const char* name, int* values, int n_values);
int (*set_sub_fs)(struct Program* p, const char* name);
int (*attrib_location)(struct Program* p, const char* name);
int (*handle)(struct Program* p);
};
void prog_free(struct Program* p);
int prog_add_vs(struct Program* p, const char* shader);
int prog_add_fs(struct Program* p, const char* shader);
int prog_add_cs(struct Program* p, const char* shader);
int prog_link(struct Program* p);
int prog_use(struct Program* p);
int prog_validate(struct Program* p);
int prog_set_mat3x3(struct Program* p, const char* name, const mat3x3* mat);
int prog_set_mat4x4(struct Program* p, const char* name, const mat4x4* mat);
int prog_set_vec3(struct Program* p, const char* name, const vec3* vec);
int prog_set_int(struct Program*, const char* name, int* values, int n_values);
int prog_set_sub_fs(struct Program* p, const char* name);
int prog_attrib_location(struct Program* p, const char* name);
int prog_handle(struct Program* p);
struct Program* prog_opengl_new();
|
resetius/graphtoys
|
vulkan/char.c
|
#include <stddef.h>
#include <render/char.h>
#include <ft2build.h>
#include FT_FREETYPE_H
#include "render_impl.h"
#include "tools.h"
struct CharImpl {
struct Char base;
struct RenderImpl* r;
// texture
struct Texture tex;
};
static void* char_texture_(struct Char* ch) {
struct CharImpl* c = (struct CharImpl*)ch;
return &c->tex;
}
static void char_free_(struct Char* ch) {
if (ch) {
struct CharImpl* c = (struct CharImpl*)ch;
vkDestroyImageView(c->r->log_dev, c->tex.view, NULL);
vkDestroyImage(c->r->log_dev, c->tex.tex, NULL);
vkFreeMemory(c->r->log_dev, c->tex.memory, NULL);
free(c);
}
}
struct Char* rend_vulkan_char_new(struct Render* r1, wchar_t ch, void* bm) {
struct CharImpl* c = calloc(1, sizeof(*c));
struct RenderImpl* r = (struct RenderImpl*)r1;
FT_Face face = (FT_Face)bm;
FT_Bitmap bitmap = face->glyph->bitmap;
struct Char base = {
.free = char_free_,
.texture = char_texture_,
};
c->base = base;
c->base.ch = ch;
c->base.w = bitmap.width;
c->base.h = bitmap.rows;
c->base.left = face->glyph->bitmap_left;
c->base.top = face->glyph->bitmap_top;
c->base.advance = face->glyph->advance.x;
c->r = r;
VkBuffer stagingBuffer;
VkDeviceMemory stagingBufferMemory;
VkDeviceSize imageSize = bitmap.width*bitmap.rows;
if (imageSize == 0) {
free(c);
return NULL;
}
create_buffer(
r->memory_properties, r->log_dev,
imageSize,
VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
&stagingBuffer, &stagingBufferMemory);
char* data;
vkMapMemory(r->log_dev, stagingBufferMemory, 0, imageSize, 0, (void*)&data);
if (bitmap.pitch == bitmap.width) {
memcpy(data, bitmap.buffer, imageSize);
} else {
for (int i = 0; i < bitmap.rows; i++) {
memcpy(&data[i*bitmap.width], bitmap.buffer+bitmap.pitch*i, bitmap.width);
}
}
vkUnmapMemory(r->log_dev, stagingBufferMemory);
create_image(
r->memory_properties, r->log_dev,
bitmap.width,
bitmap.rows,
VK_FORMAT_R8_UNORM,
VK_IMAGE_TILING_OPTIMAL,
VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
&c->tex.tex, &c->tex.memory);
transition_image_layout(
r->graphics_family,
r->g_queue,
r->log_dev,
c->tex.tex,
VK_FORMAT_R8_UNORM,
VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
copy_buffer_to_image(
r->graphics_family,
r->g_queue,
r->log_dev,
stagingBuffer, c->tex.tex, bitmap.width, bitmap.rows);
transition_image_layout(
r->graphics_family,
r->g_queue,
r->log_dev,
c->tex.tex,
VK_FORMAT_R8_UNORM, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
vkDestroyBuffer(r->log_dev, stagingBuffer, NULL);
vkFreeMemory(r->log_dev, stagingBufferMemory, NULL);
c->tex.view = create_image_view(
r->log_dev,
c->tex.tex, VK_FORMAT_R8_UNORM, VK_IMAGE_ASPECT_COLOR_BIT);
return (struct Char*)c;
}
|
resetius/graphtoys
|
render/pipeline.h
|
<reponame>resetius/graphtoys<gh_stars>0
#pragma once
#include <stdint.h>
#include "render.h"
#include "buffer.h" // TODO: remove
enum GeometryType {
GEOM_TRIANGLES = 0,
GEOM_POINTS
};
enum DataType {
DATA_FLOAT = 0,
DATA_INT
};
enum CullType {
CULL_FRONT = 1,
CULL_BACK = 2,
CULL_BOTH = 3
};
enum WrapType {
WRAP_NONE = 0,
WRAP_REPEAT,
WRAP_MIRRORED_REPEAT,
WRAP_CLAMP_TO_EDGE,
WRAP_CLAMP_TO_BORDER
};
enum FilterType {
FILTER_NONE = 0,
FILTER_NEAREST,
FILTER_LINEAR,
FILTER_NEAREST_MIPMAP_NEAREST,
FILTER_LINEAR_MIPMAP_NEAREST,
FILTER_NEAREST_MIPMAP_LINEAR,
FILTER_LINEAR_MIPMAP_LINEAR,
};
struct Pipeline {
void (*free)(struct Pipeline*);
void (*storage_assign)(struct Pipeline* p1, int storage_id, int buffer_id);
void (*uniform_assign)(struct Pipeline* p1, int uniform_id, int buffer_id);
int (*buffer_assign)(struct Pipeline* p1, int descriptor_id, int buffer_id);
void (*storage_swap)(struct Pipeline* p1,
int dst, int src);
void (*use_texture)(struct Pipeline* p1, void* texture);
void (*start_compute)(struct Pipeline* p1, int sx, int sy, int sz);
void (*start)(struct Pipeline* p1);
void (*draw)(struct Pipeline* p1, int buffer_id);
void (*draw_indexed)(struct Pipeline* p1, int buffer_id, int buffer_index_id, int index_byte_size);
};
void pl_free(struct Pipeline*);
void pl_storage_assign(struct Pipeline* p1, int storage_id, int buffer_id);
void pl_uniform_assign(struct Pipeline* p1, int uniform_id, int buffer_id);
int pl_buffer_assign(struct Pipeline* p1, int descriptor_id, int buffer_id);
void pl_use_texture(struct Pipeline* p1, void* texture);
void pl_start(struct Pipeline*);
void pl_draw(struct Pipeline* p1, int buffer_id);
struct ShaderCode {
const char* glsl;
const char* spir_v;
int size;
};
struct PipelineBuilder {
struct PipelineBuilder* (*set_bmgr)(struct PipelineBuilder*, struct BufferManager*);
struct PipelineBuilder* (*begin_program)(struct PipelineBuilder*);
struct PipelineBuilder* (*add_vs)(struct PipelineBuilder*, struct ShaderCode shader);
struct PipelineBuilder* (*add_fs)(struct PipelineBuilder*, struct ShaderCode shader);
struct PipelineBuilder* (*add_cs)(struct PipelineBuilder*, struct ShaderCode shader);
struct PipelineBuilder* (*end_program)(struct PipelineBuilder*);
struct PipelineBuilder* (*begin_buffer)(struct PipelineBuilder*, int stride);
struct PipelineBuilder* (*buffer_attribute)(
struct PipelineBuilder*,
int location,
int channels, enum DataType data_type,
uint64_t offset);
struct PipelineBuilder* (*end_buffer)(struct PipelineBuilder*);
struct PipelineBuilder* (*storage_add)(
struct PipelineBuilder*p1,
int binding,
const char* name);
struct PipelineBuilder* (*uniform_add)(
struct PipelineBuilder*p1,
int binding,
const char* name);
struct PipelineBuilder* (*begin_sampler)(struct PipelineBuilder* p1, int binding);
struct PipelineBuilder* (*sampler_mag_filter)(struct PipelineBuilder* p1, enum FilterType);
struct PipelineBuilder* (*sampler_min_filter)(struct PipelineBuilder* p1, enum FilterType);
struct PipelineBuilder* (*sampler_wrap_s)(struct PipelineBuilder* p1, enum WrapType);
struct PipelineBuilder* (*sampler_wrap_t)(struct PipelineBuilder* p1, enum WrapType);
struct PipelineBuilder* (*end_sampler)(struct PipelineBuilder* p1);
struct PipelineBuilder* (*enable_depth)(struct PipelineBuilder* p1);
struct PipelineBuilder* (*enable_blend)(struct PipelineBuilder* p1);
struct PipelineBuilder* (*enable_cull)(struct PipelineBuilder* p1, enum CullType cull);
struct PipelineBuilder* (*geometry)(struct PipelineBuilder* p1, enum GeometryType type);
struct Pipeline* (*build)(struct PipelineBuilder*); // free
};
|
resetius/graphtoys
|
models/mandelbulb.h
|
<filename>models/mandelbulb.h
#pragma once
#include <render/render.h>
#include <lib/object.h>
struct Config;
struct Object* CreateMandelbulb(struct Render*, struct Config*);
|
resetius/graphtoys
|
lib/formats/stl.h
|
<filename>lib/formats/stl.h<gh_stars>0
#pragma once
#include <lib/linmath.h>
struct StlVertex {
vec3 col;
vec3 norm;
vec3 pos;
};
struct StlVertex* stl_load(const char* fname, int* nvertices);
|
resetius/graphtoys
|
models/particles.h
|
#pragma once
#include <lib/object.h>
struct Render;
struct Config;
struct Object* CreateParticles(struct Render* r, struct Config* cfg);
|
resetius/graphtoys
|
vulkan/render.c
|
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include "vk.h"
#define GLFW_INCLUDE_NONE
#include <GLFW/glfw3.h>
#include <render/render.h>
#include <lib/config.h>
#include "device.h"
#include "renderpass.h"
#include "swapchain.h"
#include "render_impl.h"
#include "stats.h"
struct BufferManager* buf_mgr_vulkan_new(struct Render* r);
void vk_load_global();
void vk_load_instance(VkInstance instance);
void vk_load_device(VkDevice device);
struct Texture* vk_tex_new(struct Render* r, void* data, enum TexType tex_type);
static void free_(struct Render* r1) {
int i;
struct RenderImpl* r = (struct RenderImpl*)r1;
rt_destroy(&r->rt);
rp_destroy(&r->rp);
sc_destroy(&r->sc);
vk_stats_free(r->stats);
for (i = 0; i < r->sc.n_images; i++) {
frame_destroy(&r->frames[i]);
}
for (i = 0; i < r->n_recycled_semaphores; i++) {
vkDestroySemaphore(r->log_dev, r->recycled_semaphores[i], NULL);
}
vkDestroyDevice(r->log_dev, NULL);
vkDestroySurfaceKHR(r->instance, r->surface, NULL);
vkDestroyInstance(r->instance, NULL);
free(r->modes);
free(r->formats);
free(r);
}
static void draw_begin_(struct Render* r1) {
struct RenderImpl* r = (struct RenderImpl*)r1;
if (r->update_viewport) {
vkDeviceWaitIdle(r->log_dev);
vkGetPhysicalDeviceSurfaceCapabilitiesKHR(r->phy_dev, r->surface, &r->caps);
rt_destroy(&r->rt);
rp_destroy(&r->rp);
sc_destroy(&r->sc);
sc_init(&r->sc, r);
rp_init(&r->rp, r->log_dev, r->sc.im_format, r->sc.depth_format);
rt_init(&r->rt, r);
r->update_viewport = 0;
VkRect2D scissor = {{0, 0}, r->sc.extent};
r->scissor = scissor;
}
assert(r->n_recycled_semaphores > 0);
VkSemaphore acquire_sem = r->recycled_semaphores[--r->n_recycled_semaphores];
vkAcquireNextImageKHR(
r->log_dev,
r->sc.swapchain,
UINT64_MAX,
acquire_sem,
VK_NULL_HANDLE,
&r->image_index);
r->frame = &r->frames[r->image_index];
if (r->frame->acquire_image != VK_NULL_HANDLE) {
r->recycled_semaphores[r->n_recycled_semaphores++] = r->frame->acquire_image;
r->frame->acquire_image = VK_NULL_HANDLE;
}
r->frame->acquire_image = acquire_sem;
vkWaitForFences(r->log_dev, 1, &r->frame->fence, VK_TRUE, UINT64_MAX);
vkResetFences(r->log_dev, 1, &r->frame->fence);
r->buffer = frame_cb(r->frame);
cb_begin(&r->frame->cb, r->buffer);
vkCmdSetViewport(r->buffer, 0, 1, &r->viewport);
vkCmdSetScissor(r->buffer, 0, 1, &r->scissor);
VkClearColorValue color = {
.float32 = {0.0f, 0.0f, 0.0f, 1.0f}
};
VkClearValue clear_color = {
.color = color
};
VkClearValue clear_depth = {
.depthStencil = {1.0f, 0}
};
VkClearValue values[] = { clear_color, clear_depth };
rp_begin(
&r->rp,
values, 2,
r->buffer,
r->rt.framebuffers[r->image_index],
r->sc.extent);
}
static void draw_end_(struct Render* r1) {
struct RenderImpl* r = (struct RenderImpl*)r1;
rp_end(&r->rp, r->buffer);
cb_end(&r->frame->cb, r->buffer);
VkPipelineStageFlags waitStages[] = { VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT };
VkSubmitInfo submitInfo = {
.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO,
.commandBufferCount = 1,
.pCommandBuffers = &r->buffer,
.pWaitDstStageMask = waitStages,
.waitSemaphoreCount = 1,
.pWaitSemaphores = &r->frame->acquire_image,
.signalSemaphoreCount = 1,
.pSignalSemaphores = &r->frame->render_finished
};
vkQueueSubmit(r->g_queue, 1, &submitInfo, r->frame->fence);
VkPresentInfoKHR presentInfo = {
.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR,
.waitSemaphoreCount = 1,
.pWaitSemaphores = &r->frame->render_finished,
.swapchainCount = 1,
.pSwapchains = &r->sc.swapchain,
.pImageIndices = &r->image_index
};
vkQueuePresentKHR(r->p_queue, &presentInfo);
}
static void set_window_(struct Render* r1, void* w) {
struct RenderImpl* r = (struct RenderImpl*)r1;
r->window = w;
}
static void find_queue_families(struct RenderImpl* r) {
uint32_t count = 0;
VkQueueFamilyProperties* families;
int i;
vkGetPhysicalDeviceQueueFamilyProperties(r->phy_dev, &count, NULL);
printf("Found %d queue families\n", count);
families = malloc(count*sizeof(VkQueueFamilyProperties));
vkGetPhysicalDeviceQueueFamilyProperties(r->phy_dev, &count, families);
r->compute_family = r->graphics_family = r->present_family = -1;
for (i = 0; i < count; i++) {
VkBool32 flag = 0;
if (families[i].queueCount > 0 && (families[i].queueFlags & VK_QUEUE_GRAPHICS_BIT)) {
r->graphics_family = i;
}
if (families[i].queueCount > 0 && (families[i].queueFlags & VK_QUEUE_COMPUTE_BIT)) {
r->compute_family = i;
}
vkGetPhysicalDeviceSurfaceSupportKHR(r->phy_dev, i, r->surface, &flag);
if (families[i].queueCount > 0 && flag) {
r->present_family = i;
}
if (r->present_family >= 0 && r->graphics_family >= 0 && r->compute_family >= 0) {
break;
}
}
printf("Present: %d, graphics: %d, compute: %d\n",
r->present_family,
r->graphics_family,
r->compute_family);
free(families);
}
static void init_(struct Render* r1) {
struct RenderImpl* r = (struct RenderImpl*)r1;
uint32_t deviceCount = 0;
const char* deviceExtensions[] = {
VK_KHR_SWAPCHAIN_EXTENSION_NAME,
"VK_KHR_portability_subset",
"VK_KHR_performance_query",
};
uint32_t nDeviceExtensions = sizeof(deviceExtensions)/sizeof(const char*);
VkPhysicalDevice devices[100];
VkDeviceQueueCreateInfo queueCreateInfo[2];
uint32_t nQueueCreateInfo = 2;
float queuePriority = 1.0f;
int i;
if (glfwCreateWindowSurface(r->instance, r->window, NULL, &r->surface) != VK_SUCCESS)
{
fprintf(stderr, "Cannot create window surface\n");
exit(-1);
}
printf("Vulkan surface created\n");
vkEnumeratePhysicalDevices(r->instance, &deviceCount, NULL);
printf("Found devices: %d\n", deviceCount);
if (deviceCount == 0) { exit(-1); }
if (deviceCount > sizeof(devices)/sizeof(VkPhysicalDevice)) {
printf("Cut devices\n");
}
vkEnumeratePhysicalDevices(r->instance, &deviceCount, devices);
printf("Devices:\n");
for (i = 0; i < deviceCount; i++) {
vkGetPhysicalDeviceProperties(devices[i], &r->properties);
printf("Name: %d: '%s'\n", i, r->properties.deviceName);
// TODO: check device
}
int dev_id = cfg_geti_def(r->cfg.cfg, "dev", 0);
if (dev_id < deviceCount) {
printf("Using device: %d\n", dev_id);
r->phy_dev = devices[dev_id];
}
vkGetPhysicalDeviceFeatures(r->phy_dev, &r->features);
vkGetPhysicalDeviceMemoryProperties(r->phy_dev, &r->memory_properties);
find_queue_families(r);
printf("graphics_family: %d, present_family: %d\n",
r->graphics_family,
r->present_family);
if (r->graphics_family == r->present_family) {
nQueueCreateInfo = 1;
queueCreateInfo[0].queueFamilyIndex = r->graphics_family;
} else {
queueCreateInfo[0].queueFamilyIndex = r->graphics_family;
queueCreateInfo[1].queueFamilyIndex = r->present_family;
}
// TODO: hide into Device
for (i = 0; i < nQueueCreateInfo; i++) {
VkDeviceQueueCreateInfo info = {
.queueFamilyIndex = queueCreateInfo[i].queueFamilyIndex,
.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO,
.queueCount = 1,
.pQueuePriorities = &queuePriority
};
queueCreateInfo[i] = info;
}
device_new(&r->device, r->phy_dev, deviceExtensions, nDeviceExtensions, queueCreateInfo, nQueueCreateInfo);
r->log_dev = r->device.dev; // TODO
vk_load_device(r->log_dev);
vkGetDeviceQueue(r->log_dev, r->graphics_family, 0, &r->g_queue);
vkGetDeviceQueue(r->log_dev, r->present_family, 0, &r->p_queue);
vkGetPhysicalDeviceSurfaceCapabilitiesKHR(r->phy_dev, r->surface, &r->caps);
vkGetPhysicalDeviceSurfaceFormatsKHR(r->phy_dev, r->surface, &r->n_formats, NULL);
if (r->n_formats) {
r->formats = malloc(r->n_formats*sizeof(VkSurfaceFormatKHR));
vkGetPhysicalDeviceSurfaceFormatsKHR(r->phy_dev, r->surface, &r->n_formats, r->formats);
}
vkGetPhysicalDeviceSurfacePresentModesKHR(r->phy_dev, r->surface, &r->n_modes, NULL);
if (r->n_modes) {
r->modes = malloc(r->n_modes*sizeof(VkPresentModeKHR));
vkGetPhysicalDeviceSurfacePresentModesKHR(r->phy_dev, r->surface, &r->n_modes, r->modes);
}
printf("formats: %d, modes: %d\n", r->n_formats, r->n_modes);
printf("Logical device created\n");
sc_init(&r->sc, r);
printf("Swapchain initialized\n");
rp_init(&r->rp, r->log_dev, r->sc.im_format, r->sc.depth_format);
printf("Renderpass initialized\n");
rt_init(&r->rt, r);
printf("Rendertarget initialized\n");
VkSemaphoreCreateInfo semaphoreInfo = {
.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO
};
r->n_recycled_semaphores = sizeof(r->recycled_semaphores)/sizeof(VkSemaphore);
for (int i = 0; i < r->n_recycled_semaphores; i++) {
vkCreateSemaphore(r->log_dev, &semaphoreInfo, NULL, &r->recycled_semaphores[i]);
}
for (int i = 0; i < r->sc.n_images; i++) {
frame_init(&r->frames[i], r);
}
int w = r->sc.extent.width;
int h = r->sc.extent.height;
VkViewport viewport = {
.x = 0,
.y = h,
.width = w,
.height = -h,
.minDepth = 0.0f,
.maxDepth = 1.0f
};
r->viewport = viewport;
VkRect2D scissor = {{0, 0}, r->sc.extent};
r->scissor = scissor;
r->stats = vk_stats_new(r);
}
static void set_viewport_(struct Render* r1, int w, int h) {
struct RenderImpl* r = (struct RenderImpl*)r1;
VkViewport viewport = {
.x = 0,
.y = h,
.width = w,
.height = -h,
.minDepth = 0.0f,
.maxDepth = 1.0f
};
r->viewport = viewport;
r->update_viewport = 1;
}
struct PipelineBuilder* pipeline_builder_vulkan(struct Render* r);
struct Char* rend_vulkan_char_new(struct Render* r1, wchar_t ch, void* bm);
struct Render* rend_vulkan_new(struct RenderConfig cfg) {
struct RenderImpl* r = calloc(1, sizeof(*r));
struct Render base = {
.free = free_,
.init = init_,
.set_view_entity = set_window_,
.draw_begin = draw_begin_,
.draw_end = draw_end_,
.set_viewport = set_viewport_,
.pipeline = pipeline_builder_vulkan,
.char_new = rend_vulkan_char_new,
.buffer_manager = buf_mgr_vulkan_new,
.tex_new = vk_tex_new,
};
uint32_t extensionCount = 0;
const char** glfwExtensionNames = glfwGetRequiredInstanceExtensions(&extensionCount);
uint32_t allExtCount = 0;
VkExtensionProperties* exts;
vk_load_global();
vkEnumerateInstanceExtensionProperties(NULL, &allExtCount, NULL);
exts = malloc(allExtCount*sizeof(VkExtensionProperties));
vkEnumerateInstanceExtensionProperties(NULL, &allExtCount, exts);
printf("Supported instance extensions:\n");
for (int i = 0; i < allExtCount; i++) {
printf("'%s'\n", exts[i].extensionName);
}
printf("\n");
free(exts);
const char** extensionNames = malloc((extensionCount+10)*sizeof(char*));
int i;
for (i = 0; i < extensionCount; i++) {
extensionNames[i] = glfwExtensionNames[i];
}
extensionNames[i++] = "VK_KHR_get_physical_device_properties2";
extensionCount = i;
VkApplicationInfo appInfo = {
.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO,
.pApplicationName = "Graph Toys",
.applicationVersion = VK_MAKE_VERSION(1, 0, 0),
.pEngineName = "GraphToys",
.engineVersion = VK_MAKE_VERSION(1, 0, 0),
.apiVersion = VK_MAKE_VERSION(1, 2, 0)
};
VkInstanceCreateInfo vkInstanceInfo = {
.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
.pNext = NULL,
.flags = 0,
.pApplicationInfo = &appInfo,
.enabledLayerCount = 0,
.enabledExtensionCount = extensionCount,
.ppEnabledExtensionNames = extensionNames
};
printf("Loading extensions:\n");
for (int i = 0; i < extensionCount; i++) {
printf("'%s'\n", extensionNames[i]);
}
r->base = base;
r->cfg = cfg;
glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
if (vkCreateInstance(&vkInstanceInfo, NULL, &r->instance) != VK_SUCCESS) {
fprintf(stderr, "Cannot initialize vulkan\n");
exit(-1);
}
free(extensionNames);
vk_load_instance(r->instance);
return (struct Render*)r;
}
|
resetius/graphtoys
|
vulkan/stats.c
|
<reponame>resetius/graphtoys<filename>vulkan/stats.c
#include <stdio.h>
#include <stdlib.h>
#include "stats.h"
#include "render_impl.h"
struct VkStats {
struct RenderImpl* r;
int has_timestamps;
float timestamp_period;
};
struct VkStats* vk_stats_new(struct RenderImpl* r) {
struct VkStats* v = calloc(1, sizeof(*v));
v->r = r;
if (!device_ext_is_enabled(&r->device, "VK_KHR_performance_query")) {
printf("VK_KHR_performance_query is disabled, performance counters are not available\n");
return v;
}
v->has_timestamps = r->properties.limits.timestampComputeAndGraphics;
v->timestamp_period = r->properties.limits.timestampPeriod;
printf("has_timestamps: %d\n", v->has_timestamps);
printf("timestamp_period: %f\n", v->timestamp_period);
uint32_t n_counters = 0;
vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(
r->phy_dev, r->graphics_family, &n_counters, 0, 0);
printf("n_counters: %d\n", n_counters);
return v;
}
void vk_stats_free(struct VkStats* v) {
free(v);
}
|
resetius/graphtoys
|
vulkan/frame.c
|
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "frame.h"
void frame_init(struct Frame* frame, struct RenderImpl* r) {
memset(frame, 0, sizeof(*frame));
cb_init(&frame->cb, r);
frame->cmd = cb_acquire(&frame->cb);
VkFenceCreateInfo info = {
.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,
.flags = VK_FENCE_CREATE_SIGNALED_BIT
};
if (vkCreateFence(frame->cb.dev, &info, NULL, &frame->fence) != VK_SUCCESS) {
fprintf(stderr, "Failed to create synchronization objects per frame\n");
exit(-1);
}
VkSemaphoreCreateInfo sem_info = {
.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO
};
vkCreateSemaphore(frame->cb.dev, &sem_info, NULL, &frame->render_finished);
}
void frame_destroy(struct Frame* frame) {
vkDestroyFence(frame->cb.dev, frame->fence, NULL);
vkDestroySemaphore(frame->cb.dev, frame->render_finished, NULL);
if (frame->acquire_image != VK_NULL_HANDLE) {
vkDestroySemaphore(frame->cb.dev, frame->acquire_image, NULL);
}
cb_destroy(&frame->cb);
}
VkCommandBuffer frame_cb(struct Frame* frame) {
cb_reset(&frame->cb);
return frame->cmd;
}
|
resetius/graphtoys
|
models/stl.h
|
#pragma once
#include <render/render.h>
#include <lib/object.h>
#include <lib/config.h>
struct Object* CreateStl(struct Render* r, struct Config* cfg);
|
resetius/graphtoys
|
vulkan/device.h
|
#pragma once
#include "vk.h"
struct PhysicalDevice {
VkPhysicalDevice dev;
VkPhysicalDeviceFeatures features;
VkPhysicalDeviceMemoryProperties memory_properties;
VkPhysicalDeviceProperties properties;
};
struct Device {
VkDevice dev;
VkExtensionProperties* extensions;
uint32_t n_extensions;
const char** enabled_extensions;
int n_enabled_extensions;
};
void device_new(struct Device* dev, VkPhysicalDevice gpu, const char** enable, int n_enable, const VkDeviceQueueCreateInfo* queue_info, int n_queue_info);
int device_ext_is_enabled(struct Device* dev, const char* name);
void device_free(struct Device* dev);
|
resetius/graphtoys
|
models/particles2.h
|
<reponame>resetius/graphtoys
#pragma once
#include <lib/object.h>
struct Render;
struct Config;
struct Object* CreateParticles2(struct Render* r, struct Config* config);
|
resetius/graphtoys
|
render/render.h
|
<filename>render/render.h
#pragma once
#include <stddef.h>
struct Texture;
struct Char;
struct PipelineBuilder;
struct BufferManager;
struct Config;
struct RenderConfig {
const char* api;
// 0 - off
// 1 - on
// 2 - adaptive
int vsync;
int show_fps;
int triple_buffer;
int fullscreen;
int vidmode;
struct Config* cfg;
};
enum TexType {
TEX_KTX = 0
};
struct Render {
struct PipelineBuilder* (*pipeline)(struct Render*);
struct BufferManager* (*buffer_manager)(struct Render*);
struct Texture* (*tex_new)(struct Render*, void* data, enum TexType tex_type);
struct Char* (*char_new)(struct Render*, wchar_t ch, void* face);
void (*free)(struct Render*);
void (*init)(struct Render*);
void (*set_view_entity)(struct Render*, void* );
void (*draw_begin)(struct Render*);
void (*draw_end)(struct Render*);
void (*set_viewport)(struct Render*, int w, int h);
};
struct Render* rend_opengl_new(struct RenderConfig cfg);
struct Render* rend_vulkan_new(struct RenderConfig cfg);
void rend_free(struct Render*);
struct Texture* rend_tex_new(struct Render*, void* data, enum TexType tex_type);
struct Char* rend_char_new(struct Render*, wchar_t ch, void* face);
|
resetius/graphtoys
|
models/mandelbrot.c
|
<filename>models/mandelbrot.c
#include <stdlib.h>
#include <stdio.h>
#include <render/pipeline.h>
#include "mandelbrot.h"
#include <models/mandelbrot.vert.h>
#include <models/mandelbrot.frag.h>
#include <models/mandelbrot.vert.spv.h>
#include <models/mandelbrot.frag.spv.h>
#include <lib/object.h>
#include <lib/linmath.h>
struct Vertex {
vec3 pos;
};
struct UniformBlock {
mat4x4 mvp;
vec3 T;
};
struct Mandelbrot {
struct Object base;
struct UniformBlock uniform;
struct Pipeline* pl;
struct BufferManager* b;
int uniform_id;
vec3 T;
int model;
};
static void t_left(struct Object* obj, int mods) {
struct Mandelbrot* t = (struct Mandelbrot*)obj;
t->T[0] += t->T[2]*0.01;
}
static void t_right(struct Object* obj, int mods) {
struct Mandelbrot* t = (struct Mandelbrot*)obj;
t->T[0] -= t->T[2]*0.01;
}
static void t_up(struct Object* obj, int mods) {
struct Mandelbrot* t = (struct Mandelbrot*)obj;
t->T[1] += t->T[2]*0.01;
}
static void t_down(struct Object* obj, int mods) {
struct Mandelbrot* t = (struct Mandelbrot*)obj;
t->T[1] -= t->T[2]*0.01;
}
static void t_zoom_in(struct Object* obj, int mods) {
struct Mandelbrot* t = (struct Mandelbrot*)obj;
t->T[2] /= 1.01;
}
static void t_zoom_out(struct Object* obj, int mods) {
struct Mandelbrot* t = (struct Mandelbrot*)obj;
t->T[2] *= 1.01;
}
static void t_draw(struct Object* obj, struct DrawContext* ctx) {
struct Mandelbrot* t = (struct Mandelbrot*)obj;
//vec3 T = {0.0f, 0.0f, 2.0f};
mat4x4 m, v, mv, p, mvp;
mat4x4_identity(m);
//mat4x4_rotate_X(m, m, (float)glfwGetTime());
//mat4x4_rotate_Y(m, m, (float)glfwGetTime());
//mat4x4_rotate_Z(m, m, (float)glfwGetTime());
//mat4x4_rotate_Z(m, m, (float)glfwGetTime());
//mat4x4_ortho(p, -ctx->ratio, ctx->ratio, -1.f, 1.f, 1.f, -1.f);
//mat4x4_mul(mvp, p, m);
vec3 eye = {.0f, .0f, -1.f};
vec3 center = {.0f, .0f, .0f};
vec3 up = {.0f, 1.f, .0f};
mat4x4_look_at(v, eye, center, up);
mat4x4_mul(mv, v, m);
mat4x4_perspective(p, 70./2./M_PI, ctx->ratio, 0.3f, 100.f);
mat4x4_mul(mvp, p, mv);
memcpy(t->uniform.mvp, mvp, sizeof(mvp));
memcpy(t->uniform.T, t->T, sizeof(t->T));
t->pl->start(t->pl);
buffer_update(t->b, t->uniform_id, &t->uniform, 0, sizeof(t->uniform));
t->pl->draw(t->pl, t->model);
}
static void t_free(struct Object* obj) {
struct Mandelbrot* t = (struct Mandelbrot*)obj;
t->pl->free(t->pl);
t->b->free(t->b);
free(t);
}
struct Object* CreateMandelbrot(struct Render* r, struct Config* cfg) {
struct Mandelbrot* t = calloc(1, sizeof(struct Mandelbrot));
struct Vertex vertices[] = {
{{ 1.0f,-1.0f,0.0f}},
{{-1.0f,-1.0f,0.0f}},
{{-1.0f, 1.0f,0.0f}},
{{ 1.0f, 1.0f,0.0f}},
{{ 1.0f,-1.0f,0.0f}},
{{-1.0f, 1.0f,0.0f}},
};
int nvertices = 6;
struct Object base = {
.draw = t_draw,
.free = t_free,
.move_left = t_left,
.move_right = t_right,
.move_up = t_up,
.move_down = t_down,
.zoom_in = t_zoom_in,
.zoom_out = t_zoom_out
};
struct ShaderCode vertex_shader = {
.glsl = models_mandelbrot_vert,
.spir_v = models_mandelbrot_vert_spv,
.size = models_mandelbrot_vert_spv_size,
};
struct ShaderCode fragment_shader = {
.glsl = models_mandelbrot_frag,
.spir_v = models_mandelbrot_frag_spv,
.size = models_mandelbrot_frag_spv_size,
};
t->base = base;
t->b = r->buffer_manager(r);
struct PipelineBuilder* pl = r->pipeline(r);
t->pl = pl
->set_bmgr(pl, t->b)
->begin_program(pl)
->add_vs(pl, vertex_shader)
->add_fs(pl, fragment_shader)
->end_program(pl)
->uniform_add(pl, 0, "MatrixBlock")
->begin_buffer(pl, sizeof(struct Vertex))
->buffer_attribute(pl, 1, 3, DATA_FLOAT, offsetof(struct Vertex, pos))
->end_buffer(pl)
->build(pl);
t->uniform_id = buffer_create(t->b, BUFFER_UNIFORM, MEMORY_DYNAMIC, NULL, sizeof(struct UniformBlock));
pl_uniform_assign(t->pl, 0, t->uniform_id);
int model_buffer_id = buffer_create(t->b, BUFFER_ARRAY, MEMORY_STATIC, vertices, nvertices*sizeof(struct Vertex));
t->model = pl_buffer_assign(t->pl, 0, model_buffer_id);
t->T[0] = t->T[1] = 0.0; t->T[2] = 2.0;
return (struct Object*)t;
}
|
resetius/graphtoys
|
vulkan/rendertarget.c
|
#include <stdio.h>
#include <stdlib.h>
#include "rendertarget.h"
#include "render_impl.h"
#include "tools.h"
void rt_init(struct RenderTarget* rt, struct RenderImpl* r) {
int i;
rt->n_imageviews = r->sc.n_images;
rt->imageviews = malloc(rt->n_imageviews*sizeof(VkImageView));
for (i = 0; i < rt->n_imageviews; i++) {
rt->imageviews[i] = create_image_view(
r->log_dev,
r->sc.images[i],
r->sc.im_format,
VK_IMAGE_ASPECT_COLOR_BIT);
}
rt->depth_imageview = create_image_view(r->log_dev, r->sc.depth_image,
r->sc.depth_format,
VK_IMAGE_ASPECT_DEPTH_BIT);
rt->n_framebuffers = rt->n_imageviews;
rt->framebuffers = malloc(rt->n_framebuffers*sizeof(VkFramebuffer));
for (i = 0; i < rt->n_framebuffers; i++) {
VkImageView attachments[] = {
rt->imageviews[i],
rt->depth_imageview
};
int n_attachments = 2;
VkFramebufferCreateInfo fbInfo = {
.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO,
.renderPass = r->rp.rp,
.attachmentCount = n_attachments,
.pAttachments = attachments,
.width = r->sc.extent.width,
.height = r->sc.extent.height,
.layers = 1
};
if (vkCreateFramebuffer(r->log_dev, &fbInfo, NULL, &rt->framebuffers[i]) != VK_SUCCESS)
{
fprintf(stderr, "Failed to create framebuffers\n");
exit(-1);
}
}
rt->dev = r->log_dev;
}
void rt_destroy(struct RenderTarget* rt) {
int i;
for (i = 0; i < rt->n_imageviews; i++) {
vkDestroyImageView(rt->dev, rt->imageviews[i], NULL);
}
vkDestroyImageView(rt->dev, rt->depth_imageview, NULL);
for (i = 0; i < rt->n_framebuffers; i++) {
vkDestroyFramebuffer(rt->dev, rt->framebuffers[i], NULL);
}
free(rt->imageviews);
free(rt->framebuffers);
}
|
resetius/graphtoys
|
lib/formats/gltf.h
|
#pragma once
#include <lib/linmath.h>
#include <stdint.h>
struct GltfAccessor {
char name[256];
int64_t offset;
int view;
int component_type;
int count;
int components;
vec4 max;
vec4 min;
};
struct GltfBuffer {
char* data;
int64_t size;
int buffer;
};
struct GltfView {
char name[256];
char* data;
int buffer;
int stride;
int64_t size;
};
struct GltfTextureInfo {
int index;
int tex_coord; // 0
};
struct GltfNormalTextureInfo {
int index;
int tex_coord; // 0
float scale; // 1
};
struct GltfOcclusionTextureInfo {
int index;
int tex_coord; // 0
float strength; // 1
};
struct GltfMetallicRoughness {
vec4 base_color_factor; // [1,1,1,1]
struct GltfTextureInfo base_color_texture;
int has_base_color_texture; // 0
float metallic_factor; // 1
float roughness_factor; // 1
struct GltfTextureInfo metallic_roughness_texture;
int has_metallic_roughness_texture; // 0
};
struct GltfMaterial {
char name[256];
struct GltfMetallicRoughness pbr_metallic_roughness;
int has_pbr_metallic_roughness; // 0
struct GltfNormalTextureInfo normal_texture;
int has_normal_texture; // 0
struct GltfOcclusionTextureInfo occlusion_texture;
int has_occlusion_texture; // 0
struct GltfTextureInfo emissive_texture;
int has_emissive_texture; // 0
vec3 emissive_factor; // [0,0,0]
int alpha_mode; // OPAQUE
float alpha_cutoff; // 0.5
int double_sided; // 0
};
struct GltfPrimitive {
// attributes
int normal;
int position;
int texcoord[10];
int n_texcoords;
int tangent;
int indices;
int material;
};
struct GltfMesh {
char name[256];
struct GltfPrimitive* primitives;
int cap_primitives;
int n_primitives;
};
struct GltfNode {
char name[256];
int mesh;
int camera;
quat rotation;
vec3 scale;
vec3 translation;
mat4x4 matrix;
mat4x4 norm_matrix;
};
struct GltfScene {
char name[256];
int nodes[1024];
int n_nodes;
};
struct GltfCameraPerspective {
double aspect;
double yfov;
double zfar;
double znear;
};
struct GltfCameraOrthographic {
double xmag;
double ymag;
double zfar;
double znear;
};
struct GltfCamera {
char name[256];
int is_perspective;
struct GltfCameraPerspective perspective;
struct GltfCameraOrthographic orthographic;
};
struct GltfImage {
char name[256];
void* texture;
};
struct GltfTexture {
int source;
};
struct Gltf {
struct GltfAccessor* accessors;
int cap_accessors;
int n_accessors;
struct GltfScene* scenes;
int cap_scenes;
int n_scenes;
struct GltfNode* nodes;
int cap_nodes;
int n_nodes;
struct GltfMesh* meshes;
int cap_meshes;
int n_meshes;
struct GltfBuffer* buffers;
int cap_buffers;
int n_buffers;
struct GltfView* views;
int cap_views;
int n_views;
struct GltfCamera* cameras;
int cap_cameras;
int n_cameras;
struct GltfImage* images;
int cap_images;
int n_images;
struct GltfTexture* textures;
int cap_textures;
int n_textures;
struct GltfMaterial* materials;
int cap_materials;
int n_materials;
int def;
char fsbase[1024];
};
struct Gltf* gltf_alloc();
void gltf_free(struct Gltf*);
void gltf_ctor(struct Gltf*, const char* fn);
void gltf_dtor(struct Gltf*);
|
resetius/graphtoys
|
test/base64.c
|
<reponame>resetius/graphtoys<filename>test/base64.c
#include <stdarg.h>
#include <stddef.h>
#include <setjmp.h>
#include <cmocka.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <lib/formats/base64.h>
static void test_dec(const char* str, const char* dst) {
int64_t size;
char* out = base64_decode(str, strlen(str), &size);
assert_string_equal(out, dst);
assert_int_equal(size, strlen(dst));
free(out);
}
static void test_enc(const char* str, const char* dst) {
int64_t size;
char* out = base64_encode(str, strlen(str), &size);
assert_string_equal(out, dst);
free(out);
}
static void test_decoder(void** state) {
test_dec("dGVzdA==", "test");
test_dec("bG9uZyBsb25nIGxvbmcgdGV4dCB0ZXN0", "long long long text test");
test_dec("0YDRg9GB0YHQutC40Lkg0YLQtdC60YHRgg==", "русский текст");
test_dec("bG9uZyBsb25nIGxvbmcgdGV4dCB0ZXN0", "long long long text test");
}
static void test_encoder(void** state) {
test_enc("русский текст", "0YDRg9GB0YHQutC40Lkg0YLQtdC60YHRgg==");
test_enc("test", "dGVzdA==");
test_enc("long long long text test", "bG9uZyBsb25nIGxvbmcgdGV4dCB0ZXN0");
}
int main(void) {
const struct CMUnitTest tests[] = {
cmocka_unit_test(test_decoder),
cmocka_unit_test(test_encoder),
};
return cmocka_run_group_tests(tests, NULL, NULL);
}
|
resetius/graphtoys
|
vulkan/loader.c
|
#define VK_NO_PROTOTYPES
#include <vulkan/vulkan.h>
#define GLFW_INCLUDE_NONE
#include <GLFW/glfw3.h>
#include <assert.h>
#define DECL_FUNC(name) \
PFN_##name name; \
PFN_##name ktx_##name;
#define L0_FUNC(name) DECL_FUNC(name)
#define L1_FUNC(name) DECL_FUNC(name)
#define L2_FUNC(name) DECL_FUNC(name)
#include "symbols.h"
#undef DECL_FUNC
#undef L0_FUNC
#undef L1_FUNC
#undef L2_FUNC
void vk_load_global() {
#define L0_FUNC(name) \
ktx_##name = name = (PFN_##name)glfwGetInstanceProcAddress(NULL, #name); \
assert(name);
#include "symbols.h"
#undef L0_FUNC
}
void vk_load_instance(VkInstance instance) {
#define L1_FUNC(name) \
ktx_##name = name = (PFN_##name)glfwGetInstanceProcAddress(instance, #name); \
assert(name);
#include "symbols.h"
#undef L1_FUNC
}
void vk_load_device(VkDevice device) {
#define L2_FUNC(name) \
ktx_##name = name = (PFN_##name)vkGetDeviceProcAddr(device, #name); \
assert(name)
#include "symbols.h"
#undef L2_FUNC
}
#include <ktxvulkan.h>
void* ktxVulkanModuleHandle = (void*)1; // hack
ktx_error_code_e ktxLoadVulkanLibrary(void) { return 0; }
|
resetius/graphtoys
|
lib/object.c
|
#include <stdlib.h>
#include "object.h"
void ovec_free(struct ObjectVec* v) {
int i;
for (i = 0; i < v->size; i++) {
v->objs[i]->free(v->objs[i]);
}
free(v->objs);
}
void ovec_add(struct ObjectVec* v, struct Object* o) {
if (v->cap <= v->size) {
v->cap = (1+v->cap)*2;
v->objs = realloc(v->objs, v->cap*sizeof(struct Object*));
}
v->objs[v->size++] = o;
}
struct Object* ovec_get(struct ObjectVec* v, int index) {
return v->objs[index];
}
|
resetius/graphtoys
|
models/mandelbulb.c
|
#include <stdlib.h>
#include <stdio.h>
#include "mandelbulb.h"
#include <models/mandelbulb.vert.h>
#include <models/mandelbulb.frag.h>
#include <models/mandelbulb.vert.spv.h>
#include <models/mandelbulb.frag.spv.h>
#include <lib/object.h>
#include <lib/linmath.h>
#include <render/pipeline.h>
struct UniformBlock {
mat4x4 mvp;
mat4x4 rot;
mat4x4 inv_rot;
vec4 T;
int next;
};
struct Mandelbulb {
struct Object base;
vec3 T;
struct BufferManager* b;
int uniform_id;
int cur_type;
int n_types;
struct UniformBlock uniform;
struct Pipeline* pl;
int model;
};
static void t_left(struct Object* obj, int mods) {
struct Mandelbulb* t = (struct Mandelbulb*)obj;
t->T[0] += t->T[2]*0.01;
}
static void t_right(struct Object* obj, int mods) {
struct Mandelbulb* t = (struct Mandelbulb*)obj;
t->T[0] -= t->T[2]*0.01;
}
static void t_up(struct Object* obj, int mods) {
struct Mandelbulb* t = (struct Mandelbulb*)obj;
t->T[1] += t->T[2]*0.01;
}
static void t_down(struct Object* obj, int mods) {
struct Mandelbulb* t = (struct Mandelbulb*)obj;
t->T[1] -= t->T[2]*0.01;
}
static void t_zoom_in(struct Object* obj, int mods) {
struct Mandelbulb* t = (struct Mandelbulb*)obj;
t->T[2] /= 1.01;
}
static void t_zoom_out(struct Object* obj, int mods) {
struct Mandelbulb* t = (struct Mandelbulb*)obj;
t->T[2] *= 1.01;
}
static void t_mode(struct Object* obj) {
struct Mandelbulb* t = (struct Mandelbulb*)obj;
t->cur_type = (t->cur_type + 1) % t->n_types;
}
static void t_draw(struct Object* obj, struct DrawContext* ctx) {
struct Mandelbulb* t = (struct Mandelbulb*)obj;
//vec3 T = {0.0f, 0.0f, 2.0f};
mat4x4 m, v, mv, p, mvp;
mat4x4_identity(m);
//mat4x4_rotate_X(m, m, (float)glfwGetTime());
//mat4x4_rotate_Y(m, m, (float)glfwGetTime());
//mat4x4_rotate_Z(m, m, (float)glfwGetTime());
//mat4x4_rotate_Z(m, m, (float)glfwGetTime());
//mat4x4_ortho(p, -ctx->ratio, ctx->ratio, -1.f, 1.f, 1.f, -1.f);
//mat4x4_mul(mvp, p, m);
vec3 eye = {.0f, .0f, -1.f};
vec3 center = {.0f, .0f, .0f};
vec3 up = {.0f, 1.f, .0f};
mat4x4_look_at(v, eye, center, up);
mat4x4_mul(mv, v, m);
mat4x4_perspective(p, 70./2./M_PI, ctx->ratio, 0.3f, 100.f);
mat4x4_mul(mvp, p, mv);
mat4x4 rot;
mat4x4_identity(rot);
mat4x4_rotate_X(rot, rot, 0.5*ctx->time);
mat4x4_rotate_Y(rot, rot, 0.5*ctx->time);
mat4x4_rotate_Z(rot, rot, 0.5*ctx->time);
//mat3x3 norm;
//mat3x3_from_mat4x4(norm, rot);
memcpy(t->uniform.mvp, mvp, sizeof(mvp));
memcpy(t->uniform.rot, rot, sizeof(rot));
mat4x4_invert(t->uniform.inv_rot, rot);
memcpy(t->uniform.T, t->T, sizeof(t->T));
memcpy(&t->uniform.next, &t->cur_type, 4);
t->pl->start(t->pl);
buffer_update(t->b, t->uniform_id, &t->uniform, 0, sizeof(t->uniform));
t->pl->draw(t->pl, t->model);
}
static void t_free(struct Object* obj) {
struct Mandelbulb* t = (struct Mandelbulb*)obj;
t->pl->free(t->pl);
t->b->free(t->b);
free(t);
}
struct Vertex {
vec3 pos;
};
struct Object* CreateMandelbulb(struct Render* r, struct Config* cfg) {
struct Mandelbulb* t = calloc(1, sizeof(struct Mandelbulb));
struct Vertex vertices[] = {
{{ 1.0f,-1.0f,0.0f}},
{{-1.0f,-1.0f,0.0f}},
{{-1.0f, 1.0f,0.0f}},
{{ 1.0f, 1.0f,0.0f}},
{{ 1.0f,-1.0f,0.0f}},
{{-1.0f, 1.0f,0.0f}}
};
int n_vertices = 6;
struct Object base = {
.draw = t_draw,
.free = t_free,
.move_left = t_left,
.move_right = t_right,
.move_up = t_up,
.move_down = t_down,
.zoom_in = t_zoom_in,
.zoom_out = t_zoom_out,
.mode = t_mode
};
struct ShaderCode vertex_shader = {
.glsl =models_mandelbulb_vert,
.spir_v =models_mandelbulb_vert_spv,
.size = models_mandelbulb_vert_spv_size,
};
struct ShaderCode fragment_shader = {
.glsl = models_mandelbulb_frag,
.spir_v = models_mandelbulb_frag_spv,
.size = models_mandelbulb_frag_spv_size,
};
t->b = r->buffer_manager(r);
t->base = base;
t->T[0] = t->T[1] = 0.0; t->T[2] = 2.0;
struct PipelineBuilder* p = r->pipeline(r);
t->pl = p
->set_bmgr(p, t->b)
->begin_program(p)
->add_vs(p, vertex_shader)
->add_fs(p, fragment_shader)
->end_program(p)
->uniform_add(p, 0, "MatrixBlock")
->begin_buffer(p, sizeof(struct Vertex))
->buffer_attribute(p, 1, 3, DATA_FLOAT, offsetof(struct Vertex, pos))
->end_buffer(p)
->build(p);
t->uniform_id = buffer_create(t->b, BUFFER_UNIFORM, MEMORY_DYNAMIC, NULL, sizeof(struct UniformBlock));
pl_uniform_assign(t->pl, 0, t->uniform_id);
int model_buffer_id = buffer_create(t->b, BUFFER_ARRAY, MEMORY_STATIC, vertices, n_vertices*sizeof(struct Vertex));
t->model = pl_buffer_assign(t->pl, 0, model_buffer_id);
t->n_types = 4;
t->cur_type = 0;
return (struct Object*)t;
}
|
resetius/graphtoys
|
render/render.c
|
<filename>render/render.c<gh_stars>0
#include "render.h"
struct Texture* rend_tex_new(struct Render* r, void* data, enum TexType tex_type) {
return r->tex_new(r, data, tex_type);
}
struct Char* rend_char_new(struct Render* r, wchar_t ch, void* face) {
return r->char_new(r, ch, face);
}
void rend_free(struct Render* r) {
if (r) {
r->free(r);
}
}
|
resetius/graphtoys
|
opengl/pipeline.c
|
<reponame>resetius/graphtoys
#include <stdlib.h>
#include <stdio.h>
#include <assert.h>
#include <render/pipeline.h>
#include <opengl/program.h>
#include <opengl/buffer.h>
#include <lib/verify.h>
struct UniformBlock {
struct BufferImpl base;
int id;
const char* name;
GLuint binding;
GLuint index;
};
struct Buffer {
struct BufferImpl base;
int id;
int n_vertices; // pipeline
GLuint vao; // pipeline
int stride; // pipeline
int binding; // pipeline
int descriptor; // pipeline
};
struct BufferAttribute {
int location;
int channels;
enum DataType data_type;
int stride;
uint64_t offset;
};
struct BufferDescriptor {
int stride;
int dynamic;
struct BufferAttribute attrs[10];
int n_attrs;
};
struct Sampler {
GLuint id;
int binding;
};
struct PipelineImpl {
struct Pipeline base;
struct Render* r;
struct Program** programs;
int n_programs;
struct UniformBlock* uniforms;
int n_uniforms;
struct Buffer* buffers;
int n_buffers;
int buf_cap;
struct BufferDescriptor* buf_descr;
int n_buf_descrs;
struct Sampler* samplers;
int n_samplers;
int enable_depth;
int enable_blend;
enum GeometryType geometry;
struct BufferManager* b; // TODO: remove me
int enable_cull;
GLenum cull_mode;
};
struct PipelineBuilderImpl {
struct PipelineBuilder base;
struct Render* r;
struct Program* programs[100];
struct Program* cur_program;
int n_programs;
struct UniformBlock uniforms[100];
struct UniformBlock* cur_uniform;
int n_uniforms;
//struct Buffer buffers[100];
//struct Buffer* cur_buffer;
struct BufferDescriptor buffers[100];
struct BufferDescriptor* cur_buffer;
int n_buffers;
struct Sampler samplers[100];
struct Sampler* cur_sampler;
int n_samplers;
int enable_depth;
int enable_blend;
enum GeometryType geometry;
struct BufferManager* b; // TODO: remove me
int enable_cull;
GLenum cull_mode;
};
static int is_integer(enum DataType data_type) {
int result = 0;
switch (data_type) {
case DATA_FLOAT:
result = 0;
break;
case DATA_INT:
result = 1;
break;
default:
assert(0);
break;
}
return result;
}
static GLint gl_data_type(enum DataType data_type) {
GLint result = -1;
switch (data_type) {
case DATA_FLOAT:
result = GL_FLOAT;
break;
case DATA_INT:
result = GL_INT;
break;
default:
assert(0);
break;
}
return result;
}
static struct PipelineBuilder* uniform_add(
struct PipelineBuilder*p1,
int binding,
const char* name)
{
struct PipelineBuilderImpl* p = (struct PipelineBuilderImpl*)p1;
assert(p->n_programs > 0);
int program = prog_handle(p->programs[p->n_programs-1]);
GLuint index = glGetUniformBlockIndex(program, name);
glUniformBlockBinding(program, index, binding);
struct UniformBlock block = {
.id = -1,
.name = name,
.binding = binding,
.index = index,
};
p->uniforms[p->n_uniforms++] = block;
return p1;
}
static struct PipelineBuilder* storage_add(
struct PipelineBuilder*p1,
int binding,
const char* name)
{
struct PipelineBuilderImpl* p = (struct PipelineBuilderImpl*)p1;
struct UniformBlock block = {
.id = -1,
.name = name,
.binding = binding,
};
p->uniforms[p->n_uniforms++] = block;
return p1;
}
static struct PipelineBuilder* begin_program(struct PipelineBuilder* p1) {
struct PipelineBuilderImpl* p = (struct PipelineBuilderImpl*)p1;
p->cur_program = p->programs[p->n_programs++] = prog_opengl_new(p->r);
return p1;
}
static struct PipelineBuilder* add_vs(struct PipelineBuilder*p1, struct ShaderCode shader) {
struct PipelineBuilderImpl* p = (struct PipelineBuilderImpl*)p1;
assert(p->cur_program);
prog_add_vs(p->cur_program, shader.glsl);
return p1;
}
static struct PipelineBuilder* add_fs(struct PipelineBuilder*p1, struct ShaderCode shader) {
struct PipelineBuilderImpl* p = (struct PipelineBuilderImpl*)p1;
assert(p->cur_program);
prog_add_fs(p->cur_program, shader.glsl);
return p1;
}
static struct PipelineBuilder* add_cs(struct PipelineBuilder*p1, struct ShaderCode shader) {
struct PipelineBuilderImpl* p = (struct PipelineBuilderImpl*)p1;
assert(p->cur_program);
prog_add_cs(p->cur_program, shader.glsl);
return p1;
}
static struct PipelineBuilder* end_program(struct PipelineBuilder*p1) {
struct PipelineBuilderImpl* p = (struct PipelineBuilderImpl*)p1;
assert(p->cur_program);
prog_link(p->cur_program);
p->cur_program = NULL;
return p1;
}
static struct PipelineBuilder* begin_buffer(struct PipelineBuilder* p1, int stride) {
struct PipelineBuilderImpl* p = (struct PipelineBuilderImpl*)p1;
// TODO: check current
p->cur_buffer = &p->buffers[p->n_buffers++];
p->cur_buffer->stride = stride;
return p1;
}
static struct PipelineBuilder* buffer_attribute(
struct PipelineBuilder* p1,
int location,
int channels,
enum DataType data_type,
uint64_t offset)
{
struct PipelineBuilderImpl* p = (struct PipelineBuilderImpl*)p1;
struct BufferAttribute* attr = &p->cur_buffer->attrs[p->cur_buffer->n_attrs++];
attr->location = location;
attr->channels = channels;
attr->data_type = data_type;
attr->stride = p->cur_buffer->stride;
attr->offset = offset;
return p1;
}
static struct PipelineBuilder* end_buffer(struct PipelineBuilder* p1) {
struct PipelineBuilderImpl* p = (struct PipelineBuilderImpl*)p1;
p->cur_buffer = NULL;
return p1;
}
static void pipeline_free(struct Pipeline* p1) {
struct PipelineImpl* p = (struct PipelineImpl*)p1;
int i;
if (!p) {
return;
}
for (i = 0; i < p->n_programs; i++) {
prog_free(p->programs[i]);
}
free(p->programs);
for (i = 0; i < p->n_buffers; i++) {
if (p->buffers[i].vao) {
glDeleteVertexArrays(1, &p->buffers[i].vao);
}
}
free(p->buffers);
for (i = 0; i < p->n_uniforms; i++) {
// TODO: remove me
p->b->destroy(p->b, p->uniforms[i].id);
}
free(p->uniforms);
for (i = 0; i < p->n_samplers; i++) {
glDeleteSamplers(1, &p->samplers[i].id);
}
free(p->samplers);
free(p->buf_descr);
free(p);
}
static int buffer_assign(struct Pipeline* p1, int id, int buffer_id) {
struct PipelineImpl* p = (struct PipelineImpl*)p1;
assert(id < p->n_buf_descrs);
struct BufferDescriptor* descr = &p->buf_descr[id];
if (p->n_buffers >= p->buf_cap) {
p->buf_cap = (p->buf_cap+1)*2;
p->buffers = realloc(p->buffers, p->buf_cap*sizeof(struct Buffer));
}
int logical_id = p->n_buffers++; // logical id
struct Buffer* buf = &p->buffers[logical_id];
memset(buf, 0, sizeof(*buf));
buf->id = buffer_id;
memcpy(&buf->base, p->b->get(p->b, buf->id), sizeof(buf->base));
buf->stride = descr->stride;
buf->n_vertices = buf->base.size / descr->stride;
buf->descriptor = id;
glBindBuffer(GL_ARRAY_BUFFER, buf->base.buffer);
glGenVertexArrays(1, &buf->vao);
glBindVertexArray(buf->vao);
for (int j = 0; j < descr->n_attrs; j++) {
int location = descr->attrs[j].location;
glEnableVertexAttribArray(location);
if (is_integer(descr->attrs[j].data_type)) {
glVertexAttribIPointer(
location,
descr->attrs[j].channels,
gl_data_type(descr->attrs[j].data_type),
descr->stride,
(const void*)descr->attrs[j].offset);
} else {
glVertexAttribPointer(
location,
descr->attrs[j].channels,
gl_data_type(descr->attrs[j].data_type),
GL_FALSE,
descr->stride,
(const void*)descr->attrs[j].offset);
}
}
glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindVertexArray(0);
return logical_id;
}
static void uniform_assign(struct Pipeline* p1, int uniform_id, int buffer_id)
{
struct PipelineImpl* p = (struct PipelineImpl*)p1;
assert(uniform_id < p->n_uniforms);
p->uniforms[uniform_id].id = buffer_id;
memcpy(&p->uniforms[uniform_id].base,
p->b->get(p->b, buffer_id),
sizeof(p->uniforms[uniform_id].base));
}
static void storage_swap(struct Pipeline* p1, int dst, int src) {
struct PipelineImpl* p = (struct PipelineImpl*)p1;
assert(dst < p->n_uniforms);
assert(src < p->n_uniforms);
struct UniformBlock* src_buf = &p->uniforms[src];
struct UniformBlock* dst_buf = &p->uniforms[dst];
int t = src_buf->binding;
src_buf->binding = dst_buf->binding;
dst_buf->binding = t;
}
static void before(struct PipelineImpl* p) {
if (p->enable_blend) {
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
}
if (p->enable_depth) {
glEnable(GL_DEPTH_TEST);
}
if (p->geometry == GEOM_POINTS) {
glEnable(GL_PROGRAM_POINT_SIZE);
}
if (p->enable_cull) {
glEnable(GL_CULL_FACE);
glCullFace(p->cull_mode);
}
}
static void after(struct PipelineImpl* p) {
if (p->enable_blend) {
glDisable(GL_BLEND);
}
if (p->enable_depth) {
glDisable(GL_DEPTH_TEST);
}
if (p->geometry == GEOM_POINTS) {
glDisable(GL_PROGRAM_POINT_SIZE);
}
if (p->enable_cull) {
glDisable(GL_CULL_FACE);
}
}
static void start(struct Pipeline* p1) {
struct PipelineImpl* p = (struct PipelineImpl*)p1;
int i;
for (i = 0; i < p->n_programs; i++) {
prog_use(p->programs[i]);
}
for (i = 0; i < p->n_samplers; i++) {
glBindSampler(p->samplers[i].binding, p->samplers[i].id);
}
for (i = 0; i < p->n_uniforms; i++) {
glBindBufferBase(
p->uniforms[i].base.type,
p->uniforms[i].binding,
p->uniforms[i].base.buffer);
}
}
static void start_compute(struct Pipeline* p1, int sx, int sy, int sz) {
struct PipelineImpl* p = (struct PipelineImpl*)p1;
int i;
prog_use(p->programs[0]);
assert(p->n_uniforms > 0);
for (i = 0; i < p->n_uniforms; i++) {
glBindBufferBase(
p->uniforms[i].base.type,
p->uniforms[i].binding,
p->uniforms[i].base.buffer);
}
glDispatchCompute(sx, sy, sz);
glMemoryBarrier(GL_SHADER_STORAGE_BARRIER_BIT); // TODO
}
static void use_texture(struct Pipeline* p1, void* tex) {
//struct PipelineImpl* p = (struct PipelineImpl*)p1;
int tex_id = *(int*)tex;
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, tex_id);
}
static void draw(struct Pipeline* p1, int id) {
struct PipelineImpl* p = (struct PipelineImpl*)p1;
before(p);
glBindVertexArray(p->buffers[id].vao);
if (p->geometry == GEOM_POINTS) {
glDrawArrays(GL_POINTS, 0, p->buffers[id].n_vertices);
} else {
glDrawArrays(GL_TRIANGLES, 0, p->buffers[id].n_vertices);
}
glBindVertexArray(0);
after(p);
}
static void draw_indexed(struct Pipeline* p1, int id, int index, int index_byte_size) {
struct PipelineImpl* p = (struct PipelineImpl*)p1;
before(p);
if (index_byte_size < 2) {
// TODO
return;
}
glBindVertexArray(p->buffers[id].vao);
struct BufferImpl* ibuf = p->b->get(p->b, index);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibuf->buffer);
assert(index_byte_size == 2 || index_byte_size == 4 || index_byte_size == 1);
int n_vertices = ibuf->size / index_byte_size;
//printf("Draw: %d\n", n_vertices);
GLenum type;
if (index_byte_size == 2) {
type = GL_UNSIGNED_SHORT;
} else if (index_byte_size == 4) {
type = GL_UNSIGNED_INT;
} else {
type = GL_UNSIGNED_BYTE;
}
if (p->geometry == GEOM_POINTS) {
glDrawElements(GL_POINTS, n_vertices, type, NULL);
} else {
glDrawElements(GL_TRIANGLES, n_vertices, type, NULL);
}
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
glBindVertexArray(0);
after(p);
}
static struct PipelineBuilder* enable_depth(struct PipelineBuilder* p1) {
struct PipelineBuilderImpl* p = (struct PipelineBuilderImpl*)p1;
p->enable_depth = 1;
return p1;
}
static struct PipelineBuilder* enable_blend(struct PipelineBuilder* p1) {
struct PipelineBuilderImpl* p = (struct PipelineBuilderImpl*)p1;
p->enable_blend = 1;
return p1;
}
struct PipelineBuilder* enable_cull(struct PipelineBuilder* p1, enum CullType cull) {
struct PipelineBuilderImpl* p = (struct PipelineBuilderImpl*)p1;
switch (cull) {
case CULL_FRONT:
p->enable_cull = 1;
p->cull_mode = GL_FRONT;
break;
case CULL_BACK:
p->enable_cull = 1;
p->cull_mode = GL_BACK;
break;
case CULL_BOTH:
p->enable_cull = 1;
p->cull_mode = GL_FRONT_AND_BACK;
break;
default:
assert(0);
}
return p1;
}
static struct PipelineBuilder* geometry(struct PipelineBuilder* p1, enum GeometryType type) {
struct PipelineBuilderImpl* p = (struct PipelineBuilderImpl*)p1;
p->geometry = type;
return p1;
}
static struct PipelineBuilder* begin_sampler(struct PipelineBuilder* p1, int binding) {
struct PipelineBuilderImpl* p = (struct PipelineBuilderImpl*)p1;
p->cur_sampler = &p->samplers[p->n_samplers++];
p->cur_sampler->binding = binding;
glGenSamplers(1, &p->cur_sampler->id);
glSamplerParameteri(p->cur_sampler->id, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glSamplerParameteri(p->cur_sampler->id, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glSamplerParameteri(p->cur_sampler->id, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
glSamplerParameteri(p->cur_sampler->id, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
vec4 border = {0.0f,0.0f,0.0f,0.5f};
glSamplerParameterfv(p->cur_sampler->id, GL_TEXTURE_BORDER_COLOR, border);
return p1;
}
static int gl_filter(enum FilterType filter_type) {
switch (filter_type) {
case FILTER_NEAREST: return GL_NEAREST;
case FILTER_LINEAR: return GL_LINEAR;
case FILTER_NEAREST_MIPMAP_NEAREST: return GL_NEAREST_MIPMAP_NEAREST;
case FILTER_LINEAR_MIPMAP_NEAREST: return GL_LINEAR_MIPMAP_NEAREST;
case FILTER_NEAREST_MIPMAP_LINEAR: return GL_NEAREST_MIPMAP_LINEAR;
case FILTER_LINEAR_MIPMAP_LINEAR: return GL_LINEAR_MIPMAP_LINEAR;
default: verify(0);
}
return -1;
}
static int gl_wrap(enum WrapType wrap_type) {
switch (wrap_type) {
case WRAP_REPEAT: return GL_REPEAT;
case WRAP_MIRRORED_REPEAT: return GL_MIRRORED_REPEAT;
case WRAP_CLAMP_TO_EDGE: return GL_CLAMP_TO_EDGE;
case WRAP_CLAMP_TO_BORDER: return GL_CLAMP_TO_BORDER;
default: verify(0); break;
}
return -1;
}
static struct PipelineBuilder* sampler_mag_filter(struct PipelineBuilder* p1, enum FilterType filter_type) {
struct PipelineBuilderImpl* p = (struct PipelineBuilderImpl*)p1;
glSamplerParameteri(p->cur_sampler->id, GL_TEXTURE_MAG_FILTER, gl_filter(filter_type));
return p1;
}
static struct PipelineBuilder* sampler_min_filter(struct PipelineBuilder* p1, enum FilterType filter_type) {
struct PipelineBuilderImpl* p = (struct PipelineBuilderImpl*)p1;
glSamplerParameteri(p->cur_sampler->id, GL_TEXTURE_MIN_FILTER, gl_filter(filter_type));
return p1;
}
static struct PipelineBuilder* sampler_wrap_s(struct PipelineBuilder* p1, enum WrapType wrap_type) {
struct PipelineBuilderImpl* p = (struct PipelineBuilderImpl*)p1;
glSamplerParameteri(p->cur_sampler->id, GL_TEXTURE_WRAP_S, gl_wrap(wrap_type));
return p1;
}
static struct PipelineBuilder* sampler_wrap_t(struct PipelineBuilder* p1, enum WrapType wrap_type) {
struct PipelineBuilderImpl* p = (struct PipelineBuilderImpl*)p1;
glSamplerParameteri(p->cur_sampler->id, GL_TEXTURE_WRAP_T, gl_wrap(wrap_type));
return p1;
}
static struct PipelineBuilder* end_sampler(struct PipelineBuilder* p1) {
struct PipelineBuilderImpl* p = (struct PipelineBuilderImpl*)p1;
p->cur_sampler = NULL;
return p1;
}
static struct PipelineBuilder* set_bmgr(struct PipelineBuilder* p1, struct BufferManager* b)
{
struct PipelineBuilderImpl* p = (struct PipelineBuilderImpl*)p1;
p->b = b;
return p1;
}
static struct Pipeline* build(struct PipelineBuilder* p1) {
struct PipelineBuilderImpl* p = (struct PipelineBuilderImpl*)p1;
struct PipelineImpl* pl = calloc(1, sizeof(*pl));
struct Pipeline base = {
.free = pipeline_free,
.storage_assign = uniform_assign,
.uniform_assign = uniform_assign,
.buffer_assign = buffer_assign,
.storage_swap = storage_swap,
.start = start,
.start_compute = start_compute,
.draw = draw,
.draw_indexed = draw_indexed,
.use_texture = use_texture
};
pl->base = base;
pl->n_programs = p->n_programs;
pl->programs = malloc(pl->n_programs*sizeof(struct Program*));
memcpy(pl->programs, p->programs, pl->n_programs*sizeof(struct Program*));
pl->n_uniforms = p->n_uniforms;
pl->uniforms = malloc(pl->n_uniforms*sizeof(struct UniformBlock));
memcpy(pl->uniforms, p->uniforms, pl->n_uniforms*sizeof(struct UniformBlock));
pl->n_buf_descrs = p->n_buffers;
pl->buf_descr = malloc(pl->n_buf_descrs*sizeof(struct BufferDescriptor));
memcpy(pl->buf_descr, p->buffers, pl->n_buf_descrs*sizeof(struct BufferDescriptor));
pl->n_samplers = p->n_samplers;
pl->samplers = malloc(pl->n_samplers*sizeof(struct Sampler));
memcpy(pl->samplers, p->samplers, pl->n_samplers*sizeof(struct Sampler));
pl->enable_depth = p->enable_depth;
pl->enable_blend = p->enable_blend;
pl->geometry = p->geometry;
pl->b = p->b;
pl->enable_cull = p->enable_cull;
pl->cull_mode = p->cull_mode;
free(p);
return (struct Pipeline*)pl;
}
struct PipelineBuilder* pipeline_builder_opengl(struct Render* r) {
struct PipelineBuilderImpl* p = calloc(1, sizeof(*p));
struct PipelineBuilder base = {
.set_bmgr = set_bmgr,
.begin_program = begin_program,
.add_vs = add_vs,
.add_fs = add_fs,
.add_cs = add_cs,
.end_program = end_program,
.storage_add = storage_add,
.uniform_add = uniform_add,
.begin_buffer = begin_buffer,
.buffer_attribute = buffer_attribute,
.end_buffer = end_buffer,
.begin_sampler = begin_sampler,
.sampler_mag_filter = sampler_mag_filter,
.sampler_min_filter = sampler_min_filter,
.sampler_wrap_s = sampler_wrap_s,
.sampler_wrap_t = sampler_wrap_t,
.end_sampler = end_sampler,
.enable_depth = enable_depth,
.enable_blend = enable_blend,
.enable_cull = enable_cull,
.geometry = geometry,
.build = build
};
p->base = base;
p->r = r;
return (struct PipelineBuilder*)p;
}
|
resetius/graphtoys
|
lib/formats/gltf.c
|
#include "gltf.h"
#include "base64.h"
#include <ktx.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <contrib/json/json.h>
#include <lib/verify.h>
#define BACK(vec, cap, count) \
count>=cap ? ( cap=(1+cap)*2, vec = realloc(vec, cap*sizeof(vec[0])), memset(&vec[count], 0, sizeof(vec[count])), &vec[count++] ) : ( memset(&vec[count], 0, sizeof(vec[count])), &vec[count++] )
static float get_float(json_value* value) {
if (value->type == json_integer) {
return value->u.integer;
} else {
return value->u.dbl;
}
}
static void load_vec(json_value* value, float* vec, int size) {
int i;
for (i = 0; i < size; i++) {
vec[i] = get_float(value->u.array.values[i]);
}
}
static void load_scene(struct GltfScene* scene, json_value* value) {
for (json_object_entry* entry = value->u.object.values;
entry != value->u.object.values+value->u.object.length; entry++)
{
if (!strcmp(entry->name, "name") && entry->value->type == json_string) {
strncpy(scene->name, entry->value->u.string.ptr, sizeof(scene->name)-1);
} else if (!strcmp(entry->name, "nodes") && entry->value->type == json_array) {
for (json_value** node = entry->value->u.array.values;
node != entry->value->u.array.values+entry->value->u.array.length; node++)
{
scene->nodes[scene->n_nodes++] = (*node)->u.integer;
}
} else {
printf("Unknown scene key: '%s'\n", entry->name);
}
}
}
static void load_scenes(struct Gltf* gltf, json_value* value) {
for (json_value** entry = value->u.array.values;
entry != value->u.array.values+value->u.array.length; entry++)
{
if ((*entry)->type == json_object) {
load_scene(BACK(gltf->scenes, gltf->cap_scenes, gltf->n_scenes), *entry);
} else {
printf("Bad scene type\n");
}
}
}
static void load_node(struct GltfNode* node, json_value* value) {
quat_identity(node->rotation);
node->scale[0] = node->scale[1] = node->scale[2] = 1.0;
mat4x4_identity(node->matrix);
node->camera = node->mesh = -1;
for (json_object_entry* entry = value->u.object.values;
entry != value->u.object.values+value->u.object.length; entry++)
{
if (!strcmp(entry->name, "mesh") && entry->value->type == json_integer) {
node->mesh = entry->value->u.integer;
} else if (!strcmp(entry->name, "name") && entry->value->type == json_string) {
strncpy(node->name, entry->value->u.string.ptr, sizeof(node->name)-1);
} else if (!strcmp(entry->name, "rotation") && entry->value->type == json_array && entry->value->u.array.length == 4) {
load_vec(entry->value, node->rotation, 4);
} else if (!strcmp(entry->name, "scale") && entry->value->type == json_array && entry->value->u.array.length == 3) {
load_vec(entry->value, node->scale, 3);
} else if (!strcmp(entry->name, "translation") && entry->value->type == json_array && entry->value->u.array.length == 3) {
load_vec(entry->value, node->translation, 3);
} else if (!strcmp(entry->name, "camera")) {
node->camera = entry->value->u.integer;
} else {
// TODO
printf("Unknown node key: '%s'\n", entry->name);
}
}
mat4x4_from_quat(node->matrix, node->rotation);
mat4x4_translate_in_place(node->matrix,
node->translation[0],
node->translation[1],
node->translation[2]);
mat4x4_scale_aniso(node->matrix, node->matrix,
node->scale[0], node->scale[1], node->scale[2]);
mat4x4 norm_matrix;
mat4x4_invert(norm_matrix, node->matrix);
mat4x4_transpose(node->norm_matrix, norm_matrix);
}
static void load_nodes(struct Gltf* gltf, json_value* value) {
for (json_value** entry = value->u.array.values;
entry != value->u.array.values+value->u.array.length; entry++)
{
if ((*entry)->type == json_object) {
load_node(BACK(gltf->nodes, gltf->cap_nodes, gltf->n_nodes), *entry);
} else {
printf("Bad nodes type\n");
}
}
}
static char* gltf_file_by_fullname(const char* name, int64_t* size) {
FILE* f;
char* output;
f = fopen(name, "rb");
if (!f) return NULL;
fseek(f, 0, SEEK_END);
*size = ftell(f);
fseek(f, 0, SEEK_SET);
output = malloc(*size);
verify(fread(output, 1, *size, f) == *size);
fclose(f);
return output;
}
static char* gltf_file_by_name(struct Gltf* gltf, const char* name, int64_t* size) {
int l = strlen(gltf->fsbase);
char* output;
strncat(gltf->fsbase, name, sizeof(gltf->fsbase)-l-1);
output = gltf_file_by_fullname(gltf->fsbase, size);
gltf->fsbase[l] = 0;
return output;
}
static char* load_uri(struct Gltf* gltf, json_value* value, int64_t* size) {
const char* base64_type = "data:application/octet-stream;base64,";
int base64_type_len = strlen(base64_type);
*size = 0;
if (!strncmp(value->u.string.ptr, base64_type, base64_type_len)) {
return base64_decode(
value->u.string.ptr+base64_type_len,
value->u.string.length-base64_type_len,
size);
} else {
char* output = gltf_file_by_name(gltf, value->u.string.ptr, size);
verify(output);
return output;
}
}
static void load_buffer(struct Gltf* gltf, struct GltfBuffer* buffer, json_value* value) {
for (json_object_entry* entry = value->u.object.values;
entry != value->u.object.values+value->u.object.length; entry++)
{
if (!strcmp(entry->name, "byteLength") && entry->value->type == json_integer) {
buffer->size = entry->value->u.integer;
} else if (!strcmp(entry->name, "uri") && entry->value->type == json_string) {
// later
} else {
printf("Unknown buffer key: '%s'\n", entry->name);
}
}
for (json_object_entry* entry = value->u.object.values;
entry != value->u.object.values+value->u.object.length; entry++)
{
if (!strcmp(entry->name, "uri") && entry->value->type == json_string) {
int64_t size;
buffer->data = load_uri(gltf, entry->value, &size);
verify(size == buffer->size);
}
}
}
static void load_buffers(struct Gltf* gltf, json_value* value) {
for (json_value** entry = value->u.array.values;
entry != value->u.array.values+value->u.array.length; entry++)
{
if ((*entry)->type == json_object) {
load_buffer(gltf, BACK(gltf->buffers, gltf->cap_buffers, gltf->n_buffers), *entry);
} else {
printf("Bad buffers type\n");
}
}
}
static void load_accessor(struct GltfAccessor* acc, json_value* value) {
for (json_object_entry* entry = value->u.object.values;
entry != value->u.object.values+value->u.object.length; entry++)
{
if (!strcmp(entry->name, "bufferView") && entry->value->type == json_integer) {
acc->view = entry->value->u.integer;
} else if (!strcmp(entry->name, "componentType") && entry->value->type == json_integer) {
acc->component_type = entry->value->u.integer;
} else if (!strcmp(entry->name, "byteOffset") && entry->value->type == json_integer) {
acc->offset = entry->value->u.integer;
} else if (!strcmp(entry->name, "count") && entry->value->type == json_integer) {
acc->count = entry->value->u.integer;
} else if (!strcmp(entry->name, "type") && entry->value->type == json_string) {
if (!strcmp(entry->value->u.string.ptr, "SCALAR")) {
acc->components = 1;
} else if (!strcmp(entry->value->u.string.ptr, "VEC2")) {
acc->components = 2;
} else if (!strcmp(entry->value->u.string.ptr, "VEC3")) {
acc->components = 3;
} else if (!strcmp(entry->value->u.string.ptr, "VEC4")) {
acc->components = 4;
} else {
printf("Unknown type: %s\n", entry->value->u.string.ptr);
}
} else if (!strcmp(entry->name, "name") && entry->value->type == json_string) {
strncpy(acc->name, entry->value->u.string.ptr, sizeof(acc->name)-1);
} else if (!strcmp(entry->name, "max") && entry->value->type == json_array && entry->value->u.array.length <= 4) {
load_vec(entry->value, acc->max, entry->value->u.array.length);
} else if (!strcmp(entry->name, "min") && entry->value->type == json_array && entry->value->u.array.length <= 4) {
load_vec(entry->value, acc->min, entry->value->u.array.length);
} else {
printf("Unknown accessor key: '%s'\n", entry->name);
}
}
}
static void load_accessors(struct Gltf* gltf, json_value* value) {
for (json_value** entry = value->u.array.values;
entry != value->u.array.values+value->u.array.length; entry++)
{
if ((*entry)->type == json_object) {
load_accessor(BACK(gltf->accessors, gltf->cap_accessors, gltf->n_accessors), *entry);
} else {
printf("Unknown accessor type\n");
}
}
}
static void load_view(struct GltfView* buf, json_value* value) {
for (json_object_entry* entry = value->u.object.values;
entry != value->u.object.values+value->u.object.length; entry++)
{
if (!strcmp(entry->name, "buffer") && entry->value->type == json_integer) {
buf->buffer = entry->value->u.integer;
} else if (!strcmp(entry->name, "byteLength") && entry->value->type == json_integer) {
buf->size = entry->value->u.integer;
} else if (!strcmp(entry->name, "byteOffset") && entry->value->type == json_integer) {
buf->data = (char*)entry->value->u.integer;
} else if (!strcmp(entry->name, "byteStride") && entry->value->type == json_integer) {
buf->stride = entry->value->u.integer;
} else if (!strcmp(entry->name, "name") && entry->value->type == json_string) {
strncpy(buf->name, entry->value->u.string.ptr, sizeof(buf->data)-1);
} else {
printf("Unknown view key: '%s'\n", entry->name);
}
}
}
static void load_views(struct Gltf* gltf, json_value* value) {
for (json_value** entry = value->u.array.values;
entry != value->u.array.values+value->u.array.length; entry++)
{
if ((*entry)->type == json_object) {
load_view(BACK(gltf->views, gltf->cap_views, gltf->n_views), *entry);
} else {
printf("Unknown views type\n");
}
}
}
static void load_attributes(struct GltfPrimitive* primitive, json_value* value) {
for (json_object_entry* entry = value->u.object.values;
entry != value->u.object.values+value->u.object.length; entry++)
{
if (!strcmp(entry->name, "NORMAL") && entry->value->type == json_integer) {
primitive->normal = entry->value->u.integer;
} else if (!strcmp(entry->name, "POSITION") && entry->value->type == json_integer) {
primitive->position = entry->value->u.integer;
} else if (!strcmp(entry->name, "TEXCOORD_0") && entry->value->type == json_integer) {
primitive->texcoord[0] = entry->value->u.integer;
} else if (!strcmp(entry->name, "TANGENT") && entry->value->type == json_integer) {
primitive->tangent = entry->value->u.integer;
} else {
printf("Unsupported attribute: '%s'\n", entry->name);
}
}
}
static void load_primitive(struct GltfPrimitive* primitive, json_value* value) {
primitive->material = primitive->normal = primitive->position = primitive->tangent = -1;
for (int i = 0; i < sizeof(primitive->texcoord)/sizeof(int); i++) {
primitive->texcoord[i] = -1;
}
for (json_object_entry* entry = value->u.object.values;
entry != value->u.object.values+value->u.object.length; entry++)
{
if (!strcmp(entry->name, "indices") && entry->value->type == json_integer) {
primitive->indices = entry->value->u.integer;
} else if (!strcmp(entry->name, "material") && entry->value->type == json_integer) {
primitive->material = entry->value->u.integer;
} else if (!strcmp(entry->name, "attributes") && entry->value->type == json_object) {
load_attributes(primitive, entry->value);
} else {
printf("Unsupported primitive key: '%s'\n", entry->name);
}
}
}
static void load_primitives(struct GltfMesh* mesh, json_value* value) {
for (json_value** entry = value->u.array.values;
entry != value->u.array.values+value->u.array.length; entry++)
{
if ((*entry)->type == json_object) {
load_primitive(BACK(mesh->primitives, mesh->cap_primitives, mesh->n_primitives), *entry);
} else {
printf("Unknown primitives type\n");
}
}
}
static void load_mesh(struct GltfMesh* mesh, json_value* value) {
for (json_object_entry* entry = value->u.object.values;
entry != value->u.object.values+value->u.object.length; entry++)
{
if (!strcmp(entry->name, "name") && entry->value->type == json_string) {
strncpy(mesh->name, entry->value->u.string.ptr, sizeof(mesh->name)-1);
} else if (!strcmp(entry->name, "primitives") && entry->value->type == json_array) {
load_primitives(mesh, entry->value);
} else {
printf("Unsupported mesh key: '%s'\n", entry->name);
}
}
}
static void load_meshes(struct Gltf* gltf, json_value* value) {
for (json_value** entry = value->u.array.values;
entry != value->u.array.values+value->u.array.length; entry++)
{
if ((*entry)->type == json_object) {
load_mesh(BACK(gltf->meshes, gltf->cap_meshes, gltf->n_meshes), *entry);
} else {
printf("Unknown meshes type\n");
}
}
}
static void load_perspective(struct GltfCameraPerspective* cam, json_value* value) {
for (json_object_entry* entry = value->u.object.values;
entry != value->u.object.values+value->u.object.length; entry++)
{
if (!strcmp(entry->name, "aspectRatio")) {
cam->aspect = get_float(entry->value);
} else if (!strcmp(entry->name, "yfov")) {
cam->yfov = get_float(entry->value);
} else if (!strcmp(entry->name, "zfar")) {
cam->zfar = get_float(entry->value);
} else if (!strcmp(entry->name, "znear")) {
cam->znear = get_float(entry->value);
}
}
}
static void load_orthographic(struct GltfCameraOrthographic* cam, json_value* value) {
for (json_object_entry* entry = value->u.object.values;
entry != value->u.object.values+value->u.object.length; entry++)
{
if (!strcmp(entry->name, "xmag")) {
cam->xmag = get_float(entry->value);
} else if (!strcmp(entry->name, "ymag")) {
cam->ymag = get_float(entry->value);
} else if (!strcmp(entry->name, "zfar")) {
cam->zfar = get_float(entry->value);
} else if (!strcmp(entry->name, "znear")) {
cam->znear = get_float(entry->value);
}
}
}
static void load_camera(struct GltfCamera* camera, json_value* value) {
for (json_object_entry* entry = value->u.object.values;
entry != value->u.object.values+value->u.object.length; entry++)
{
if (!strcmp(entry->name, "name") && entry->value->type == json_string) {
strncpy(camera->name, entry->value->u.string.ptr, sizeof(camera->name)-1);
} else if (!strcmp(entry->name, "type") && entry->value->type == json_string) {
if (!strcmp(entry->value->u.string.ptr, "perspective")) {
camera->is_perspective = 1;
}
} else if (!strcmp(entry->name, "perspective") && entry->value->type == json_object) {
load_perspective(&camera->perspective, entry->value);
} else if (!strcmp(entry->name, "orthographic") && entry->value->type == json_object) {
load_orthographic(&camera->orthographic, entry->value);
}
}
}
static void load_cameras(struct Gltf* gltf, json_value* value) {
for (json_value** entry = value->u.array.values;
entry != value->u.array.values+value->u.array.length; entry++)
{
if ((*entry)->type == json_object) {
load_camera(BACK(gltf->cameras, gltf->cap_cameras, gltf->n_cameras), *entry);
} else {
printf("Unknown camera type\n");
}
}
}
void* gltf_load_image_uri(const char* fname) {
char* data;
int64_t size;
ktxTexture* tex = NULL;
data = gltf_file_by_fullname(fname, &size);
if (!data) return tex;
verify(ktxTexture_CreateFromMemory(
(const ktx_uint8_t *)data,
size, // TODO: optimization
KTX_TEXTURE_CREATE_LOAD_IMAGE_DATA_BIT,
&tex) == KTX_SUCCESS);
free(data);
return tex;
}
static void* load_image_uri(struct Gltf* gltf, json_value* value) {
char* data;
int64_t size;
ktxTexture* tex = NULL;
data = load_uri(gltf, value, &size);
verify(ktxTexture_CreateFromMemory(
(const ktx_uint8_t *)data,
size, // TODO: optimization
KTX_TEXTURE_CREATE_LOAD_IMAGE_DATA_BIT,
&tex) == KTX_SUCCESS);
free(data);
return tex;
}
static void load_image(struct Gltf* gltf, struct GltfImage* image, json_value* value) {
for (json_object_entry* entry = value->u.object.values;
entry != value->u.object.values+value->u.object.length; entry++)
{
if (!strcmp(entry->name, "uri") && entry->value->type == json_string) {
image->texture = load_image_uri(gltf, entry->value);
} else if (!strcmp(entry->name, "name") && entry->value->type == json_string) {
strncpy(image->name, entry->value->u.string.ptr, sizeof(image->name)-1);
} else {
printf("Unknown image key: '%s'\n", entry->name);
}
}
}
static void load_images(struct Gltf* gltf, json_value* value) {
for (json_value** entry = value->u.array.values;
entry != value->u.array.values+value->u.array.length; entry++)
{
if ((*entry)->type == json_object) {
load_image(gltf, BACK(gltf->images, gltf->cap_images, gltf->n_images), *entry);
} else {
printf("Unknown image type\n");
}
}
}
static void load_texture(struct GltfTexture* texture, json_value* value) {
for (json_object_entry* entry = value->u.object.values;
entry != value->u.object.values+value->u.object.length; entry++)
{
if (!strcmp(entry->name, "source") && entry->value->type == json_integer) {
texture->source = entry->value->u.integer;
}
}
}
static void load_textures(struct Gltf* gltf, json_value* value) {
for (json_value** entry = value->u.array.values;
entry != value->u.array.values+value->u.array.length; entry++)
{
if ((*entry)->type == json_object) {
load_texture(BACK(gltf->textures, gltf->cap_textures, gltf->n_textures), *entry);
} else {
printf("Unknown texture type\n");
}
}
}
static void load_tex_info(struct GltfTextureInfo* info, json_value* value) {
for (json_object_entry* entry = value->u.object.values;
entry != value->u.object.values+value->u.object.length; entry++)
{
if (!strcmp(entry->name, "index") && entry->value->type == json_integer) {
info->index = entry->value->u.integer;
} else if (!strcmp(entry->name, "texCoord") && entry->value->type == json_integer) {
info->tex_coord = entry->value->u.integer;
} else {
printf("Unknowm tex info key: '%s'\n", entry->name);
}
}
}
static void load_normal_tex_info(struct GltfNormalTextureInfo* info, json_value* value) {
for (json_object_entry* entry = value->u.object.values;
entry != value->u.object.values+value->u.object.length; entry++)
{
if (!strcmp(entry->name, "index") && entry->value->type == json_integer) {
info->index = entry->value->u.integer;
} else if (!strcmp(entry->name, "texCoord") && entry->value->type == json_integer) {
info->tex_coord = entry->value->u.integer;
} else if (!strcmp(entry->name, "scale")) {
info->scale = get_float(entry->value);
} else {
printf("Unknowm tex info key: '%s'\n", entry->name);
}
}
}
static void load_occlusion_tex_info(struct GltfOcclusionTextureInfo* info, json_value* value) {
for (json_object_entry* entry = value->u.object.values;
entry != value->u.object.values+value->u.object.length; entry++)
{
if (!strcmp(entry->name, "index") && entry->value->type == json_integer) {
info->index = entry->value->u.integer;
} else if (!strcmp(entry->name, "texCoord") && entry->value->type == json_integer) {
info->tex_coord = entry->value->u.integer;
} else if (!strcmp(entry->name, "strength")) {
info->strength = get_float(entry->value);
} else {
printf("Unknowm tex info key: '%s'\n", entry->name);
}
}
}
static void load_pbr_metallic_roughness(struct GltfMetallicRoughness* info, json_value* value) {
info->base_color_factor[0] = info->base_color_factor[1] = info->base_color_factor[2] = info->base_color_factor[3] = 1;
info->metallic_factor = info->roughness_factor = 1;
for (json_object_entry* entry = value->u.object.values;
entry != value->u.object.values+value->u.object.length; entry++)
{
if (!strcmp(entry->name, "baseColorFactor") && entry->value->type == json_array && entry->value->u.array.length == 4) {
load_vec(entry->value, info->base_color_factor, 4);
} else if (!strcmp(entry->name, "baseColorTexture") && entry->value->type == json_object) {
info->has_base_color_texture = 1;
load_tex_info(&info->base_color_texture, entry->value);
} else if (!strcmp(entry->name, "metallicFactor")) {
info->metallic_factor = get_float(entry->value);
} else if (!strcmp(entry->name, "roughnessFactor")) {
info->roughness_factor = get_float(entry->value);
} else if (!strcmp(entry->name, "metallicRoughnessTexture") && entry->value->type == json_object) {
info->has_metallic_roughness_texture = 1;
load_tex_info(&info->metallic_roughness_texture, entry->value);
} else {
printf("Unknowm pbr key: '%s'\n", entry->name);
}
}
}
static void load_material(struct GltfMaterial* material, json_value* value) {
for (json_object_entry* entry = value->u.object.values;
entry != value->u.object.values+value->u.object.length; entry++)
{
if (!strcmp(entry->name, "name") && entry->value->type == json_string) {
strncpy(material->name, entry->value->u.string.ptr, sizeof(material->name)-1);
} else if (!strcmp(entry->name, "pbrMetallicRoughness") && entry->value->type == json_object) {
material->has_pbr_metallic_roughness = 1;
load_pbr_metallic_roughness(&material->pbr_metallic_roughness, entry->value);
} else if (!strcmp(entry->name, "normalTexture") && entry->value->type == json_object) {
material->has_normal_texture = 1;
load_normal_tex_info(&material->normal_texture, entry->value);
} else if (!strcmp(entry->name, "occlusionTexture") && entry->value->type == json_object) {
material->has_occlusion_texture = 1;
load_occlusion_tex_info(&material->occlusion_texture, entry->value);
} else if (!strcmp(entry->name, "emissiveTexture") && entry->value->type == json_object) {
material->has_emissive_texture = 1;
load_tex_info(&material->emissive_texture, entry->value);
} else if (!strcmp(entry->name, "emissiveFactor") && entry->value->type == json_array && entry->value->u.array.length == 3) {
load_vec(entry->value, material->emissive_factor, 3);
} else if (!strcmp(entry->name, "alphaMode") && entry->value->type == json_string) {
if (!strcmp(entry->value->u.string.ptr, "OPAQUE")) {
material->alpha_mode = 1;
} else {
printf("Unknown alphaMode: '%s'\n", entry->value->u.string.ptr);
}
} else if (!strcmp(entry->name, "doubleSided") && entry->value->type == json_boolean) {
material->double_sided = entry->value->u.boolean;
} else {
printf("Unknown material key: '%s'\n", entry->name);
}
}
}
static void load_materials(struct Gltf* gltf, json_value* value) {
for (json_value** entry = value->u.array.values;
entry != value->u.array.values+value->u.array.length; entry++)
{
if ((*entry)->type == json_object) {
load_material(BACK(gltf->materials, gltf->cap_materials, gltf->n_materials), *entry);
} else {
printf("Unknown material type\n");
}
}
}
void gltf_ctor(struct Gltf* gltf, const char* fn) {
FILE* f = fopen(fn, "rb");
char* buf;
int64_t size;
memset(gltf, 0, sizeof(*gltf));
if (!f) {
printf("Cannot open '%s'\n", fn);
return;
}
fseek(f, 0, SEEK_END);
size = ftell(f);
buf = malloc(size+1);
fseek(f, 0, SEEK_SET);
verify(fread(buf, 1, size, f) == size);
buf[size] = 0;
fclose(f);
strncpy(gltf->fsbase, fn, sizeof(gltf->fsbase)-1);
char* p = strrchr(gltf->fsbase, '/');
if (*p) {
*(p+1) = 0;
}
json_value* value = json_parse(buf, size);
if (value->type != json_object) {
printf("Bad json format\n");
goto end;
}
for (json_object_entry* entry = value->u.object.values;
entry != value->u.object.values+value->u.object.length; entry++)
{
if (!strcmp(entry->name, "scene") && entry->value->type == json_integer) {
gltf->def = entry->value->u.integer;
} else if (!strcmp(entry->name, "scenes") && entry->value->type == json_array) {
load_scenes(gltf, entry->value);
} else if (!strcmp(entry->name, "nodes") && entry->value->type == json_array) {
load_nodes(gltf, entry->value);
} else if (!strcmp(entry->name, "materials")) {
load_materials(gltf, entry->value);
} else if (!strcmp(entry->name, "extensions")) {
// TODO
printf("Extensions unsupported yet\n");
} else if (!strcmp(entry->name, "buffers") && entry->value->type == json_array) {
load_buffers(gltf, entry->value);
} else if (!strcmp(entry->name, "bufferViews") && entry->value->type == json_array) {
load_views(gltf, entry->value);
} else if (!strcmp(entry->name, "asset")) {
// skip
printf("Asset\n");
} else if (!strcmp(entry->name, "accessors") && entry->value->type == json_array) {
load_accessors(gltf, entry->value);
} else if (!strcmp(entry->name, "meshes") && entry->value->type == json_array) {
load_meshes(gltf, entry->value);
} else if (!strcmp(entry->name, "cameras") && entry->value->type == json_array) {
load_cameras(gltf, entry->value);
} else if (!strcmp(entry->name, "images") && entry->value->type == json_array) {
load_images(gltf, entry->value);
} else if (!strcmp(entry->name, "textures") && entry->value->type == json_array) {
load_textures(gltf, entry->value);
} else {
printf("Unsupported key: '%s'\n", entry->name);
}
}
for (int i = 0; i < gltf->n_views; i++) {
verify(gltf->views[i].buffer < gltf->n_buffers);
gltf->views[i].data += (int64_t)gltf->buffers[gltf->views[i].buffer].data;
}
end:
json_value_free(value);
free(buf);
}
void gltf_dtor(struct Gltf* gltf) {
int i;
for (i = 0; i < gltf->n_buffers; i++) {
free(gltf->buffers[i].data);
}
for (i = 0; i < gltf->n_meshes; i++) {
free(gltf->meshes[i].primitives);
}
for (i = 0; i < gltf->n_images; i++) {
ktxTexture_Destroy((ktxTexture*)gltf->images[i].texture);
}
free(gltf->accessors);
free(gltf->scenes);
free(gltf->nodes);
free(gltf->meshes);
free(gltf->views);
free(gltf->buffers);
free(gltf->images);
free(gltf->textures);
}
struct Gltf* gltf_alloc() {
return calloc(1, sizeof(sizeof(struct Gltf)));
}
void gltf_free(struct Gltf* gltf) {
free(gltf);
}
|
resetius/graphtoys
|
tools/gltfprint.c
|
#include <stddef.h>
#include <stdio.h>
#include <string.h>
#include <stdint.h>
#include <stdlib.h>
#include <lib/formats/gltf.h>
int main(int argc, char** argv) {
struct Gltf gltf;
if (argc < 2) {
printf("usage: %s filename\n", argv[0]);
return -1;
}
gltf_ctor(&gltf, argv[1]);
for (int i = 0; i < gltf.n_scenes; i++) {
printf("Scene name: '%s'\n", gltf.scenes[i].name);
for (int j = 0; j < gltf.scenes[i].n_nodes; j++) {
printf("Node: %d\n", gltf.scenes[i].nodes[j]);
}
for (int j = 0; j < gltf.n_buffers; j++) {
printf("Buffer: %d %p %ld\n", j, gltf.buffers[j].data, (long)gltf.buffers[j].size);
}
for (int j = 0; j < gltf.n_views; j++) {
printf("View: %d %d %p %ld\n", j, gltf.views[j].buffer, gltf.views[j].data, (long)gltf.views[j].size);
}
for (int j = 0; j < gltf.n_nodes; j++) {
printf("Node: %d '%s'\n", j, gltf.nodes[j].name);
}
for (int j = 0; j < gltf.n_accessors; j++) {
printf("Accessor: %d %d %d\n", j, gltf.accessors[j].view, gltf.accessors[j].count);
}
}
printf("Meshes: %d\n", gltf.n_meshes);
gltf_dtor(&gltf);
return 0;
}
|
resetius/graphtoys
|
render/buffer.h
|
<gh_stars>0
#pragma once
#include <stdint.h>
enum BufferType {
BUFFER_ARRAY, // vao
BUFFER_SHADER_STORAGE,
BUFFER_UNIFORM,
BUFFER_INDEX
};
enum BufferMemoryType {
MEMORY_STATIC,
MEMORY_DYNAMIC,
MEMORY_DYNAMIC_COPY
};
// Создаем все виды буферов (vertex, storage, uniform) ...
// Делаем привязку буфера к descriptor'у через pipeline
// Для vulkan внутри хранится descriptorset
// Для opengl binding id
// Идентификаторы должны храниться внутри pipeline, так как один буффер может
// использоваться в разных pipeline с разными binding_id/descriptor_set
// Перед использованием буфера шлем descriptorset в сommand buffer или делаем bind
struct BufferManager {
// uniform create per-image
// dynamic create per-image?
int (*create)(
struct BufferManager* mgr,
enum BufferType type,
enum BufferMemoryType mem_type,
const void* data,
int size);
void (*update)(
struct BufferManager* mgr,
int id,
const void* data,
int offset,
int size);
void (*destroy)(struct BufferManager* mgr, int id);
// internal handler
void* (*get)(struct BufferManager* mgr, int id);
void (*release)(struct BufferManager* mgr, void* buffer);
struct BufferBase* (*acquire)(struct BufferManager* mgr, int buffer_size);
void (*free)(struct BufferManager* mgr);
};
int buffer_create(
struct BufferManager* b,
enum BufferType type,
enum BufferMemoryType mem_type,
const void* data,
int size);
void buffer_update(
struct BufferManager* b,
int id,
const void* data,
int offset,
int size);
// buffer_id
// local_buffer_id (buffer_id in pipeline)
// local_buffer_id = pipeline->assign(buffer_id, binding)
// pipeline->use_buffer(local_buffer_id)
// pipeline->swap_assignments(local_buffer_id1, local_buffer_id2)
struct BufferBase {
int id;
int valid;
int size;
};
struct BufferManagerBase {
struct BufferManager iface;
int buffer_size;
char* buffers;
int n_buffers;
int cap;
int64_t total_memory;
};
void buffermanager_base_ctor(struct BufferManagerBase* bm, int buffer_size);
|
resetius/graphtoys
|
vulkan/frame.h
|
<reponame>resetius/graphtoys
#pragma once
#include "vk.h"
#include "commandbuffer.h"
struct RenderImpl;
struct Frame {
struct CommandBuffer cb;
VkCommandBuffer cmd;
VkFence fence;
VkSemaphore acquire_image;
VkSemaphore render_finished;
};
void frame_init(struct Frame* frame, struct RenderImpl* r);
void frame_destroy(struct Frame* frame);
VkCommandBuffer frame_cb(struct Frame* frame);
|
resetius/graphtoys
|
lib/ref.h
|
<filename>lib/ref.h<gh_stars>0
#pragma once
#include <stdatomic.h>
struct Ref {
atomic_int counter;
void (*free)(struct Ref* r);
};
void ref(struct Ref*);
void unref(struct Ref*);
|
resetius/graphtoys
|
render/buffer.c
|
<gh_stars>0
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include "buffer.h"
#include "render.h"
static struct BufferBase* buffer_acquire_(struct BufferManagerBase* b, int size) {
struct BufferBase* buf = NULL;
if (b->n_buffers >= b->cap) {
int i;
for (i = b->n_buffers - 1; i >= 0 && ((struct BufferBase*)&b->buffers[b->buffer_size * i])->valid; --i) {
;
}
if (i >= 0) {
buf = (struct BufferBase*)&b->buffers[i*b->buffer_size];
}
}
if (!buf && b->n_buffers >= b->cap) {
int old_cap = b->cap;
b->cap = (1+b->cap)*2;
b->buffers = realloc(b->buffers, b->cap*b->buffer_size);
memset(b->buffers + old_cap * b->buffer_size,
0,
(b->cap - old_cap)*b->buffer_size);
}
if (!buf) {
int id = b->n_buffers++;
buf = (struct BufferBase*)&b->buffers[id*b->buffer_size];
buf->id = id;
}
b->total_memory += size;
printf("(%p) buffer memory: %lld\n", b, (long long)b->total_memory);
buf->valid = 1;
buf->size = size;
return buf;
}
static void buffer_release_(struct BufferManager* mgr, int id) {
struct BufferManagerBase* b = (struct BufferManagerBase*)mgr;
struct BufferBase base = {
.id = id,
.valid = 0,
.size = 0,
};
assert(id < b->n_buffers);
b->iface.release(&b->iface, &b->buffers[id*b->buffer_size]);
b->total_memory -= ((struct BufferBase*)&b->buffers[id*b->buffer_size])->size;
printf("(%p) free buffer memory: %lld\n", b, (long long)b->total_memory);
memcpy(&b->buffers[id*b->buffer_size], &base, sizeof(base));
while (b->n_buffers > 0 &&
!((struct BufferBase*)&b->buffers[b->buffer_size * (b->n_buffers - 1)])->valid)
{
b->n_buffers --;
}
}
static void buffer_mgr_free_(struct BufferManager* mgr) {
struct BufferManagerBase* b = (struct BufferManagerBase*)mgr;
while (b->n_buffers > 0) {
buffer_release_(mgr, b->n_buffers-1);
}
free(b->buffers);
free(b);
}
static void* buffer_get_(struct BufferManager* mgr, int id) {
struct BufferManagerBase* b = (struct BufferManagerBase*)mgr;
assert(id < b->n_buffers);
return &b->buffers[id*b->buffer_size];
}
int buffer_create(
struct BufferManager* b,
enum BufferType type,
enum BufferMemoryType mem_type,
const void* data,
int size)
{
return b->create(b, type, mem_type, data, size);
}
void buffer_update(
struct BufferManager* b,
int id,
const void* data,
int offset,
int size)
{
return b->update(b, id, data, offset, size);
}
void buffermanager_base_ctor(struct BufferManagerBase* bm, int buffer_size) {
struct BufferManager iface = {
.get = buffer_get_,
.destroy = buffer_release_,
.free = buffer_mgr_free_,
.acquire = buffer_acquire_,
};
bm->iface = iface;
bm->buffer_size = buffer_size;
}
|
resetius/graphtoys
|
vulkan/renderpass.h
|
#pragma once
#include "vk.h"
struct RenderPass {
VkRenderPass rp;
VkDevice dev;
};
void rp_init(struct RenderPass* r, VkDevice logDev, VkFormat swapChainImageFormat, VkFormat depthFormat);
void rp_destroy(struct RenderPass* r);
void rp_begin(
struct RenderPass* r, VkClearValue* values, int n_values, VkCommandBuffer commands,
VkFramebuffer framebuffer, VkExtent2D extent);
void rp_end(struct RenderPass* r, VkCommandBuffer commands);
|
resetius/graphtoys
|
font/font.h
|
<filename>font/font.h
#pragma once
#include <stdint.h>
#include <render/render.h>
struct Font;
struct BufferPair;
struct Label {
struct Font* f;
uint32_t* text;
struct BufferPair* buf;
int len;
int cap;
int x;
int y;
int w;
int h;
int id;
int dirty;
};
struct Font* font_new(struct Render* r,
int char_width,
int char_height,
int device_w,
int device_h);
void font_free(struct Font*);
struct Label* label_alloc();
void label_ctor(struct Label*l, struct Font* f);
void label_dtor(struct Label*l);
void label_set_text(struct Label* l, const char* s);
void label_set_vtext(struct Label* l, const char* s, ...);
void label_set_pos(struct Label* l, int x, int y);
void label_set_screen(struct Label* l, int w, int h);
void label_render(struct Label* l);
void label_free(struct Label* l);
|
resetius/graphtoys
|
vulkan/swapchain.c
|
#include <stdio.h>
#include <stdlib.h>
#include "swapchain.h"
#include "render_impl.h"
#include "tools.h"
// TODO
static uint32_t max(uint32_t a, uint32_t b) {
return a>b?a:b;
}
static uint32_t min(uint32_t a, uint32_t b) {
return a<b?a:b;
}
static VkSurfaceFormatKHR choose_format(VkSurfaceFormatKHR* formats, int n) {
int i;
if (n == 1 && formats[0].format == VK_FORMAT_UNDEFINED) {
VkSurfaceFormatKHR format = {
VK_FORMAT_B8G8R8A8_UNORM,
VK_COLOR_SPACE_SRGB_NONLINEAR_KHR
};
return format;
}
for (i = 0; i < n; i++) {
VkSurfaceFormatKHR* format = &formats[i];
if (format->format == VK_FORMAT_B8G8R8A8_UNORM
&& format->colorSpace == VK_COLOR_SPACE_SRGB_NONLINEAR_KHR)
{
return *format;
}
}
return formats[0];
}
static VkPresentModeKHR choose_mode(VkPresentModeKHR* modes, int n_modes, int vsync) {
if (!vsync) {
int i;
for (i = 0; i < n_modes; i++) {
if (modes[i] == VK_PRESENT_MODE_IMMEDIATE_KHR) {
return VK_PRESENT_MODE_IMMEDIATE_KHR;
}
}
for (i = 0; i < n_modes; i++) {
if (modes[i] == VK_PRESENT_MODE_MAILBOX_KHR) {
return VK_PRESENT_MODE_MAILBOX_KHR;
}
}
}
return VK_PRESENT_MODE_FIFO_KHR;
}
static VkExtent2D choose_extent(const VkSurfaceCapabilitiesKHR* caps) {
if (caps->currentExtent.width != (uint32_t)-1) {
return caps->currentExtent;
} else {
VkExtent2D extent = { 800, 600 };
extent.width = max(
caps->minImageExtent.width,
min(caps->maxImageExtent.width, extent.width));
extent.height = max(
caps->minImageExtent.height,
min(caps->maxImageExtent.height, extent.height));
return extent;
}
}
static VkFormat find_supported_format(
struct RenderImpl* r,
VkFormat* candidates, int n_candidates,
VkImageTiling tiling,
VkFormatFeatureFlags features)
{
int i;
for (i = 0; i < n_candidates; i++) {
VkFormat format = candidates[i];
VkFormatProperties props;
vkGetPhysicalDeviceFormatProperties(r->phy_dev, format, &props);
if (tiling == VK_IMAGE_TILING_LINEAR && (props.linearTilingFeatures & features) == features) {
return format;
} else if (tiling == VK_IMAGE_TILING_OPTIMAL && (props.optimalTilingFeatures & features) == features) {
return format;
}
}
fprintf(stderr, "failed to find supported format!");
exit(-1);
}
void sc_init(struct SwapChain* sc, struct RenderImpl* r) {
//sc->depth_format = VK_FORMAT_D24_UNORM_S8_UINT; // TODO: detect format
VkFormat formats [] = {
VK_FORMAT_D24_UNORM_S8_UINT,
VK_FORMAT_D32_SFLOAT,
VK_FORMAT_D32_SFLOAT_S8_UINT,
};
sc->depth_format = find_supported_format(
r, formats,
sizeof(formats)/sizeof(VkFormat),
VK_IMAGE_TILING_OPTIMAL,
VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT);
VkSurfaceFormatKHR surfaceFormat = choose_format(r->formats, r->n_formats);
VkPresentModeKHR presentMode = choose_mode(
r->modes,
r->n_modes,
r->cfg.vsync);
VkExtent2D extent = choose_extent(&r->caps);
uint32_t imageCount = r->cfg.triple_buffer
? 3
: r->caps.minImageCount;
if (r->caps.maxImageCount > 0 && imageCount > r->caps.maxImageCount) {
imageCount = r->caps.maxImageCount;
}
VkSwapchainCreateInfoKHR createInfo = {
.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR,
.surface = r->surface,
.minImageCount = imageCount,
.imageFormat = surfaceFormat.format,
.imageColorSpace = surfaceFormat.colorSpace,
.imageExtent = extent,
.imageArrayLayers = 1,
.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,
.preTransform = r->caps.currentTransform,
.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR,
.presentMode = presentMode,
.clipped = VK_TRUE,
.oldSwapchain = VK_NULL_HANDLE
};
uint32_t queueFamilyIndices[] = {
(uint32_t)r->graphics_family,
(uint32_t)r->present_family
};
if (r->graphics_family != r->present_family) {
createInfo.imageSharingMode = VK_SHARING_MODE_CONCURRENT;
createInfo.queueFamilyIndexCount = 2;
createInfo.pQueueFamilyIndices = queueFamilyIndices;
}
else {
createInfo.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
createInfo.queueFamilyIndexCount = 0;
createInfo.pQueueFamilyIndices = NULL;
}
if (vkCreateSwapchainKHR(r->log_dev, &createInfo, NULL, &sc->swapchain) != VK_SUCCESS)
{
fprintf(stderr, "failed to create swap chain !\n");
exit(-1);
}
vkGetSwapchainImagesKHR(r->log_dev, sc->swapchain, &imageCount, NULL);
sc->images = malloc(imageCount*sizeof(VkImage));
sc->n_images = imageCount;
vkGetSwapchainImagesKHR(r->log_dev, sc->swapchain, &imageCount, sc->images);
sc->im_format = surfaceFormat.format;
sc->extent = extent;
sc->r = r;
create_image(
r->memory_properties,
r->log_dev,
sc->extent.width,
sc->extent.height,
sc->depth_format,
VK_IMAGE_TILING_OPTIMAL,
VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT,
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
&sc->depth_image,
&sc->depth_image_memory);
}
void sc_destroy(struct SwapChain* sc) {
free(sc->images);
vkDestroyImage(sc->r->log_dev, sc->depth_image, NULL);
vkFreeMemory(sc->r->log_dev, sc->depth_image_memory, NULL);
vkDestroySwapchainKHR(sc->r->log_dev, sc->swapchain, NULL);
}
|
resetius/graphtoys
|
models/stl.c
|
<reponame>resetius/graphtoys<filename>models/stl.c
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <lib/formats/stl.h>
#include <lib/object.h>
#include "stl.h"
#include <render/pipeline.h>
#include <lib/linmath.h>
#include <models/stl.frag.h>
#include <models/stl.vert.h>
#include <models/stl.frag.spv.h>
#include <models/stl.vert.spv.h>
#include <models/dot.frag.h>
#include <models/dot.vert.h>
#include <models/dot.frag.spv.h>
#include <models/dot.vert.spv.h>
// x = (R+r cos(psi)) cos phi
// y = (R+r cos(psi)) sin phi
// z = r sin phi
// psi in [0,2pi)
// phi in [-pi,pi)
struct UniformBlock {
mat4x4 mv;
mat4x4 mvp;
mat4x4 norm;
vec4 light;
};
struct Stl {
struct Object base;
struct UniformBlock uniform;
struct Pipeline* pl;
struct Pipeline* plt;
struct BufferManager* b;
//mat4x4 m;
float ax, ay, az;
vec4 light;
quat q;
int model;
int uniform_id;
int dot;
int dot_uniform_id;
};
static void t_draw(struct Object* obj, struct DrawContext* ctx) {
struct Stl* t = (struct Stl*)obj;
mat4x4 m, v, p, mv, mvp;
mat4x4_identity(m);
//mat4x4_rotate_X(m, m, ctx->time);
//mat4x4_rotate_Y(m, m, ctx->time);
//mat4x4_rotate_Z(m, m, ctx->time);
//memcpy(m, t->m, sizeof(m));
mat4x4_from_quat(m, t->q);
vec3 eye = {0.0f, -10.0f, 0.f};
vec3 center = {.0f, .0f, .0f};
vec3 up = {.0f, .0f, -.1f};
//vec3 eye = {0.0f, -1.0f, 0.f};
//vec3 center = {.0f, .0f, .0f};
//vec3 up = {.0f, .0f, -.1f};
mat4x4_look_at(v, eye, center, up);
//mat4x4_rotate_X(v, v, ctx->time);
//mat4x4_rotate_Y(v, v, ctx->time);
//mat4x4_rotate_Z(v, v, ctx->time);
mat4x4_mul(mv, v, m);
//mat4x4_ortho(p, -ctx->ratio, ctx->ratio, -1.f, 1.f, 1.f, -1.f);
//mat4x4_identity(p);
mat4x4_perspective(p, 70./2./M_PI, ctx->ratio, 0.3f, 1000.f);
mat4x4_mul(mvp, p, mv);
mat4x4 norm;
//mat4x4_invert(norm4, mv);
//mat4x4_transpose(norm4, norm4);
//mat3x3 norm;
//mat3x3_from_mat4x4(norm, norm4);
//mat3x3_from_mat4x4(norm, mv);
memcpy(norm, mv, sizeof(norm));
norm[3][0] = norm[3][1] = norm[3][2] = 0;
norm[0][3] = norm[1][3] = norm[2][3] = 0;
norm[3][3] = 1;
memcpy(t->uniform.mvp, mvp, sizeof(mvp));
memcpy(t->uniform.mv, mv, sizeof(mv));
memcpy(t->uniform.norm, norm, sizeof(norm));
//mat4x4 lrot;
//mat4x4_identity(lrot);
//mat4x4_rotate_X(lrot, lrot, ctx->time);
//vec4 light = {10, -10, 20, 0};
//mat4x4_mul_vec4(t->uniform.light, lrot, light);
//printf("%f %f %f %f\n, ", t->uniform.light[0],t->uniform.light[1],t->uniform.light[2],t->uniform.light[3]);
//memcpy(t->uniform.light, light, sizeof(light));
// light position in view coordinate
mat4x4_mul_vec4(t->uniform.light, v, t->light);
t->pl->start(t->pl);
buffer_update(t->b, t->uniform_id, &t->uniform, 0, sizeof(t->uniform));
t->pl->draw(t->pl, t->model);
mat4x4 m1;
mat4x4_identity(m1);
mat4x4_translate_in_place(m1, t->light[0], t->light[1], t->light[2]);
mat4x4_rotate_X(m1, m1, M_PI/2);
mat4x4_mul(mv, v, m1);
mat4x4_mul(mvp, p, mv);
t->plt->start(t->plt);
buffer_update(t->b, t->dot_uniform_id, mvp, 0, sizeof(mvp));
t->plt->draw(t->plt, t->dot);
}
static void transform(struct Stl* t) {
vec3 ox = {1,0,0};
vec3 oy = {0,1,0};
vec3 oz = {0,0,1};
quat ox1 = {1,0,0,0};
quat oy1 = {0,1,0,0};
quat oz1 = {0,0,1,0};
quat qx, qy, qz, q;
quat_conj(q, t->q);
quat_mul(ox1, ox1, t->q);
quat_mul(ox1, q, ox1);
memcpy(ox, ox1, sizeof(vec3));
quat_mul(oy1, oy1, t->q);
quat_mul(oy1, q, oy1);
memcpy(oy, oy1, sizeof(vec3));
quat_mul(oz1, oz1, t->q);
quat_mul(oz1, q, oz1);
memcpy(oz, oz1, sizeof(vec3));
quat_rotate(qx, t->ax, ox);
quat_rotate(qy, t->ay, oy);
quat_rotate(qz, t->az, oz);
quat_mul(t->q, t->q, qx);
quat_mul(t->q, t->q, qy);
quat_mul(t->q, t->q, qz);
t->ax = t->ay = t->az = 0;
}
static void move_left(struct Object* obj, int mods) {
struct Stl* t = (struct Stl*)obj;
if (mods & 1) {
t->light[0] -= 0.1;
} else {
t->az += -5*M_PI/360;
}
transform(t);
}
static void move_right(struct Object* obj, int mods) {
struct Stl* t = (struct Stl*)obj;
if (mods & 1) {
t->light[0] += 0.1;
} else {
t->az += 5*M_PI/360;
}
transform(t);
}
static void move_up(struct Object* obj, int mods) {
struct Stl* t = (struct Stl*)obj;
if (mods & 1) {
t->light[2] += 0.1;
} else {
t->ax += -5*M_PI/360;
}
transform(t);
}
static void move_down(struct Object* obj, int mods) {
struct Stl* t = (struct Stl*)obj;
if (mods & 1) {
t->light[2] -= 0.1;
} else {
t->ax += 5*M_PI/360;
}
transform(t);
}
static void zoom_in(struct Object* obj, int mods) {
struct Stl* t = (struct Stl*)obj;
if (mods & 1) {
t->light[1] += 0.1;
} else {
t->ay += 5*M_PI/360;;
}
transform(t);
}
static void zoom_out(struct Object* obj, int mods) {
struct Stl* t = (struct Stl*)obj;
if (mods & 1) {
t->light[1] -= 0.1;
} else {
t->ay += -5*M_PI/360;
}
transform(t);
}
static void t_free(struct Object* obj) {
struct Stl* t = (struct Stl*)obj;
t->pl->free(t->pl);
t->b->free(t->b);
free(t);
}
struct Object* CreateStl(struct Render* r, struct Config* cfg) {
struct Stl* t = calloc(1, sizeof(struct Stl));
struct Object base = {
.draw = t_draw,
.free = t_free,
.move_left = move_left,
.move_right = move_right,
.move_up = move_up,
.move_down = move_down,
.zoom_in = zoom_in,
.zoom_out = zoom_out,
};
struct StlVertex* vertices;
int nvertices;
struct ShaderCode vertex_shader = {
.glsl = models_stl_vert,
.spir_v = models_stl_vert_spv,
.size = models_stl_vert_spv_size,
};
struct ShaderCode fragment_shader = {
.glsl = models_stl_frag,
.spir_v = models_stl_frag_spv,
.size = models_stl_frag_spv_size,
};
struct ShaderCode vertex_shadert = {
.glsl = models_dot_vert,
.spir_v = models_dot_vert_spv,
.size = models_dot_vert_spv_size,
};
struct ShaderCode fragment_shadert = {
.glsl = models_dot_frag,
.spir_v = models_dot_frag_spv,
.size = models_dot_frag_spv_size,
};
//mat4x4_identity(t->m);
quat_identity(t->q);
t->base = base;
vec4 light = {0, 0, 0, 1};
vec4_dup(t->light, light);
const char* fn = cfg_gets_def(cfg, "name", "skull_art.stl");
//FILE* f = fopen("tricky_kittens.stl", "rb");
//FILE* f = fopen("rocklobster_solid.stl", "rb");
//FILE* f = fopen("Doraemon_Lucky_Cat.stl", "rb");
vertices = stl_load(fn, &nvertices);
t->b = r->buffer_manager(r);
struct PipelineBuilder* pl = r->pipeline(r);
t->pl = pl
->set_bmgr(pl, t->b)
->begin_program(pl)
->add_vs(pl, vertex_shader)
->add_fs(pl, fragment_shader)
->end_program(pl)
->uniform_add(pl, 0, "MatrixBlock")
->begin_buffer(pl, sizeof(struct StlVertex))
->buffer_attribute(pl, 3, 3, DATA_FLOAT, offsetof(struct StlVertex, col))
->buffer_attribute(pl, 2, 3, DATA_FLOAT, offsetof(struct StlVertex, norm))
->buffer_attribute(pl, 1, 3, DATA_FLOAT, offsetof(struct StlVertex, pos))
->end_buffer(pl)
->enable_depth(pl)
->build(pl);
t->uniform_id = buffer_create(t->b, BUFFER_UNIFORM, MEMORY_DYNAMIC, NULL, sizeof(struct UniformBlock));
t->pl->uniform_assign(t->pl, 0, t->uniform_id);
int model_buffer_id = buffer_create(t->b, BUFFER_ARRAY, MEMORY_STATIC, vertices, nvertices*sizeof(struct StlVertex));
t->model = pl_buffer_assign(t->pl, 0, model_buffer_id);
struct StlVertex pp[] = {
{{1.0, 0.0, 1.0}, {0.0, 0.0, 0.0}, { -1, 1, 0}},
{{1.0, 0.0, 1.0}, {0.0, 0.0, 0.0}, { -1, -1, 0}},
{{1.0, 0.0, 1.0}, {0.0, 0.0, 0.0}, { 1, -1, 0}},
{{1.0, 0.0, 1.0}, {0.0, 0.0, 0.0}, { -1, 1, 0}},
{{1.0, 0.0, 1.0}, {0.0, 0.0, 0.0}, { 1, -1, 0}},
{{1.0, 0.0, 1.0}, {0.0, 0.0, 0.0}, { 1, 1, 0}}
};
struct PipelineBuilder* plt = r->pipeline(r);
t->plt = plt
->set_bmgr(plt, t->b)
->begin_program(plt)
->add_vs(plt, vertex_shadert)
->add_fs(plt, fragment_shadert)
->end_program(plt)
->uniform_add(plt, 0, "MatrixBlock")
->begin_buffer(plt, sizeof(struct StlVertex))
->buffer_attribute(plt, 2, 3, DATA_FLOAT, offsetof(struct StlVertex, col))
->buffer_attribute(plt, 1, 3, DATA_FLOAT, offsetof(struct StlVertex, pos))
->end_buffer(plt)
->enable_blend(plt)
->enable_depth(plt)
->build(plt);
t->dot_uniform_id = buffer_create(t->b, BUFFER_UNIFORM, MEMORY_DYNAMIC, NULL, sizeof(mat4x4));
t->plt->uniform_assign(t->plt, 0, t->dot_uniform_id);
int dot_buffer_id = buffer_create(t->b, BUFFER_ARRAY, MEMORY_STATIC, pp, sizeof(pp));
t->dot = pl_buffer_assign(t->plt, 0, dot_buffer_id);
free(vertices);
return (struct Object*)t;
}
|
resetius/graphtoys
|
font/font.c
|
<filename>font/font.c
#include <stdlib.h>
#include <stdio.h>
#include <stdarg.h>
#include <ctype.h>
#include <ft2build.h>
#include FT_FREETYPE_H
#include <render/pipeline.h>
#include <render/char.h>
#include <render/render.h>
#include <font/font.vert.h>
#include <font/font.frag.h>
#include <font/font.vert.spv.h>
#include <font/font.frag.spv.h>
#include <font/RobotoMono-Regular.ttf.h>
#include "font.h"
#include <lib/linmath.h>
struct UniformBlock {
mat4x4 mvp;
};
struct BufferPair {
int id;
int vao;
};
struct FontImpl {
struct Char* chars[65536];
struct UniformBlock uniform;
struct Pipeline* pl;
struct BufferManager* b;
int current_id;
int max_letters;
int uniform_id;
};
static void char_load(struct Render* r, struct Char* chars[], FT_Face face, wchar_t ch) {
struct Char** out = &chars[ch];
int error;
error = FT_Load_Char(face, ch, FT_LOAD_RENDER);
if (error) {
printf("Cannot load char: %d\n", error);
exit(1);
}
error = FT_Render_Glyph(face->glyph, FT_RENDER_MODE_NORMAL);
if (error) {
printf("Cannot render glyph: %d\n", error);
exit(1);
}
*out = rend_char_new(r, ch, face);
}
struct Font* font_new(struct Render* r, int char_w, int char_h, int dev_w, int dev_h) {
struct FontImpl* t = calloc(1, sizeof(*t));
int i;
FT_Library library;
FT_Face face;
const wchar_t* cyr =
L"АБВГДЕЁЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯ"
L"абвгдеёжзийклмнопрстуфхцчшщъыьэюя";
int error = FT_Init_FreeType(&library);
if (error) {
printf("Cannot load FreeType\n");
exit(1);
}
error = FT_New_Memory_Face(
library,
(const FT_Byte*)font_RobotoMono_Regular_ttf,
font_RobotoMono_Regular_ttf_size,
0,
&face);
if (error) {
printf("Cannot load Font\n");
exit(1);
}
error = FT_Set_Char_Size(
face, /* handle to face object */
char_w, /* char_width in 1/64th of points */
char_h, /* char_height in 1/64th of points */
dev_w, /* horizontal device resolution */
dev_h ); /* vertical device resolution */
if (error) {
printf("Cannot set char size\n");
exit(1);
}
t->max_letters = 100;
memset(t->chars, 0, sizeof(t->chars));
// load ascii
for (i = 1; i < 128; i++) {
char_load(r, t->chars, face, i);
}
while (*cyr) {
char_load(r, t->chars, face, *cyr++);
}
struct ShaderCode vertex_shader = {
.glsl = font_font_vert,
.spir_v = font_font_vert_spv,
.size = font_font_vert_spv_size,
};
struct ShaderCode fragment_shader = {
.glsl = font_font_frag,
.spir_v = font_font_frag_spv,
.size = font_font_frag_spv_size,
};
t->b = r->buffer_manager(r);
struct PipelineBuilder* p = r->pipeline(r);
struct Pipeline* pl = p
->set_bmgr(p, t->b)
->begin_program(p)
->add_vs(p, vertex_shader)
->add_fs(p, fragment_shader)
->end_program(p)
->begin_buffer(p, sizeof(vec4)) // {x,y,s,t}
// set buffer data later in char render
->buffer_attribute(p, 1, 4, DATA_FLOAT, 0)
->end_buffer(p)
->uniform_add(p, 0, "MatrixBlock")
->begin_sampler(p, 0)
->end_sampler(p)
->enable_blend(p)
//->begin_descriptor(p)
// for each texture
//->end_descriptor(p)
->build(p);
t->pl = pl;
t->uniform_id = buffer_create(t->b, BUFFER_UNIFORM, MEMORY_DYNAMIC, NULL, sizeof(t->uniform));
pl_uniform_assign(t->pl, 0, t->uniform_id);
FT_Done_Face(face);
FT_Done_FreeType(library);
return (struct Font*)t;
}
void font_free(struct Font* o) {
int i;
struct FontImpl* f = (struct FontImpl*)o;
if (f) {
for (i = 0; i < sizeof(f->chars)/sizeof(struct Char*); i++) {
if (f->chars[i]) {
f->chars[i]->free(f->chars[i]);
}
}
f->pl->free(f->pl);
free(f);
}
}
static int next_or_die(const unsigned char** p, jmp_buf* buf) {
if (((**p) >> 6) != 0x2) {
longjmp(*buf, 1);
}
return (*((*p)++)) & 0x3f;
}
void label_set_text(struct Label* l, const char* s1) {
int len = strlen(s1);
const unsigned char* s = (const unsigned char*)s1;
struct FontImpl* f = (struct FontImpl*)l->f;
if (l->cap < len) {
l->cap = len+1;
l->text = realloc(l->text, l->cap*sizeof(uint32_t));
l->buf = realloc(l->buf, l->cap*sizeof(struct BufferPair));
}
int k = 0;
jmp_buf buf;
int except = setjmp(buf);
uint32_t symbol = 0;
int changed = 0;
while (*s && !except) {
symbol = 0;
if ((*s & 0x80) == 0) {
symbol = *s++;
} else if (((*s) >> 5) == 0x6) {
symbol = ((*s++) & 0x1f) << 6;
symbol |= next_or_die(&s, &buf);
} else if (((*s) >> 4) == 0xe) {
symbol = ((*s++) & 0xf) << 12;
symbol |= next_or_die(&s, &buf) << 6;
symbol |= next_or_die(&s, &buf);
} else if (((*s) >> 3) == 0x1e) {
symbol = ((*s++) & 0x7) << 18;
symbol |= next_or_die(&s, &buf) << 12;
symbol |= next_or_die(&s, &buf) << 6;
symbol |= next_or_die(&s, &buf);
} else {
longjmp(buf, 1);
}
changed |= k >= l->len || l->text[k] != symbol;
if (changed) {
l->text[k] = symbol | 0x80000000;
}
if (k >= l->len) {
l->buf[k].id = buffer_create(f->b, BUFFER_ARRAY, MEMORY_DYNAMIC, NULL, 6*4*4);
l->buf[k].vao = pl_buffer_assign(f->pl, 0, l->buf[k].id);
}
k++;
}
if (except) {
printf("Bad utf-8 sequence\n");
}
l->len = k;
}
void label_set_vtext(struct Label* l, const char* format, ...) {
char buf[32768];
va_list args;
va_start(args, format);
vsnprintf(buf, sizeof(buf), format, args);
va_end(args);
label_set_text(l, buf);
}
void label_set_pos(struct Label* l, int x, int y) {
l->x = x;
l->y = y;
}
void label_set_screen(struct Label* l, int w, int h) {
l->w = w;
l->h = h;
l->dirty = 5;
}
void label_render(struct Label* l)
{
struct FontImpl* f = (struct FontImpl*)l->f;
int x = l->x;
int y = l->y;
mat4x4 m, p, mvp;
struct Char* ch;
int i;
mat4x4_identity(m);
mat4x4_ortho(p, 0, l->w, 0, l->h, 1.f, -1.f);
p[3][2] = 0;
mat4x4_mul(mvp, p, m);
if (l->dirty--) {
buffer_update(f->b, f->uniform_id, mvp, 0, sizeof(mvp));
}
f->pl->start(f->pl);
for (i = 0; i < l->len; i++) {
uint32_t symbol = l->text[i];
int changed = !! (symbol & 0x80000000);
symbol &= ~0x80000000;
l->text[i] = symbol;
if (isspace(symbol)) {
ch = f->chars['o'];
} else {
ch = f->chars[symbol];
if (!ch) {
continue;
}
float xpos, ypos, w, h;
xpos = x + ch->left;
ypos = y - (ch->h - ch->top);
w = ch->w;
h = ch->h;
float vertices[6][4] = {
{ xpos, ypos + h, 0.0, 0.0 },
{ xpos, ypos, 0.0, 1.0 },
{ xpos + w, ypos, 1.0, 1.0 },
{ xpos, ypos + h, 0.0, 0.0 },
{ xpos + w, ypos, 1.0, 1.0 },
{ xpos + w, ypos + h, 1.0, 0.0 }
};
if (changed) {
buffer_update(f->b, l->buf[i].id, vertices, 0, sizeof(vertices));
}
f->pl->use_texture(f->pl, ch->texture(ch));
f->pl->draw(f->pl, l->buf[i].vao);
}
if (!ch) {
continue;
}
x += ch->advance>>6;
}
}
struct Label* label_alloc() {
return malloc(sizeof(struct Label));
}
void label_ctor(struct Label* l, struct Font* f) {
struct FontImpl* f1 = (struct FontImpl*)f;
memset(l, 0, sizeof(*l));
l->f = f;
l->id = f1->current_id ++;
l->dirty = 5;
}
void label_dtor(struct Label* l) {
if (l) {
free(l->text);
free(l->buf);
}
}
void label_free(struct Label* l) {
free(l);
}
|
resetius/graphtoys
|
tools/cfgprint.c
|
#include <stdio.h>
#include <lib/config.h>
int main(int argc, char** argv) {
struct Config* cfg;
if (argc < 2) {
printf("Usage: %s config.ini\n", argv[0]);
return -1;
}
cfg = cfg_new(argv[1], argc, argv);
cfg_print(cfg);
cfg_free(cfg);
return 0;
}
|
resetius/graphtoys
|
lib/camera.h
|
#pragma once
#include <lib/linmath.h>
#include <lib/event.h>
// TODO: orthographic camera
struct Camera {
vec3 eye;
vec3 center;
vec3 up;
float fov;
float aspect;
float znear;
float zfar;
};
void cam_init(struct Camera* cam);
void cam_update(mat4x4 v, mat4x4 p, struct Camera* cam);
void cam_rotate(struct Camera* cam, quat q);
void cam_translate(struct Camera* cam, vec3 translation);
struct CameraEventConsumer {
struct EventConsumer base;
struct Camera* cam;
};
void cam_event_consumer_init(struct CameraEventConsumer* cons, struct Camera* cam);
|
resetius/graphtoys
|
opengl/buffer.h
|
#pragma once
#include <render/buffer.h>
#include "glad/gl.h"
struct BufferImpl {
struct BufferBase base;
GLuint buffer;
GLenum type;
GLenum mtype;
int size;
};
struct Render;
struct BufferManager* buf_mgr_opengl_new(struct Render* r);
// TODO: BufferManager free
|
resetius/graphtoys
|
vulkan/symbols.h
|
#ifndef L0_FUNC
#define L0_FUNC(name)
#endif
L0_FUNC(vkCreateInstance);
L0_FUNC(vkEnumerateInstanceExtensionProperties);
#undef L0_FUNC
#ifndef L1_FUNC
#define L1_FUNC(name)
#endif
L1_FUNC(vkEnumeratePhysicalDevices);
L1_FUNC(vkGetPhysicalDeviceProperties);
L1_FUNC(vkGetPhysicalDeviceFormatProperties);
L1_FUNC(vkGetPhysicalDeviceMemoryProperties);
L1_FUNC(vkGetPhysicalDeviceFeatures);
L1_FUNC(vkGetPhysicalDeviceQueueFamilyProperties);
L1_FUNC(vkCreateDevice);
L1_FUNC(vkGetDeviceProcAddr);
L1_FUNC(vkDestroyInstance);
L1_FUNC(vkEnumerateDeviceExtensionProperties);
L1_FUNC(vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR);
L1_FUNC(vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR);
L1_FUNC(vkGetPhysicalDeviceSurfaceCapabilitiesKHR);
L1_FUNC(vkGetPhysicalDeviceSurfaceFormatsKHR);
L1_FUNC(vkGetPhysicalDeviceSurfacePresentModesKHR);
L1_FUNC(vkGetPhysicalDeviceSurfaceSupportKHR);
L1_FUNC(vkGetPhysicalDeviceImageFormatProperties);
L1_FUNC(vkDestroySurfaceKHR);
#undef L1_FUNC
#ifndef L2_FUNC
#define L2_FUNC(name)
#endif
L2_FUNC(vkAcquireNextImageKHR);
L2_FUNC(vkAllocateDescriptorSets);
L2_FUNC(vkCmdBlitImage);
L2_FUNC(vkMapMemory);
L2_FUNC(vkUnmapMemory);
L2_FUNC(vkGetDeviceQueue);
L2_FUNC(vkDeviceWaitIdle);
L2_FUNC(vkDestroyDevice);
L2_FUNC(vkCreateSemaphore);
L2_FUNC(vkCreateCommandPool);
L2_FUNC(vkResetCommandPool);
L2_FUNC(vkAllocateCommandBuffers);
L2_FUNC(vkBeginCommandBuffer);
L2_FUNC(vkResetCommandBuffer);
L2_FUNC(vkCmdPipelineBarrier);
L2_FUNC(vkCmdClearColorImage);
L2_FUNC(vkEndCommandBuffer);
L2_FUNC(vkQueueSubmit);
L2_FUNC(vkFreeCommandBuffers);
L2_FUNC(vkDestroyCommandPool);
L2_FUNC(vkDestroySemaphore);
L2_FUNC(vkAllocateMemory);
L2_FUNC(vkBindBufferMemory);
L2_FUNC(vkBindImageMemory);
L2_FUNC(vkCmdBindIndexBuffer);
L2_FUNC(vkCmdBeginRenderPass);
L2_FUNC(vkCmdBindDescriptorSets);
L2_FUNC(vkCmdBindPipeline);
L2_FUNC(vkCmdBindVertexBuffers);
L2_FUNC(vkCmdCopyBuffer);
L2_FUNC(vkCmdCopyBufferToImage);
L2_FUNC(vkCmdDraw);
L2_FUNC(vkCmdDrawIndexed);
L2_FUNC(vkCmdEndRenderPass);
L2_FUNC(vkCmdSetScissor);
L2_FUNC(vkCmdSetViewport);
L2_FUNC(vkCreateBuffer);
L2_FUNC(vkCreateComputePipelines);
L2_FUNC(vkCreateDescriptorPool);
L2_FUNC(vkCreateDescriptorSetLayout);
L2_FUNC(vkCreateFence);
L2_FUNC(vkCreateFramebuffer);
L2_FUNC(vkCreateGraphicsPipelines);
L2_FUNC(vkCreateImage);
L2_FUNC(vkCreateImageView);
L2_FUNC(vkCreatePipelineLayout);
L2_FUNC(vkCreateRenderPass);
L2_FUNC(vkCreateSampler);
L2_FUNC(vkCreateShaderModule);
L2_FUNC(vkCreateSwapchainKHR);
L2_FUNC(vkDestroyBuffer);
L2_FUNC(vkDestroyDescriptorPool);
L2_FUNC(vkDestroyDescriptorSetLayout);
L2_FUNC(vkDestroyFence);
L2_FUNC(vkDestroyFramebuffer);
L2_FUNC(vkDestroyImage);
L2_FUNC(vkDestroyImageView);
L2_FUNC(vkDestroyPipeline);
L2_FUNC(vkDestroyPipelineLayout);
L2_FUNC(vkDestroyRenderPass);
L2_FUNC(vkDestroySampler);
L2_FUNC(vkDestroyShaderModule);
L2_FUNC(vkDestroySwapchainKHR);
L2_FUNC(vkFreeMemory);
L2_FUNC(vkGetBufferMemoryRequirements);
L2_FUNC(vkGetImageMemoryRequirements);
L2_FUNC(vkGetImageSubresourceLayout);
L2_FUNC(vkGetSwapchainImagesKHR);
L2_FUNC(vkQueuePresentKHR);
L2_FUNC(vkQueueWaitIdle);
L2_FUNC(vkResetFences);
L2_FUNC(vkUpdateDescriptorSets);
L2_FUNC(vkWaitForFences);
#undef L2_FUNC
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.