From 3d9cc076eb02909d4c4f2cfd6cad9ff100abd995 Mon Sep 17 00:00:00 2001
From: christiankerl <christian.kerl@in.tum.de>
Date: Sat, 15 Nov 2014 16:26:11 +0100
Subject: [PATCH 1/8] started to remove opencv dependency

---
 examples/protonect/CMakeLists.txt             |   6 +-
 .../src/cpu_depth_packet_processor.cpp        | 227 +++++++++++++-----
 2 files changed, 173 insertions(+), 60 deletions(-)

diff --git a/examples/protonect/CMakeLists.txt b/examples/protonect/CMakeLists.txt
index 1c29e413d..515c37e92 100644
--- a/examples/protonect/CMakeLists.txt
+++ b/examples/protonect/CMakeLists.txt
@@ -40,10 +40,10 @@ SET(LIBRARY_OUTPUT_PATH ${MY_DIR}/lib)
 FIND_PACKAGE(OpenCL)
 
 # dependencies
-FIND_PACKAGE(OpenCV REQUIRED)
+#FIND_PACKAGE(OpenCV REQUIRED)
 
 # OpenCV
-INCLUDE_DIRECTORIES(${OpenCV_INCLUDE_DIR})
+#INCLUDE_DIRECTORIES(${OpenCV_INCLUDE_DIR})
 
 # LibUSB
 INCLUDE_DIRECTORIES("${MY_DIR}/../../depends/libusb/include/libusb-1.0/")
@@ -94,7 +94,7 @@ SET(SOURCES
 
 SET(LIBRARIES
   usb-1.0
-  ${OpenCV_LIBS}
+#  ${OpenCV_LIBS}
   turbojpeg
   ${LIBFREENECT2_THREADING_LIBRARIES}
 )
diff --git a/examples/protonect/src/cpu_depth_packet_processor.cpp b/examples/protonect/src/cpu_depth_packet_processor.cpp
index 269d39811..bd854317a 100644
--- a/examples/protonect/src/cpu_depth_packet_processor.cpp
+++ b/examples/protonect/src/cpu_depth_packet_processor.cpp
@@ -37,6 +37,111 @@
 #include <math.h>
 #endif
 
+template<typename ScalarT, int Size>
+struct Vec
+{
+  ScalarT val[Size];
+};
+
+template<typename ScalarT>
+struct Mat
+{
+private:
+  bool owns_buffer;
+  unsigned char *buffer_, *buffer_end_;
+  int width, height, x_step, y_step;
+
+  void allocate(int width, int height, unsigned char *external_buffer = 0)
+  {
+    this->width = width;
+    this->height = height;
+    x_step = sizeof(ScalarT);
+    y_step = width * x_step;
+
+    owns_buffer = external_buffer != 0;
+
+    if(owns_buffer)
+    {
+      buffer_ = new unsigned char[y_step * height];
+      buffer_end_ = buffer_ + (y_step * height);
+    }
+  }
+
+  void deallocate()
+  {
+    if(owns_buffer && buffer != 0)
+    {
+      delete[] buffer_;
+      owns_buffer = false;
+      buffer_ = 0;
+      buffer_end_ = 0;
+    }
+  }
+
+public:
+  Mat()
+  {
+  }
+
+  Mat(int height, int width) : owns_buffer(false), buffer_(0)
+  {
+    create(height, width);
+  }
+
+  template<typename DataT>
+  Mat(int height, int width, DataT *external_buffer)
+  {
+    allocate(width, height, reinterpret_cast<unsigned char *>(external_buffer));
+  }
+
+  ~Mat()
+  {
+    deallocate();
+  }
+
+  void create(int height, int width)
+  {
+    deallocate();
+    allocate(width, height);
+  }
+
+  void copyTo(Mat<ScalarT> &other) const
+  {
+    other.create(height, width);
+    std::copy(buffer_, buffer_end, other.buffer_);
+  }
+
+  const ScalarT &at(int y, int x) const
+  {
+    return *ptr(y, x);
+  }
+
+  ScalarT &at(int y, int x)
+  {
+    return *ptr(y, x);
+  }
+
+  const ScalarT *ptr(int y, int x) const
+  {
+    return reinterpret_cast<const ScalarT *>(buffer_ + y_step * y + x_step * x);
+  }
+
+  ScalarT *ptr(int y, int x)
+  {
+    return reinterpret_cast<ScalarT *>(buffer_ + y_step * y + x_step * x);
+  }
+
+  unsigned char* buffer()
+  {
+    return buffer_;
+  }
+
+  int sizeInBytes() const
+  {
+    return buffer_end_ - buffer_;
+  }
+};
+
 namespace libfreenect2
 {
 
@@ -62,7 +167,8 @@ inline int bfi(int width, int offset, int src2, int src3)
 class CpuDepthPacketProcessorImpl
 {
 public:
-  cv::Mat p0_table0, p0_table1, p0_table2, x_table, z_table;
+  Mat<uint16_t> p0_table0, p0_table1, p0_table2;
+  Mat<float> x_table, z_table;
 
   int16_t lut11to16[2048];
 
@@ -190,24 +296,27 @@ class CpuDepthPacketProcessorImpl
     return lut11to16[((i1 | i2) & 2047)];
   }
 
-  void fill_trig_tables(cv::Mat& p0table, float trig_table[512*424][6])
+  void fillTrigTable(Mat<uint16_t> &p0table, float trig_table[512*424][6])
   {
-    for (int i = 0; i < 512*424; i++)
-    {
-      float p0 = -((float)p0table.at<uint16_t>(i)) * 0.000031 * M_PI;
+    int i = 0;
 
-      float tmp0 = p0 + params.phase_in_rad[0];
-      float tmp1 = p0 + params.phase_in_rad[1];
-      float tmp2 = p0 + params.phase_in_rad[2];
+    for(int y = 0; y < 424; ++y)
+      for(int x = 0; x < 512; ++x, ++i)
+      {
+        float p0 = -((float)p0table.at(y, x)) * 0.000031 * M_PI;
 
-      trig_table[i][0] = std::cos(tmp0);
-      trig_table[i][1] = std::cos(tmp1);
-      trig_table[i][2] = std::cos(tmp2);
+        float tmp0 = p0 + params.phase_in_rad[0];
+        float tmp1 = p0 + params.phase_in_rad[1];
+        float tmp2 = p0 + params.phase_in_rad[2];
 
-      trig_table[i][3] = std::sin(-tmp0);
-      trig_table[i][4] = std::sin(-tmp1);
-      trig_table[i][5] = std::sin(-tmp2);
-    }
+        trig_table[i][0] = std::cos(tmp0);
+        trig_table[i][1] = std::cos(tmp1);
+        trig_table[i][2] = std::cos(tmp2);
+
+        trig_table[i][3] = std::sin(-tmp0);
+        trig_table[i][4] = std::sin(-tmp1);
+        trig_table[i][5] = std::sin(-tmp2);
+      }
   }
 
   void processMeasurementTriple(float trig_table[512*424][6], float abMultiplierPerFrq, int x, int y, const int32_t* m, float* m_out)
@@ -221,7 +330,7 @@ class CpuDepthPacketProcessorImpl
     float sin_negtmp1 = trig_table[offset][4];
     float sin_negtmp2 = trig_table[offset][5];
 
-    float zmultiplier = z_table.at<float>(y, x);
+    float zmultiplier = z_table.at(y, x);
     bool cond0 = 0 < zmultiplier;
     bool cond1 = (m[0] == 32767 || m[1] == 32767 || m[2] == 32767) && cond0;
 
@@ -283,9 +392,9 @@ class CpuDepthPacketProcessorImpl
     processMeasurementTriple(trig_table2, params.ab_multiplier_per_frq[2], x, y, m2_raw, m2_out);
   }
 
-  void filterPixelStage1(int x, int y, const cv::Mat& m, float* m_out, bool& bilateral_max_edge_test)
+  void filterPixelStage1(int x, int y, const Mat<Vec<float, 9> >& m, float* m_out, bool& bilateral_max_edge_test)
   {
-    const float *m_ptr = m.ptr<float>(y, x);
+    const float *m_ptr = &(m.ptr(y, x)->val);
     bilateral_max_edge_test = true;
 
     if(x < 1 || y < 1 || x > 510 || y > 422)
@@ -338,7 +447,7 @@ class CpuDepthPacketProcessorImpl
               continue;
             }
 
-            const float *other_m_ptr = m.ptr<float>(y + yi, x + xi) + offset;
+            const float *other_m_ptr = &(m.ptr(y + yi, x + xi)->val) + offset;
             float other_norm2 = other_m_ptr[0] * other_m_ptr[0] + other_m_ptr[1] * other_m_ptr[1];
             // TODO: maybe fix numeric problems when norm = 0 - original code uses reciprocal square root, which returns +inf for +0
             float other_inv_norm = 1.0f / std::sqrt(other_norm2);
@@ -487,8 +596,8 @@ class CpuDepthPacketProcessorImpl
     }
 
     // this seems to be the phase to depth mapping :)
-    float zmultiplier = z_table.at<float>(y, x);
-    float xmultiplier = x_table.at<float>(y, x);
+    float zmultiplier = z_table.at(y, x);
+    float xmultiplier = x_table.at(y, x);
 
     phase = 0 < phase ? phase + params.phase_offset : phase;
 
@@ -520,9 +629,9 @@ class CpuDepthPacketProcessorImpl
     //ir_out[2] = std::min(m2[2] * ab_output_multiplier, 65535.0f);
   }
 
-  void filterPixelStage2(int x, int y, cv::Mat &m, bool max_edge_test_ok, float *depth_out)
+  void filterPixelStage2(int x, int y, Mat<Vec<float, 3> > &m, bool max_edge_test_ok, float *depth_out)
   {
-    cv::Vec3f &depth_and_ir_sum = m.at<cv::Vec3f>(y, x);
+    Vec<float, 3> &depth_and_ir_sum = m.at(y, x);
     float &raw_depth = depth_and_ir_sum.val[0], &ir_sum = depth_and_ir_sum.val[2];
 
     if(raw_depth >= params.min_depth && raw_depth <= params.max_depth)
@@ -541,7 +650,7 @@ class CpuDepthPacketProcessorImpl
           {
             if(yi == 0 && xi == 0) continue;
 
-            cv::Vec3f &other = m.at<cv::Vec3f>(y + yi, x + xi);
+            Vec<float, 3> &other = m.at(y + yi, x + xi);
 
             ir_sum_acc += other.val[2];
             squared_ir_sum_acc += other.val[2] * other.val[2];
@@ -634,37 +743,37 @@ void CpuDepthPacketProcessor::loadP0TablesFromCommandResponse(unsigned char* buf
 
   if(impl_->flip_ptables)
   {
-    cv::flip(cv::Mat(424, 512, CV_16UC1, p0table->p0table0), impl_->p0_table0, 0);
-    cv::flip(cv::Mat(424, 512, CV_16UC1, p0table->p0table1), impl_->p0_table1, 0);
-    cv::flip(cv::Mat(424, 512, CV_16UC1, p0table->p0table2), impl_->p0_table2, 0);
-
-    impl_->fill_trig_tables(impl_->p0_table0, impl_->trig_table0);
-    impl_->fill_trig_tables(impl_->p0_table1, impl_->trig_table1);
-    impl_->fill_trig_tables(impl_->p0_table2, impl_->trig_table2);
+    cv::flip(Mat<uint16_t>(424, 512, p0table->p0table0), impl_->p0_table0, 0);
+    cv::flip(Mat<uint16_t>(424, 512, p0table->p0table1), impl_->p0_table1, 0);
+    cv::flip(Mat<uint16_t>(424, 512, p0table->p0table2), impl_->p0_table2, 0);
   }
   else
   {
-    cv::Mat(424, 512, CV_16UC1, p0table->p0table0).copyTo(impl_->p0_table0);
-    cv::Mat(424, 512, CV_16UC1, p0table->p0table1).copyTo(impl_->p0_table1);
-    cv::Mat(424, 512, CV_16UC1, p0table->p0table2).copyTo(impl_->p0_table2);
+    Mat<uint16_t>(424, 512, p0table->p0table0).copyTo(impl_->p0_table0);
+    Mat<uint16_t>(424, 512, p0table->p0table1).copyTo(impl_->p0_table1);
+    Mat<uint16_t>(424, 512, p0table->p0table2).copyTo(impl_->p0_table2);
   }
+
+  impl_->fillTrigTable(impl_->p0_table0, impl_->trig_table0);
+  impl_->fillTrigTable(impl_->p0_table1, impl_->trig_table1);
+  impl_->fillTrigTable(impl_->p0_table2, impl_->trig_table2);
 }
 void CpuDepthPacketProcessor::loadP0TablesFromFiles(const char* p0_filename, const char* p1_filename, const char* p2_filename)
 {
-  cv::Mat p0_table0(424, 512, CV_16UC1);
-  if(!loadBufferFromFile2(p0_filename, p0_table0.data, p0_table0.total() * p0_table0.elemSize()))
+  Mat<uint16_t> p0_table0(424, 512);
+  if(!loadBufferFromFile2(p0_filename, p0_table0.buffer(), p0_table0.sizeInBytes()))
   {
     std::cerr << "[CpuDepthPacketProcessor::loadP0TablesFromFiles] Loading p0table 0 from '" << p0_filename << "' failed!" << std::endl;
   }
 
-  cv::Mat p0_table1(424, 512, CV_16UC1);
-  if(!loadBufferFromFile2(p1_filename, p0_table1.data, p0_table1.total() * p0_table1.elemSize()))
+  Mat<uint16_t> p0_table1(424, 512);
+  if(!loadBufferFromFile2(p1_filename, p0_table1.buffer(), p0_table1.sizeInBytes()))
   {
     std::cerr << "[CpuDepthPacketProcessor::loadP0TablesFromFiles] Loading p0table 1 from '" << p1_filename << "' failed!" << std::endl;
   }
 
-  cv::Mat p0_table2(424, 512, CV_16UC1);
-  if(!loadBufferFromFile2(p2_filename, p0_table2.data, p0_table2.total() * p0_table2.elemSize()))
+  Mat<uint16_t> p0_table2(424, 512);
+  if(!loadBufferFromFile2(p2_filename, p0_table2.buffer(), p0_table2.sizeInBytes()))
   {
     std::cerr << "[CpuDepthPacketProcessor::loadP0TablesFromFiles] Loading p0table 2 from '" << p2_filename << "' failed!" << std::endl;
   }
@@ -675,27 +784,27 @@ void CpuDepthPacketProcessor::loadP0TablesFromFiles(const char* p0_filename, con
     cv::flip(p0_table1, impl_->p0_table1, 0);
     cv::flip(p0_table2, impl_->p0_table2, 0);
 
-    impl_->fill_trig_tables(impl_->p0_table0, impl_->trig_table0);
-    impl_->fill_trig_tables(impl_->p0_table1, impl_->trig_table1);
-    impl_->fill_trig_tables(impl_->p0_table2, impl_->trig_table2);
+    impl_->fillTrigTable(impl_->p0_table0, impl_->trig_table0);
+    impl_->fillTrigTable(impl_->p0_table1, impl_->trig_table1);
+    impl_->fillTrigTable(impl_->p0_table2, impl_->trig_table2);
   }
   else
   {
-    impl_->fill_trig_tables(p0_table0, impl_->trig_table0);
-    impl_->fill_trig_tables(p0_table1, impl_->trig_table1);
-    impl_->fill_trig_tables(p0_table2, impl_->trig_table2);
+    impl_->fillTrigTable(p0_table0, impl_->trig_table0);
+    impl_->fillTrigTable(p0_table1, impl_->trig_table1);
+    impl_->fillTrigTable(p0_table2, impl_->trig_table2);
   }
 }
 
 void CpuDepthPacketProcessor::loadXTableFromFile(const char* filename)
 {
-  impl_->x_table.create(424, 512, CV_32FC1);
+  impl_->x_table.create(424, 512);
   const unsigned char *data;
   size_t length;
 
   if(loadResource("xTable.bin", &data, &length))
   {
-    std::copy(data, data + length, impl_->x_table.data);
+    std::copy(data, data + length, impl_->x_table.buffer());
   }
   else
   {
@@ -705,14 +814,14 @@ void CpuDepthPacketProcessor::loadXTableFromFile(const char* filename)
 
 void CpuDepthPacketProcessor::loadZTableFromFile(const char* filename)
 {
-  impl_->z_table.create(424, 512, CV_32FC1);
+  impl_->z_table.create(424, 512);
 
   const unsigned char *data;
   size_t length;
 
   if(loadResource("zTable.bin", &data, &length))
   {
-    std::copy(data, data + length, impl_->z_table.data);
+    std::copy(data, data + length, impl_->z_table.buffer());
   }
   else
   {
@@ -741,9 +850,13 @@ void CpuDepthPacketProcessor::process(const DepthPacket &packet)
 
   impl_->startTiming();
 
-  cv::Mat m = cv::Mat::zeros(424, 512, CV_32FC(9)), m_filtered = cv::Mat::zeros(424, 512, CV_32FC(9)), m_max_edge_test = cv::Mat::ones(424, 512, CV_8UC1);
+  Mat<Vec<float, 9> >
+      m(424, 512),
+      m_filtered(424, 512)
+  ;
+  Mat<unsigned char> m_max_edge_test(424, 512);
 
-  float *m_ptr = m.ptr<float>();
+  float *m_ptr = &(m.ptr(0, 0)->val);
 
   for(int y = 0; y < 424; ++y)
     for(int x = 0; x < 512; ++x, m_ptr += 9)
@@ -754,8 +867,8 @@ void CpuDepthPacketProcessor::process(const DepthPacket &packet)
   // bilateral filtering
   if(impl_->enable_bilateral_filter)
   {
-    float *m_filtered_ptr = m_filtered.ptr<float>();
-    unsigned char *m_max_edge_test_ptr = m_max_edge_test.ptr<unsigned char>();
+    float *m_filtered_ptr = &(m_filtered.ptr(0, 0)->val);
+    unsigned char *m_max_edge_test_ptr = m_max_edge_test.ptr(0, 0);
 
     for(int y = 0; y < 424; ++y)
       for(int x = 0; x < 512; ++x, m_filtered_ptr += 9, ++m_max_edge_test_ptr)
@@ -765,11 +878,11 @@ void CpuDepthPacketProcessor::process(const DepthPacket &packet)
         *m_max_edge_test_ptr = max_edge_test_val ? 1 : 0;
       }
 
-    m_ptr = m_filtered.ptr<float>();
+    m_ptr = &(m_filtered.ptr(0, 0)->val);
   }
   else
   {
-    m_ptr = m.ptr<float>();
+    m_ptr = &(m.ptr(0, 0)->val);
   }
 
   cv::Mat out_ir(424, 512, CV_32FC1, impl_->ir_frame->data), out_depth(424, 512, CV_32FC1, impl_->depth_frame->data);
@@ -778,7 +891,7 @@ void CpuDepthPacketProcessor::process(const DepthPacket &packet)
   {
     cv::Mat depth_ir_sum(424, 512, CV_32FC3);
     cv::Vec3f *depth_ir_sum_ptr = depth_ir_sum.ptr<cv::Vec3f>();
-    unsigned char *m_max_edge_test_ptr = m_max_edge_test.ptr<unsigned char>();
+    unsigned char *m_max_edge_test_ptr = m_max_edge_test.ptr(0, 0);
 
     for(int y = 0; y < 424; ++y)
       for(int x = 0; x < 512; ++x, m_ptr += 9, ++m_max_edge_test_ptr, ++depth_ir_sum_ptr)

From c38d3a003fd95174e0bd693686ced48823a16fbc Mon Sep 17 00:00:00 2001
From: christiankerl <christian.kerl@in.tum.de>
Date: Sat, 15 Nov 2014 18:43:29 +0100
Subject: [PATCH 2/8] removed most of the opencv dependencies

---
 examples/protonect/CMakeLists.txt             |  6 +-
 .../src/cpu_depth_packet_processor.cpp        | 89 +++++++++++++------
 .../src/opencl_depth_packet_processor.cpp     |  6 +-
 .../src/turbo_jpeg_rgb_packet_processor.cpp   |  7 +-
 4 files changed, 68 insertions(+), 40 deletions(-)

diff --git a/examples/protonect/CMakeLists.txt b/examples/protonect/CMakeLists.txt
index 515c37e92..983465b13 100644
--- a/examples/protonect/CMakeLists.txt
+++ b/examples/protonect/CMakeLists.txt
@@ -40,10 +40,7 @@ SET(LIBRARY_OUTPUT_PATH ${MY_DIR}/lib)
 FIND_PACKAGE(OpenCL)
 
 # dependencies
-#FIND_PACKAGE(OpenCV REQUIRED)
-
-# OpenCV
-#INCLUDE_DIRECTORIES(${OpenCV_INCLUDE_DIR})
+FIND_PACKAGE(OpenCV)
 
 # LibUSB
 INCLUDE_DIRECTORIES("${MY_DIR}/../../depends/libusb/include/libusb-1.0/")
@@ -94,7 +91,6 @@ SET(SOURCES
 
 SET(LIBRARIES
   usb-1.0
-#  ${OpenCV_LIBS}
   turbojpeg
   ${LIBFREENECT2_THREADING_LIBRARIES}
 )
diff --git a/examples/protonect/src/cpu_depth_packet_processor.cpp b/examples/protonect/src/cpu_depth_packet_processor.cpp
index bd854317a..362ee9a17 100644
--- a/examples/protonect/src/cpu_depth_packet_processor.cpp
+++ b/examples/protonect/src/cpu_depth_packet_processor.cpp
@@ -28,7 +28,6 @@
 #include <libfreenect2/resource.h>
 #include <libfreenect2/protocol/response.h>
 
-#include <opencv2/opencv.hpp>
 #include <iostream>
 #include <fstream>
 
@@ -49,12 +48,12 @@ struct Mat
 private:
   bool owns_buffer;
   unsigned char *buffer_, *buffer_end_;
-  int width, height, x_step, y_step;
+  int width_, height_, x_step, y_step;
 
   void allocate(int width, int height, unsigned char *external_buffer = 0)
   {
-    this->width = width;
-    this->height = height;
+    this->width_ = width;
+    this->height_ = height;
     x_step = sizeof(ScalarT);
     y_step = width * x_step;
 
@@ -69,7 +68,7 @@ struct Mat
 
   void deallocate()
   {
-    if(owns_buffer && buffer != 0)
+    if(owns_buffer && buffer_ != 0)
     {
       delete[] buffer_;
       owns_buffer = false;
@@ -99,6 +98,16 @@ struct Mat
     deallocate();
   }
 
+  int width() const
+  {
+    return width_;
+  }
+  
+  int height() const
+  {
+    return height_;
+  }
+
   void create(int height, int width)
   {
     deallocate();
@@ -107,8 +116,8 @@ struct Mat
 
   void copyTo(Mat<ScalarT> &other) const
   {
-    other.create(height, width);
-    std::copy(buffer_, buffer_end, other.buffer_);
+    other.create(height(), width());
+    std::copy(buffer_, buffer_end_, other.buffer_);
   }
 
   const ScalarT &at(int y, int x) const
@@ -142,6 +151,27 @@ struct Mat
   }
 };
 
+template<typename ScalarT>
+void flipHorizontal(const Mat<ScalarT> &in, Mat<ScalarT>& out)
+{
+  in.copyTo(out);
+  
+  typedef unsigned char type;
+
+  int linestep = out.sizeInBytes() / out.height() / sizeof(type);
+
+  type *first_line = reinterpret_cast<type *>(out.buffer()), *last_line = reinterpret_cast<type *>(out.buffer()) + (out.height() - 1) * linestep;
+
+  for(int y = 0; y < out.height() / 2; ++y)
+  {
+    for(int x = 0; x < linestep; ++x, ++first_line, ++last_line)
+    {
+      std::swap(*first_line, *last_line);
+    }
+    last_line -= 2 * linestep;
+  }
+}
+
 namespace libfreenect2
 {
 
@@ -205,12 +235,12 @@ class CpuDepthPacketProcessorImpl
 
   void startTiming()
   {
-    timing_current_start = cv::getTickCount();
+    //timing_current_start = cv::getTickCount();
   }
 
   void stopTiming()
   {
-    timing_acc += (cv::getTickCount() - timing_current_start) / cv::getTickFrequency();
+    //timing_acc += (cv::getTickCount() - timing_current_start) / cv::getTickFrequency();
     timing_acc_n += 1.0;
 
     if(timing_acc_n >= 100.0)
@@ -394,7 +424,7 @@ class CpuDepthPacketProcessorImpl
 
   void filterPixelStage1(int x, int y, const Mat<Vec<float, 9> >& m, float* m_out, bool& bilateral_max_edge_test)
   {
-    const float *m_ptr = &(m.ptr(y, x)->val);
+    const float *m_ptr = (m.ptr(y, x)->val);
     bilateral_max_edge_test = true;
 
     if(x < 1 || y < 1 || x > 510 || y > 422)
@@ -447,7 +477,7 @@ class CpuDepthPacketProcessorImpl
               continue;
             }
 
-            const float *other_m_ptr = &(m.ptr(y + yi, x + xi)->val) + offset;
+            const float *other_m_ptr = (m.ptr(y + yi, x + xi)->val) + offset;
             float other_norm2 = other_m_ptr[0] * other_m_ptr[0] + other_m_ptr[1] * other_m_ptr[1];
             // TODO: maybe fix numeric problems when norm = 0 - original code uses reciprocal square root, which returns +inf for +0
             float other_inv_norm = 1.0f / std::sqrt(other_norm2);
@@ -743,13 +773,14 @@ void CpuDepthPacketProcessor::loadP0TablesFromCommandResponse(unsigned char* buf
 
   if(impl_->flip_ptables)
   {
-    cv::flip(Mat<uint16_t>(424, 512, p0table->p0table0), impl_->p0_table0, 0);
-    cv::flip(Mat<uint16_t>(424, 512, p0table->p0table1), impl_->p0_table1, 0);
-    cv::flip(Mat<uint16_t>(424, 512, p0table->p0table2), impl_->p0_table2, 0);
+    flipHorizontal(Mat<uint16_t>(424, 512, p0table->p0table0), impl_->p0_table0);
+    flipHorizontal(Mat<uint16_t>(424, 512, p0table->p0table1), impl_->p0_table1);
+    flipHorizontal(Mat<uint16_t>(424, 512, p0table->p0table2), impl_->p0_table2);
   }
   else
   {
-    Mat<uint16_t>(424, 512, p0table->p0table0).copyTo(impl_->p0_table0);
+    Mat<uint16_t> p00(424, 512, p0table->p0table0);
+    p00.copyTo(impl_->p0_table0);
     Mat<uint16_t>(424, 512, p0table->p0table1).copyTo(impl_->p0_table1);
     Mat<uint16_t>(424, 512, p0table->p0table2).copyTo(impl_->p0_table2);
   }
@@ -780,9 +811,9 @@ void CpuDepthPacketProcessor::loadP0TablesFromFiles(const char* p0_filename, con
 
   if(impl_->flip_ptables)
   {
-    cv::flip(p0_table0, impl_->p0_table0, 0);
-    cv::flip(p0_table1, impl_->p0_table1, 0);
-    cv::flip(p0_table2, impl_->p0_table2, 0);
+    flipHorizontal(p0_table0, impl_->p0_table0);
+    flipHorizontal(p0_table1, impl_->p0_table1);
+    flipHorizontal(p0_table2, impl_->p0_table2);
 
     impl_->fillTrigTable(impl_->p0_table0, impl_->trig_table0);
     impl_->fillTrigTable(impl_->p0_table1, impl_->trig_table1);
@@ -856,7 +887,7 @@ void CpuDepthPacketProcessor::process(const DepthPacket &packet)
   ;
   Mat<unsigned char> m_max_edge_test(424, 512);
 
-  float *m_ptr = &(m.ptr(0, 0)->val);
+  float *m_ptr = (m.ptr(0, 0)->val);
 
   for(int y = 0; y < 424; ++y)
     for(int x = 0; x < 512; ++x, m_ptr += 9)
@@ -867,7 +898,7 @@ void CpuDepthPacketProcessor::process(const DepthPacket &packet)
   // bilateral filtering
   if(impl_->enable_bilateral_filter)
   {
-    float *m_filtered_ptr = &(m_filtered.ptr(0, 0)->val);
+    float *m_filtered_ptr = (m_filtered.ptr(0, 0)->val);
     unsigned char *m_max_edge_test_ptr = m_max_edge_test.ptr(0, 0);
 
     for(int y = 0; y < 424; ++y)
@@ -878,19 +909,19 @@ void CpuDepthPacketProcessor::process(const DepthPacket &packet)
         *m_max_edge_test_ptr = max_edge_test_val ? 1 : 0;
       }
 
-    m_ptr = &(m_filtered.ptr(0, 0)->val);
+    m_ptr = (m_filtered.ptr(0, 0)->val);
   }
   else
   {
-    m_ptr = &(m.ptr(0, 0)->val);
+    m_ptr = (m.ptr(0, 0)->val);
   }
 
-  cv::Mat out_ir(424, 512, CV_32FC1, impl_->ir_frame->data), out_depth(424, 512, CV_32FC1, impl_->depth_frame->data);
+  Mat<float> out_ir(424, 512, impl_->ir_frame->data), out_depth(424, 512, impl_->depth_frame->data);
 
   if(impl_->enable_edge_filter)
   {
-    cv::Mat depth_ir_sum(424, 512, CV_32FC3);
-    cv::Vec3f *depth_ir_sum_ptr = depth_ir_sum.ptr<cv::Vec3f>();
+    Mat<Vec<float, 3> > depth_ir_sum(424, 512);
+    Vec<float, 3> *depth_ir_sum_ptr = depth_ir_sum.ptr(0, 0);
     unsigned char *m_max_edge_test_ptr = m_max_edge_test.ptr(0, 0);
 
     for(int y = 0; y < 424; ++y)
@@ -898,19 +929,19 @@ void CpuDepthPacketProcessor::process(const DepthPacket &packet)
       {
         float raw_depth, ir_sum;
 
-        impl_->processPixelStage2(x, y, m_ptr + 0, m_ptr + 3, m_ptr + 6, out_ir.ptr<float>(423 - y, x), &raw_depth, &ir_sum);
+        impl_->processPixelStage2(x, y, m_ptr + 0, m_ptr + 3, m_ptr + 6, out_ir.ptr(423 - y, x), &raw_depth, &ir_sum);
 
         depth_ir_sum_ptr->val[0] = raw_depth;
         depth_ir_sum_ptr->val[1] = *m_max_edge_test_ptr == 1 ? raw_depth : 0;
         depth_ir_sum_ptr->val[2] = ir_sum;
       }
 
-    m_max_edge_test_ptr = m_max_edge_test.ptr<unsigned char>();
+    m_max_edge_test_ptr = m_max_edge_test.ptr(0, 0);
 
     for(int y = 0; y < 424; ++y)
       for(int x = 0; x < 512; ++x, ++m_max_edge_test_ptr)
       {
-        impl_->filterPixelStage2(x, y, depth_ir_sum, *m_max_edge_test_ptr == 1, out_depth.ptr<float>(423 - y, x));
+        impl_->filterPixelStage2(x, y, depth_ir_sum, *m_max_edge_test_ptr == 1, out_depth.ptr(423 - y, x));
       }
   }
   else
@@ -918,7 +949,7 @@ void CpuDepthPacketProcessor::process(const DepthPacket &packet)
     for(int y = 0; y < 424; ++y)
       for(int x = 0; x < 512; ++x, m_ptr += 9)
       {
-        impl_->processPixelStage2(x, y, m_ptr + 0, m_ptr + 3, m_ptr + 6, out_ir.ptr<float>(423 - y, x), out_depth.ptr<float>(423 - y, x), 0);
+        impl_->processPixelStage2(x, y, m_ptr + 0, m_ptr + 3, m_ptr + 6, out_ir.ptr(423 - y, x), out_depth.ptr(423 - y, x), 0);
       }
   }
 
diff --git a/examples/protonect/src/opencl_depth_packet_processor.cpp b/examples/protonect/src/opencl_depth_packet_processor.cpp
index edda413af..7c1970804 100644
--- a/examples/protonect/src/opencl_depth_packet_processor.cpp
+++ b/examples/protonect/src/opencl_depth_packet_processor.cpp
@@ -28,7 +28,7 @@
 #include <libfreenect2/resource.h>
 #include <libfreenect2/protocol/response.h>
 
-#include <opencv2/opencv.hpp>
+//#include <opencv2/opencv.hpp>
 #include <iostream>
 #include <fstream>
 #include <sstream>
@@ -538,12 +538,12 @@ class OpenCLDepthPacketProcessorImpl
 
   void startTiming()
   {
-    timing_current_start = cv::getTickCount();
+    //timing_current_start = cv::getTickCount();
   }
 
   void stopTiming()
   {
-    timing_acc += (cv::getTickCount() - timing_current_start) / cv::getTickFrequency();
+    //timing_acc += (cv::getTickCount() - timing_current_start) / cv::getTickFrequency();
     timing_acc_n += 1.0;
 
     if(timing_acc_n >= 100.0)
diff --git a/examples/protonect/src/turbo_jpeg_rgb_packet_processor.cpp b/examples/protonect/src/turbo_jpeg_rgb_packet_processor.cpp
index 88f650c2b..201edf2ad 100644
--- a/examples/protonect/src/turbo_jpeg_rgb_packet_processor.cpp
+++ b/examples/protonect/src/turbo_jpeg_rgb_packet_processor.cpp
@@ -26,8 +26,9 @@
 
 #include <libfreenect2/rgb_packet_processor.h>
 
-#include <opencv2/opencv.hpp>
+//#include <opencv2/opencv.hpp>
 #include <turbojpeg.h>
+#include <iostream>
 
 namespace libfreenect2
 {
@@ -78,12 +79,12 @@ class TurboJpegRgbPacketProcessorImpl
 
   void startTiming()
   {
-    timing_current_start = cv::getTickCount();
+    //timing_current_start = cv::getTickCount();
   }
 
   void stopTiming()
   {
-    timing_acc += (cv::getTickCount() - timing_current_start) / cv::getTickFrequency();
+    //timing_acc += (cv::getTickCount() - timing_current_start) / cv::getTickFrequency();
     timing_acc_n += 1.0;
 
     if(timing_acc_n >= 100.0)

From 4d61f57e790da5476f5f7ce7072c152358d20417 Mon Sep 17 00:00:00 2001
From: christiankerl <christian.kerl@in.tum.de>
Date: Mon, 2 Feb 2015 14:12:18 +0100
Subject: [PATCH 3/8] fixed compilation; fixed segfaults in
 CpuDepthPacketProcessor; disabled timing

---
 examples/protonect/Protonect.cpp                 | 13 +++++++------
 .../protonect/src/cpu_depth_packet_processor.cpp | 16 ++++++++++++----
 .../src/turbo_jpeg_rgb_packet_processor.cpp      |  4 ++--
 3 files changed, 21 insertions(+), 12 deletions(-)

diff --git a/examples/protonect/Protonect.cpp b/examples/protonect/Protonect.cpp
index baac87cd5..b0199721a 100644
--- a/examples/protonect/Protonect.cpp
+++ b/examples/protonect/Protonect.cpp
@@ -28,11 +28,12 @@
 #include <iostream>
 #include <signal.h>
 
-#include <opencv2/opencv.hpp>
+//#include <opencv2/opencv.hpp>
 
 #include <libfreenect2/libfreenect2.hpp>
 #include <libfreenect2/frame_listener_impl.h>
 #include <libfreenect2/threading.h>
+#include <libfreenect2/packet_pipeline.h>
 
 bool protonect_shutdown = false;
 
@@ -55,7 +56,7 @@ int main(int argc, char *argv[])
 
 
   libfreenect2::Freenect2 freenect2;
-  libfreenect2::Freenect2Device *dev = freenect2.openDefaultDevice();
+  libfreenect2::Freenect2Device *dev = freenect2.openDefaultDevice(new libfreenect2::CpuPacketPipeline());
 
   if(dev == 0)
   {
@@ -83,11 +84,11 @@ int main(int argc, char *argv[])
     libfreenect2::Frame *ir = frames[libfreenect2::Frame::Ir];
     libfreenect2::Frame *depth = frames[libfreenect2::Frame::Depth];
 
-    cv::imshow("rgb", cv::Mat(rgb->height, rgb->width, CV_8UC3, rgb->data));
-    cv::imshow("ir", cv::Mat(ir->height, ir->width, CV_32FC1, ir->data) / 20000.0f);
-    cv::imshow("depth", cv::Mat(depth->height, depth->width, CV_32FC1, depth->data) / 4500.0f);
+    //cv::imshow("rgb", cv::Mat(rgb->height, rgb->width, CV_8UC3, rgb->data));
+    //cv::imshow("ir", cv::Mat(ir->height, ir->width, CV_32FC1, ir->data) / 20000.0f);
+    //cv::imshow("depth", cv::Mat(depth->height, depth->width, CV_32FC1, depth->data) / 4500.0f);
 
-    int key = cv::waitKey(1);
+    int key = 1;//cv::waitKey(1);
     protonect_shutdown = protonect_shutdown || (key > 0 && ((key & 0xFF) == 27)); // shutdown on escape
 
     listener.release(frames);
diff --git a/examples/protonect/src/cpu_depth_packet_processor.cpp b/examples/protonect/src/cpu_depth_packet_processor.cpp
index 362ee9a17..e9def2565 100644
--- a/examples/protonect/src/cpu_depth_packet_processor.cpp
+++ b/examples/protonect/src/cpu_depth_packet_processor.cpp
@@ -36,6 +36,9 @@
 #include <math.h>
 #endif
 
+#include <cmath>
+#include <limits>
+
 template<typename ScalarT, int Size>
 struct Vec
 {
@@ -57,13 +60,17 @@ struct Mat
     x_step = sizeof(ScalarT);
     y_step = width * x_step;
 
-    owns_buffer = external_buffer != 0;
+    owns_buffer = external_buffer == 0;
 
     if(owns_buffer)
     {
       buffer_ = new unsigned char[y_step * height];
-      buffer_end_ = buffer_ + (y_step * height);
     }
+    else
+    {
+      buffer_ = external_buffer;
+    }
+    buffer_end_ = buffer_ + (y_step * height);
   }
 
   void deallocate()
@@ -162,6 +169,7 @@ void flipHorizontal(const Mat<ScalarT> &in, Mat<ScalarT>& out)
 
   type *first_line = reinterpret_cast<type *>(out.buffer()), *last_line = reinterpret_cast<type *>(out.buffer()) + (out.height() - 1) * linestep;
 
+
   for(int y = 0; y < out.height() / 2; ++y)
   {
     for(int x = 0; x < linestep; ++x, ++first_line, ++last_line)
@@ -879,7 +887,7 @@ void CpuDepthPacketProcessor::process(const DepthPacket &packet)
 {
   if(listener_ == 0) return;
 
-  impl_->startTiming();
+  //impl_->startTiming();
 
   Mat<Vec<float, 9> >
       m(424, 512),
@@ -963,7 +971,7 @@ void CpuDepthPacketProcessor::process(const DepthPacket &packet)
     impl_->newDepthFrame();
   }
 
-  impl_->stopTiming();
+  //impl_->stopTiming();
 }
 
 } /* namespace libfreenect2 */
diff --git a/examples/protonect/src/turbo_jpeg_rgb_packet_processor.cpp b/examples/protonect/src/turbo_jpeg_rgb_packet_processor.cpp
index 201edf2ad..d08256119 100644
--- a/examples/protonect/src/turbo_jpeg_rgb_packet_processor.cpp
+++ b/examples/protonect/src/turbo_jpeg_rgb_packet_processor.cpp
@@ -111,7 +111,7 @@ void TurboJpegRgbPacketProcessor::process(const RgbPacket &packet)
 {
   if(impl_->decompressor != 0 && listener_ != 0)
   {
-    impl_->startTiming();
+    //impl_->startTiming();
 
     int r = tjDecompress2(impl_->decompressor, packet.jpeg_buffer, packet.jpeg_buffer_length, impl_->frame->data, 1920, 1920 * tjPixelSize[TJPF_BGR], 1080, TJPF_BGR, 0);
 
@@ -127,7 +127,7 @@ void TurboJpegRgbPacketProcessor::process(const RgbPacket &packet)
       std::cerr << "[TurboJpegRgbPacketProcessor::doProcess] Failed to decompress rgb image! TurboJPEG error: '" << tjGetErrorStr() << "'" << std::endl;
     }
 
-    impl_->stopTiming();
+    //impl_->stopTiming();
   }
 }
 

From f3b33c08ba5f0328810aa6a726662f7555484ef7 Mon Sep 17 00:00:00 2001
From: larshg <larshg@gmail.com>
Date: Mon, 15 Jun 2015 19:33:28 +0200
Subject: [PATCH 4/8] Added viewer to Protonect

---
 examples/protonect/CMakeLists.txt           |   18 +-
 examples/protonect/Protonect.cpp            |   17 +-
 examples/protonect/flextGL.c                |  367 ++++
 examples/protonect/flextGL.h                | 1664 +++++++++++++++++++
 examples/protonect/src/shader/grayrender.fs |   20 +
 examples/protonect/src/shader/render.fs     |   16 +
 examples/protonect/src/shader/render.vs     |   14 +
 examples/protonect/viewer.cpp               |  196 +++
 examples/protonect/viewer.h                 |  289 ++++
 9 files changed, 2594 insertions(+), 7 deletions(-)
 create mode 100644 examples/protonect/flextGL.c
 create mode 100644 examples/protonect/flextGL.h
 create mode 100644 examples/protonect/src/shader/grayrender.fs
 create mode 100644 examples/protonect/src/shader/render.fs
 create mode 100644 examples/protonect/src/shader/render.vs
 create mode 100644 examples/protonect/viewer.cpp
 create mode 100644 examples/protonect/viewer.h

diff --git a/examples/protonect/CMakeLists.txt b/examples/protonect/CMakeLists.txt
index b56c89c49..cc8a1ae1a 100644
--- a/examples/protonect/CMakeLists.txt
+++ b/examples/protonect/CMakeLists.txt
@@ -140,6 +140,9 @@ IF(ENABLE_OPENGL)
     src/shader/filter2.fs
     src/shader/stage1.fs
     src/shader/stage2.fs
+    src/shader/render.fs
+    src/shader/grayrender.fs
+    src/shader/render.vs
   )
   ENDIF()
 ENDIF(ENABLE_OPENGL)
@@ -183,8 +186,21 @@ ENDIF()
 MESSAGE("Linking with these libraries: ${LIBRARIES}")
 TARGET_LINK_LIBRARIES(freenect2shared ${LIBRARIES})
   
+SET(Protonect_src
+    Protonect.cpp
+    )
+    
+IF (ENABLE_OPENGL AND OPENGL_FOUND)
+    LIST(APPEND Protonect_src
+        viewer.h
+        viewer.cpp
+        flextGL.c
+        )
+ENDIF()
+  
 ADD_EXECUTABLE(Protonect
-  Protonect.cpp
+  ${Protonect_src}
+
 )
   
 TARGET_LINK_LIBRARIES(Protonect
diff --git a/examples/protonect/Protonect.cpp b/examples/protonect/Protonect.cpp
index 3308fd0f7..5d2a66312 100644
--- a/examples/protonect/Protonect.cpp
+++ b/examples/protonect/Protonect.cpp
@@ -35,6 +35,7 @@
 #include <libfreenect2/threading.h>
 #include <libfreenect2/registration.h>
 #include <libfreenect2/packet_pipeline.h>
+#include "viewer.h"
 
 bool protonect_shutdown = false;
 
@@ -135,6 +136,9 @@ int main(int argc, char *argv[])
 
   libfreenect2::Registration* registration = new libfreenect2::Registration(dev->getIrCameraParams(), dev->getColorCameraParams());
 
+  Viewer viewer;
+  viewer.initialize();
+
   while(!protonect_shutdown)
   {
     listener.waitForNewFrame(frames);
@@ -142,14 +146,15 @@ int main(int argc, char *argv[])
     libfreenect2::Frame *ir = frames[libfreenect2::Frame::Ir];
     libfreenect2::Frame *depth = frames[libfreenect2::Frame::Depth];
 
-    cv::imshow("rgb", cv::Mat(rgb->height, rgb->width, CV_8UC4, rgb->data));
-    cv::imshow("ir", cv::Mat(ir->height, ir->width, CV_32FC1, ir->data) / 20000.0f);
-    cv::imshow("depth", cv::Mat(depth->height, depth->width, CV_32FC1, depth->data) / 4500.0f);
+    registration->apply(rgb, depth, &undistorted, &registered);
 
-    registration->apply(rgb,depth,&undistorted,&registered);
+    viewer.AddFrame("RGB", rgb);
+    viewer.AddFrame("ir", ir);
+    viewer.AddFrame("depth", depth);
+    viewer.AddFrame("registered", &registered);
 
-    cv::imshow("undistorted", cv::Mat(undistorted.height, undistorted.width, CV_32FC1, undistorted.data) / 4500.0f);
-    cv::imshow("registered", cv::Mat(registered.height, registered.width, CV_8UC4, registered.data));
+    if (viewer.render())
+        break;
 
     int key = cv::waitKey(1);
     protonect_shutdown = protonect_shutdown || (key > 0 && ((key & 0xFF) == 27)); // shutdown on escape
diff --git a/examples/protonect/flextGL.c b/examples/protonect/flextGL.c
new file mode 100644
index 000000000..a462628b3
--- /dev/null
+++ b/examples/protonect/flextGL.c
@@ -0,0 +1,367 @@
+/* WARNING: This file was automatically generated */
+/* Do not edit. */
+
+#include "flextGL.h"
+#include "GLFW/glfw3.h"
+
+#include <stdio.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+void flextLoadOpenGLFunctions(OpenGLBindings *bindings);
+
+int flextInit(GLFWwindow* window, OpenGLBindings *bindings)
+{
+  
+    int major = glfwGetWindowAttrib(window, GLFW_CONTEXT_VERSION_MAJOR);
+    int minor = glfwGetWindowAttrib(window, GLFW_CONTEXT_VERSION_MINOR);
+
+    flextLoadOpenGLFunctions(bindings);
+    
+    /* --- Check for minimal version and profile --- */
+
+    if (major * 10 + minor < 33) {
+        fprintf(stderr, "Error: OpenGL version 3.3 not supported.\n");
+        fprintf(stderr, "       Your version is %d.%d.\n", major, minor);
+        fprintf(stderr, "       Try updating your graphics driver.\n");
+        return GL_FALSE;
+    }
+
+
+    /* --- Check for extensions --- */
+
+
+    return GL_TRUE;
+}
+
+
+
+void flextLoadOpenGLFunctions(OpenGLBindings *bindings)
+{
+    /* --- Function pointer loading --- */
+
+
+    /* GL_VERSION_1_2 */
+
+    bindings->glDrawRangeElements = (PFNGLDRAWRANGEELEMENTS_PROC*)glfwGetProcAddress("glDrawRangeElements");
+    bindings->glTexImage3D = (PFNGLTEXIMAGE3D_PROC*)glfwGetProcAddress("glTexImage3D");
+    bindings->glTexSubImage3D = (PFNGLTEXSUBIMAGE3D_PROC*)glfwGetProcAddress("glTexSubImage3D");
+    bindings->glCopyTexSubImage3D = (PFNGLCOPYTEXSUBIMAGE3D_PROC*)glfwGetProcAddress("glCopyTexSubImage3D");
+
+    /* GL_VERSION_1_3 */
+
+    bindings->glActiveTexture = (PFNGLACTIVETEXTURE_PROC*)glfwGetProcAddress("glActiveTexture");
+    bindings->glSampleCoverage = (PFNGLSAMPLECOVERAGE_PROC*)glfwGetProcAddress("glSampleCoverage");
+    bindings->glCompressedTexImage3D = (PFNGLCOMPRESSEDTEXIMAGE3D_PROC*)glfwGetProcAddress("glCompressedTexImage3D");
+    bindings->glCompressedTexImage2D = (PFNGLCOMPRESSEDTEXIMAGE2D_PROC*)glfwGetProcAddress("glCompressedTexImage2D");
+    bindings->glCompressedTexImage1D = (PFNGLCOMPRESSEDTEXIMAGE1D_PROC*)glfwGetProcAddress("glCompressedTexImage1D");
+    bindings->glCompressedTexSubImage3D = (PFNGLCOMPRESSEDTEXSUBIMAGE3D_PROC*)glfwGetProcAddress("glCompressedTexSubImage3D");
+    bindings->glCompressedTexSubImage2D = (PFNGLCOMPRESSEDTEXSUBIMAGE2D_PROC*)glfwGetProcAddress("glCompressedTexSubImage2D");
+    bindings->glCompressedTexSubImage1D = (PFNGLCOMPRESSEDTEXSUBIMAGE1D_PROC*)glfwGetProcAddress("glCompressedTexSubImage1D");
+    bindings->glGetCompressedTexImage = (PFNGLGETCOMPRESSEDTEXIMAGE_PROC*)glfwGetProcAddress("glGetCompressedTexImage");
+
+    /* GL_VERSION_1_4 */
+
+    bindings->glBlendFuncSeparate = (PFNGLBLENDFUNCSEPARATE_PROC*)glfwGetProcAddress("glBlendFuncSeparate");
+    bindings->glMultiDrawArrays = (PFNGLMULTIDRAWARRAYS_PROC*)glfwGetProcAddress("glMultiDrawArrays");
+    bindings->glMultiDrawElements = (PFNGLMULTIDRAWELEMENTS_PROC*)glfwGetProcAddress("glMultiDrawElements");
+    bindings->glPointParameterf = (PFNGLPOINTPARAMETERF_PROC*)glfwGetProcAddress("glPointParameterf");
+    bindings->glPointParameterfv = (PFNGLPOINTPARAMETERFV_PROC*)glfwGetProcAddress("glPointParameterfv");
+    bindings->glPointParameteri = (PFNGLPOINTPARAMETERI_PROC*)glfwGetProcAddress("glPointParameteri");
+    bindings->glPointParameteriv = (PFNGLPOINTPARAMETERIV_PROC*)glfwGetProcAddress("glPointParameteriv");
+    bindings->glBlendColor = (PFNGLBLENDCOLOR_PROC*)glfwGetProcAddress("glBlendColor");
+    bindings->glBlendEquation = (PFNGLBLENDEQUATION_PROC*)glfwGetProcAddress("glBlendEquation");
+
+    /* GL_VERSION_1_5 */
+
+    bindings->glGenQueries = (PFNGLGENQUERIES_PROC*)glfwGetProcAddress("glGenQueries");
+    bindings->glDeleteQueries = (PFNGLDELETEQUERIES_PROC*)glfwGetProcAddress("glDeleteQueries");
+    bindings->glIsQuery = (PFNGLISQUERY_PROC*)glfwGetProcAddress("glIsQuery");
+    bindings->glBeginQuery = (PFNGLBEGINQUERY_PROC*)glfwGetProcAddress("glBeginQuery");
+    bindings->glEndQuery = (PFNGLENDQUERY_PROC*)glfwGetProcAddress("glEndQuery");
+    bindings->glGetQueryiv = (PFNGLGETQUERYIV_PROC*)glfwGetProcAddress("glGetQueryiv");
+    bindings->glGetQueryObjectiv = (PFNGLGETQUERYOBJECTIV_PROC*)glfwGetProcAddress("glGetQueryObjectiv");
+    bindings->glGetQueryObjectuiv = (PFNGLGETQUERYOBJECTUIV_PROC*)glfwGetProcAddress("glGetQueryObjectuiv");
+    bindings->glBindBuffer = (PFNGLBINDBUFFER_PROC*)glfwGetProcAddress("glBindBuffer");
+    bindings->glDeleteBuffers = (PFNGLDELETEBUFFERS_PROC*)glfwGetProcAddress("glDeleteBuffers");
+    bindings->glGenBuffers = (PFNGLGENBUFFERS_PROC*)glfwGetProcAddress("glGenBuffers");
+    bindings->glIsBuffer = (PFNGLISBUFFER_PROC*)glfwGetProcAddress("glIsBuffer");
+    bindings->glBufferData = (PFNGLBUFFERDATA_PROC*)glfwGetProcAddress("glBufferData");
+    bindings->glBufferSubData = (PFNGLBUFFERSUBDATA_PROC*)glfwGetProcAddress("glBufferSubData");
+    bindings->glGetBufferSubData = (PFNGLGETBUFFERSUBDATA_PROC*)glfwGetProcAddress("glGetBufferSubData");
+    bindings->glMapBuffer = (PFNGLMAPBUFFER_PROC*)glfwGetProcAddress("glMapBuffer");
+    bindings->glUnmapBuffer = (PFNGLUNMAPBUFFER_PROC*)glfwGetProcAddress("glUnmapBuffer");
+    bindings->glGetBufferParameteriv = (PFNGLGETBUFFERPARAMETERIV_PROC*)glfwGetProcAddress("glGetBufferParameteriv");
+    bindings->glGetBufferPointerv = (PFNGLGETBUFFERPOINTERV_PROC*)glfwGetProcAddress("glGetBufferPointerv");
+
+    /* GL_VERSION_2_0 */
+
+    bindings->glBlendEquationSeparate = (PFNGLBLENDEQUATIONSEPARATE_PROC*)glfwGetProcAddress("glBlendEquationSeparate");
+    bindings->glDrawBuffers = (PFNGLDRAWBUFFERS_PROC*)glfwGetProcAddress("glDrawBuffers");
+    bindings->glStencilOpSeparate = (PFNGLSTENCILOPSEPARATE_PROC*)glfwGetProcAddress("glStencilOpSeparate");
+    bindings->glStencilFuncSeparate = (PFNGLSTENCILFUNCSEPARATE_PROC*)glfwGetProcAddress("glStencilFuncSeparate");
+    bindings->glStencilMaskSeparate = (PFNGLSTENCILMASKSEPARATE_PROC*)glfwGetProcAddress("glStencilMaskSeparate");
+    bindings->glAttachShader = (PFNGLATTACHSHADER_PROC*)glfwGetProcAddress("glAttachShader");
+    bindings->glBindAttribLocation = (PFNGLBINDATTRIBLOCATION_PROC*)glfwGetProcAddress("glBindAttribLocation");
+    bindings->glCompileShader = (PFNGLCOMPILESHADER_PROC*)glfwGetProcAddress("glCompileShader");
+    bindings->glCreateProgram = (PFNGLCREATEPROGRAM_PROC*)glfwGetProcAddress("glCreateProgram");
+    bindings->glCreateShader = (PFNGLCREATESHADER_PROC*)glfwGetProcAddress("glCreateShader");
+    bindings->glDeleteProgram = (PFNGLDELETEPROGRAM_PROC*)glfwGetProcAddress("glDeleteProgram");
+    bindings->glDeleteShader = (PFNGLDELETESHADER_PROC*)glfwGetProcAddress("glDeleteShader");
+    bindings->glDetachShader = (PFNGLDETACHSHADER_PROC*)glfwGetProcAddress("glDetachShader");
+    bindings->glDisableVertexAttribArray = (PFNGLDISABLEVERTEXATTRIBARRAY_PROC*)glfwGetProcAddress("glDisableVertexAttribArray");
+    bindings->glEnableVertexAttribArray = (PFNGLENABLEVERTEXATTRIBARRAY_PROC*)glfwGetProcAddress("glEnableVertexAttribArray");
+    bindings->glGetActiveAttrib = (PFNGLGETACTIVEATTRIB_PROC*)glfwGetProcAddress("glGetActiveAttrib");
+    bindings->glGetActiveUniform = (PFNGLGETACTIVEUNIFORM_PROC*)glfwGetProcAddress("glGetActiveUniform");
+    bindings->glGetAttachedShaders = (PFNGLGETATTACHEDSHADERS_PROC*)glfwGetProcAddress("glGetAttachedShaders");
+    bindings->glGetAttribLocation = (PFNGLGETATTRIBLOCATION_PROC*)glfwGetProcAddress("glGetAttribLocation");
+    bindings->glGetProgramiv = (PFNGLGETPROGRAMIV_PROC*)glfwGetProcAddress("glGetProgramiv");
+    bindings->glGetProgramInfoLog = (PFNGLGETPROGRAMINFOLOG_PROC*)glfwGetProcAddress("glGetProgramInfoLog");
+    bindings->glGetShaderiv = (PFNGLGETSHADERIV_PROC*)glfwGetProcAddress("glGetShaderiv");
+    bindings->glGetShaderInfoLog = (PFNGLGETSHADERINFOLOG_PROC*)glfwGetProcAddress("glGetShaderInfoLog");
+    bindings->glGetShaderSource = (PFNGLGETSHADERSOURCE_PROC*)glfwGetProcAddress("glGetShaderSource");
+    bindings->glGetUniformLocation = (PFNGLGETUNIFORMLOCATION_PROC*)glfwGetProcAddress("glGetUniformLocation");
+    bindings->glGetUniformfv = (PFNGLGETUNIFORMFV_PROC*)glfwGetProcAddress("glGetUniformfv");
+    bindings->glGetUniformiv = (PFNGLGETUNIFORMIV_PROC*)glfwGetProcAddress("glGetUniformiv");
+    bindings->glGetVertexAttribdv = (PFNGLGETVERTEXATTRIBDV_PROC*)glfwGetProcAddress("glGetVertexAttribdv");
+    bindings->glGetVertexAttribfv = (PFNGLGETVERTEXATTRIBFV_PROC*)glfwGetProcAddress("glGetVertexAttribfv");
+    bindings->glGetVertexAttribiv = (PFNGLGETVERTEXATTRIBIV_PROC*)glfwGetProcAddress("glGetVertexAttribiv");
+    bindings->glGetVertexAttribPointerv = (PFNGLGETVERTEXATTRIBPOINTERV_PROC*)glfwGetProcAddress("glGetVertexAttribPointerv");
+    bindings->glIsProgram = (PFNGLISPROGRAM_PROC*)glfwGetProcAddress("glIsProgram");
+    bindings->glIsShader = (PFNGLISSHADER_PROC*)glfwGetProcAddress("glIsShader");
+    bindings->glLinkProgram = (PFNGLLINKPROGRAM_PROC*)glfwGetProcAddress("glLinkProgram");
+    bindings->glShaderSource = (PFNGLSHADERSOURCE_PROC*)glfwGetProcAddress("glShaderSource");
+    bindings->glUseProgram = (PFNGLUSEPROGRAM_PROC*)glfwGetProcAddress("glUseProgram");
+    bindings->glUniform1f = (PFNGLUNIFORM1F_PROC*)glfwGetProcAddress("glUniform1f");
+    bindings->glUniform2f = (PFNGLUNIFORM2F_PROC*)glfwGetProcAddress("glUniform2f");
+    bindings->glUniform3f = (PFNGLUNIFORM3F_PROC*)glfwGetProcAddress("glUniform3f");
+    bindings->glUniform4f = (PFNGLUNIFORM4F_PROC*)glfwGetProcAddress("glUniform4f");
+    bindings->glUniform1i = (PFNGLUNIFORM1I_PROC*)glfwGetProcAddress("glUniform1i");
+    bindings->glUniform2i = (PFNGLUNIFORM2I_PROC*)glfwGetProcAddress("glUniform2i");
+    bindings->glUniform3i = (PFNGLUNIFORM3I_PROC*)glfwGetProcAddress("glUniform3i");
+    bindings->glUniform4i = (PFNGLUNIFORM4I_PROC*)glfwGetProcAddress("glUniform4i");
+    bindings->glUniform1fv = (PFNGLUNIFORM1FV_PROC*)glfwGetProcAddress("glUniform1fv");
+    bindings->glUniform2fv = (PFNGLUNIFORM2FV_PROC*)glfwGetProcAddress("glUniform2fv");
+    bindings->glUniform3fv = (PFNGLUNIFORM3FV_PROC*)glfwGetProcAddress("glUniform3fv");
+    bindings->glUniform4fv = (PFNGLUNIFORM4FV_PROC*)glfwGetProcAddress("glUniform4fv");
+    bindings->glUniform1iv = (PFNGLUNIFORM1IV_PROC*)glfwGetProcAddress("glUniform1iv");
+    bindings->glUniform2iv = (PFNGLUNIFORM2IV_PROC*)glfwGetProcAddress("glUniform2iv");
+    bindings->glUniform3iv = (PFNGLUNIFORM3IV_PROC*)glfwGetProcAddress("glUniform3iv");
+    bindings->glUniform4iv = (PFNGLUNIFORM4IV_PROC*)glfwGetProcAddress("glUniform4iv");
+    bindings->glUniformMatrix2fv = (PFNGLUNIFORMMATRIX2FV_PROC*)glfwGetProcAddress("glUniformMatrix2fv");
+    bindings->glUniformMatrix3fv = (PFNGLUNIFORMMATRIX3FV_PROC*)glfwGetProcAddress("glUniformMatrix3fv");
+    bindings->glUniformMatrix4fv = (PFNGLUNIFORMMATRIX4FV_PROC*)glfwGetProcAddress("glUniformMatrix4fv");
+    bindings->glValidateProgram = (PFNGLVALIDATEPROGRAM_PROC*)glfwGetProcAddress("glValidateProgram");
+    bindings->glVertexAttrib1d = (PFNGLVERTEXATTRIB1D_PROC*)glfwGetProcAddress("glVertexAttrib1d");
+    bindings->glVertexAttrib1dv = (PFNGLVERTEXATTRIB1DV_PROC*)glfwGetProcAddress("glVertexAttrib1dv");
+    bindings->glVertexAttrib1f = (PFNGLVERTEXATTRIB1F_PROC*)glfwGetProcAddress("glVertexAttrib1f");
+    bindings->glVertexAttrib1fv = (PFNGLVERTEXATTRIB1FV_PROC*)glfwGetProcAddress("glVertexAttrib1fv");
+    bindings->glVertexAttrib1s = (PFNGLVERTEXATTRIB1S_PROC*)glfwGetProcAddress("glVertexAttrib1s");
+    bindings->glVertexAttrib1sv = (PFNGLVERTEXATTRIB1SV_PROC*)glfwGetProcAddress("glVertexAttrib1sv");
+    bindings->glVertexAttrib2d = (PFNGLVERTEXATTRIB2D_PROC*)glfwGetProcAddress("glVertexAttrib2d");
+    bindings->glVertexAttrib2dv = (PFNGLVERTEXATTRIB2DV_PROC*)glfwGetProcAddress("glVertexAttrib2dv");
+    bindings->glVertexAttrib2f = (PFNGLVERTEXATTRIB2F_PROC*)glfwGetProcAddress("glVertexAttrib2f");
+    bindings->glVertexAttrib2fv = (PFNGLVERTEXATTRIB2FV_PROC*)glfwGetProcAddress("glVertexAttrib2fv");
+    bindings->glVertexAttrib2s = (PFNGLVERTEXATTRIB2S_PROC*)glfwGetProcAddress("glVertexAttrib2s");
+    bindings->glVertexAttrib2sv = (PFNGLVERTEXATTRIB2SV_PROC*)glfwGetProcAddress("glVertexAttrib2sv");
+    bindings->glVertexAttrib3d = (PFNGLVERTEXATTRIB3D_PROC*)glfwGetProcAddress("glVertexAttrib3d");
+    bindings->glVertexAttrib3dv = (PFNGLVERTEXATTRIB3DV_PROC*)glfwGetProcAddress("glVertexAttrib3dv");
+    bindings->glVertexAttrib3f = (PFNGLVERTEXATTRIB3F_PROC*)glfwGetProcAddress("glVertexAttrib3f");
+    bindings->glVertexAttrib3fv = (PFNGLVERTEXATTRIB3FV_PROC*)glfwGetProcAddress("glVertexAttrib3fv");
+    bindings->glVertexAttrib3s = (PFNGLVERTEXATTRIB3S_PROC*)glfwGetProcAddress("glVertexAttrib3s");
+    bindings->glVertexAttrib3sv = (PFNGLVERTEXATTRIB3SV_PROC*)glfwGetProcAddress("glVertexAttrib3sv");
+    bindings->glVertexAttrib4Nbv = (PFNGLVERTEXATTRIB4NBV_PROC*)glfwGetProcAddress("glVertexAttrib4Nbv");
+    bindings->glVertexAttrib4Niv = (PFNGLVERTEXATTRIB4NIV_PROC*)glfwGetProcAddress("glVertexAttrib4Niv");
+    bindings->glVertexAttrib4Nsv = (PFNGLVERTEXATTRIB4NSV_PROC*)glfwGetProcAddress("glVertexAttrib4Nsv");
+    bindings->glVertexAttrib4Nub = (PFNGLVERTEXATTRIB4NUB_PROC*)glfwGetProcAddress("glVertexAttrib4Nub");
+    bindings->glVertexAttrib4Nubv = (PFNGLVERTEXATTRIB4NUBV_PROC*)glfwGetProcAddress("glVertexAttrib4Nubv");
+    bindings->glVertexAttrib4Nuiv = (PFNGLVERTEXATTRIB4NUIV_PROC*)glfwGetProcAddress("glVertexAttrib4Nuiv");
+    bindings->glVertexAttrib4Nusv = (PFNGLVERTEXATTRIB4NUSV_PROC*)glfwGetProcAddress("glVertexAttrib4Nusv");
+    bindings->glVertexAttrib4bv = (PFNGLVERTEXATTRIB4BV_PROC*)glfwGetProcAddress("glVertexAttrib4bv");
+    bindings->glVertexAttrib4d = (PFNGLVERTEXATTRIB4D_PROC*)glfwGetProcAddress("glVertexAttrib4d");
+    bindings->glVertexAttrib4dv = (PFNGLVERTEXATTRIB4DV_PROC*)glfwGetProcAddress("glVertexAttrib4dv");
+    bindings->glVertexAttrib4f = (PFNGLVERTEXATTRIB4F_PROC*)glfwGetProcAddress("glVertexAttrib4f");
+    bindings->glVertexAttrib4fv = (PFNGLVERTEXATTRIB4FV_PROC*)glfwGetProcAddress("glVertexAttrib4fv");
+    bindings->glVertexAttrib4iv = (PFNGLVERTEXATTRIB4IV_PROC*)glfwGetProcAddress("glVertexAttrib4iv");
+    bindings->glVertexAttrib4s = (PFNGLVERTEXATTRIB4S_PROC*)glfwGetProcAddress("glVertexAttrib4s");
+    bindings->glVertexAttrib4sv = (PFNGLVERTEXATTRIB4SV_PROC*)glfwGetProcAddress("glVertexAttrib4sv");
+    bindings->glVertexAttrib4ubv = (PFNGLVERTEXATTRIB4UBV_PROC*)glfwGetProcAddress("glVertexAttrib4ubv");
+    bindings->glVertexAttrib4uiv = (PFNGLVERTEXATTRIB4UIV_PROC*)glfwGetProcAddress("glVertexAttrib4uiv");
+    bindings->glVertexAttrib4usv = (PFNGLVERTEXATTRIB4USV_PROC*)glfwGetProcAddress("glVertexAttrib4usv");
+    bindings->glVertexAttribPointer = (PFNGLVERTEXATTRIBPOINTER_PROC*)glfwGetProcAddress("glVertexAttribPointer");
+
+    /* GL_VERSION_2_1 */
+
+    bindings->glUniformMatrix2x3fv = (PFNGLUNIFORMMATRIX2X3FV_PROC*)glfwGetProcAddress("glUniformMatrix2x3fv");
+    bindings->glUniformMatrix3x2fv = (PFNGLUNIFORMMATRIX3X2FV_PROC*)glfwGetProcAddress("glUniformMatrix3x2fv");
+    bindings->glUniformMatrix2x4fv = (PFNGLUNIFORMMATRIX2X4FV_PROC*)glfwGetProcAddress("glUniformMatrix2x4fv");
+    bindings->glUniformMatrix4x2fv = (PFNGLUNIFORMMATRIX4X2FV_PROC*)glfwGetProcAddress("glUniformMatrix4x2fv");
+    bindings->glUniformMatrix3x4fv = (PFNGLUNIFORMMATRIX3X4FV_PROC*)glfwGetProcAddress("glUniformMatrix3x4fv");
+    bindings->glUniformMatrix4x3fv = (PFNGLUNIFORMMATRIX4X3FV_PROC*)glfwGetProcAddress("glUniformMatrix4x3fv");
+
+    /* GL_VERSION_3_0 */
+
+    bindings->glColorMaski = (PFNGLCOLORMASKI_PROC*)glfwGetProcAddress("glColorMaski");
+    bindings->glGetBooleani_v = (PFNGLGETBOOLEANI_V_PROC*)glfwGetProcAddress("glGetBooleani_v");
+    bindings->glGetIntegeri_v = (PFNGLGETINTEGERI_V_PROC*)glfwGetProcAddress("glGetIntegeri_v");
+    bindings->glEnablei = (PFNGLENABLEI_PROC*)glfwGetProcAddress("glEnablei");
+    bindings->glDisablei = (PFNGLDISABLEI_PROC*)glfwGetProcAddress("glDisablei");
+    bindings->glIsEnabledi = (PFNGLISENABLEDI_PROC*)glfwGetProcAddress("glIsEnabledi");
+    bindings->glBeginTransformFeedback = (PFNGLBEGINTRANSFORMFEEDBACK_PROC*)glfwGetProcAddress("glBeginTransformFeedback");
+    bindings->glEndTransformFeedback = (PFNGLENDTRANSFORMFEEDBACK_PROC*)glfwGetProcAddress("glEndTransformFeedback");
+    bindings->glBindBufferRange = (PFNGLBINDBUFFERRANGE_PROC*)glfwGetProcAddress("glBindBufferRange");
+    bindings->glBindBufferBase = (PFNGLBINDBUFFERBASE_PROC*)glfwGetProcAddress("glBindBufferBase");
+    bindings->glTransformFeedbackVaryings = (PFNGLTRANSFORMFEEDBACKVARYINGS_PROC*)glfwGetProcAddress("glTransformFeedbackVaryings");
+    bindings->glGetTransformFeedbackVarying = (PFNGLGETTRANSFORMFEEDBACKVARYING_PROC*)glfwGetProcAddress("glGetTransformFeedbackVarying");
+    bindings->glClampColor = (PFNGLCLAMPCOLOR_PROC*)glfwGetProcAddress("glClampColor");
+    bindings->glBeginConditionalRender = (PFNGLBEGINCONDITIONALRENDER_PROC*)glfwGetProcAddress("glBeginConditionalRender");
+    bindings->glEndConditionalRender = (PFNGLENDCONDITIONALRENDER_PROC*)glfwGetProcAddress("glEndConditionalRender");
+    bindings->glVertexAttribIPointer = (PFNGLVERTEXATTRIBIPOINTER_PROC*)glfwGetProcAddress("glVertexAttribIPointer");
+    bindings->glGetVertexAttribIiv = (PFNGLGETVERTEXATTRIBIIV_PROC*)glfwGetProcAddress("glGetVertexAttribIiv");
+    bindings->glGetVertexAttribIuiv = (PFNGLGETVERTEXATTRIBIUIV_PROC*)glfwGetProcAddress("glGetVertexAttribIuiv");
+    bindings->glVertexAttribI1i = (PFNGLVERTEXATTRIBI1I_PROC*)glfwGetProcAddress("glVertexAttribI1i");
+    bindings->glVertexAttribI2i = (PFNGLVERTEXATTRIBI2I_PROC*)glfwGetProcAddress("glVertexAttribI2i");
+    bindings->glVertexAttribI3i = (PFNGLVERTEXATTRIBI3I_PROC*)glfwGetProcAddress("glVertexAttribI3i");
+    bindings->glVertexAttribI4i = (PFNGLVERTEXATTRIBI4I_PROC*)glfwGetProcAddress("glVertexAttribI4i");
+    bindings->glVertexAttribI1ui = (PFNGLVERTEXATTRIBI1UI_PROC*)glfwGetProcAddress("glVertexAttribI1ui");
+    bindings->glVertexAttribI2ui = (PFNGLVERTEXATTRIBI2UI_PROC*)glfwGetProcAddress("glVertexAttribI2ui");
+    bindings->glVertexAttribI3ui = (PFNGLVERTEXATTRIBI3UI_PROC*)glfwGetProcAddress("glVertexAttribI3ui");
+    bindings->glVertexAttribI4ui = (PFNGLVERTEXATTRIBI4UI_PROC*)glfwGetProcAddress("glVertexAttribI4ui");
+    bindings->glVertexAttribI1iv = (PFNGLVERTEXATTRIBI1IV_PROC*)glfwGetProcAddress("glVertexAttribI1iv");
+    bindings->glVertexAttribI2iv = (PFNGLVERTEXATTRIBI2IV_PROC*)glfwGetProcAddress("glVertexAttribI2iv");
+    bindings->glVertexAttribI3iv = (PFNGLVERTEXATTRIBI3IV_PROC*)glfwGetProcAddress("glVertexAttribI3iv");
+    bindings->glVertexAttribI4iv = (PFNGLVERTEXATTRIBI4IV_PROC*)glfwGetProcAddress("glVertexAttribI4iv");
+    bindings->glVertexAttribI1uiv = (PFNGLVERTEXATTRIBI1UIV_PROC*)glfwGetProcAddress("glVertexAttribI1uiv");
+    bindings->glVertexAttribI2uiv = (PFNGLVERTEXATTRIBI2UIV_PROC*)glfwGetProcAddress("glVertexAttribI2uiv");
+    bindings->glVertexAttribI3uiv = (PFNGLVERTEXATTRIBI3UIV_PROC*)glfwGetProcAddress("glVertexAttribI3uiv");
+    bindings->glVertexAttribI4uiv = (PFNGLVERTEXATTRIBI4UIV_PROC*)glfwGetProcAddress("glVertexAttribI4uiv");
+    bindings->glVertexAttribI4bv = (PFNGLVERTEXATTRIBI4BV_PROC*)glfwGetProcAddress("glVertexAttribI4bv");
+    bindings->glVertexAttribI4sv = (PFNGLVERTEXATTRIBI4SV_PROC*)glfwGetProcAddress("glVertexAttribI4sv");
+    bindings->glVertexAttribI4ubv = (PFNGLVERTEXATTRIBI4UBV_PROC*)glfwGetProcAddress("glVertexAttribI4ubv");
+    bindings->glVertexAttribI4usv = (PFNGLVERTEXATTRIBI4USV_PROC*)glfwGetProcAddress("glVertexAttribI4usv");
+    bindings->glGetUniformuiv = (PFNGLGETUNIFORMUIV_PROC*)glfwGetProcAddress("glGetUniformuiv");
+    bindings->glBindFragDataLocation = (PFNGLBINDFRAGDATALOCATION_PROC*)glfwGetProcAddress("glBindFragDataLocation");
+    bindings->glGetFragDataLocation = (PFNGLGETFRAGDATALOCATION_PROC*)glfwGetProcAddress("glGetFragDataLocation");
+    bindings->glUniform1ui = (PFNGLUNIFORM1UI_PROC*)glfwGetProcAddress("glUniform1ui");
+    bindings->glUniform2ui = (PFNGLUNIFORM2UI_PROC*)glfwGetProcAddress("glUniform2ui");
+    bindings->glUniform3ui = (PFNGLUNIFORM3UI_PROC*)glfwGetProcAddress("glUniform3ui");
+    bindings->glUniform4ui = (PFNGLUNIFORM4UI_PROC*)glfwGetProcAddress("glUniform4ui");
+    bindings->glUniform1uiv = (PFNGLUNIFORM1UIV_PROC*)glfwGetProcAddress("glUniform1uiv");
+    bindings->glUniform2uiv = (PFNGLUNIFORM2UIV_PROC*)glfwGetProcAddress("glUniform2uiv");
+    bindings->glUniform3uiv = (PFNGLUNIFORM3UIV_PROC*)glfwGetProcAddress("glUniform3uiv");
+    bindings->glUniform4uiv = (PFNGLUNIFORM4UIV_PROC*)glfwGetProcAddress("glUniform4uiv");
+    bindings->glTexParameterIiv = (PFNGLTEXPARAMETERIIV_PROC*)glfwGetProcAddress("glTexParameterIiv");
+    bindings->glTexParameterIuiv = (PFNGLTEXPARAMETERIUIV_PROC*)glfwGetProcAddress("glTexParameterIuiv");
+    bindings->glGetTexParameterIiv = (PFNGLGETTEXPARAMETERIIV_PROC*)glfwGetProcAddress("glGetTexParameterIiv");
+    bindings->glGetTexParameterIuiv = (PFNGLGETTEXPARAMETERIUIV_PROC*)glfwGetProcAddress("glGetTexParameterIuiv");
+    bindings->glClearBufferiv = (PFNGLCLEARBUFFERIV_PROC*)glfwGetProcAddress("glClearBufferiv");
+    bindings->glClearBufferuiv = (PFNGLCLEARBUFFERUIV_PROC*)glfwGetProcAddress("glClearBufferuiv");
+    bindings->glClearBufferfv = (PFNGLCLEARBUFFERFV_PROC*)glfwGetProcAddress("glClearBufferfv");
+    bindings->glClearBufferfi = (PFNGLCLEARBUFFERFI_PROC*)glfwGetProcAddress("glClearBufferfi");
+    bindings->glGetStringi = (PFNGLGETSTRINGI_PROC*)glfwGetProcAddress("glGetStringi");
+    bindings->glIsRenderbuffer = (PFNGLISRENDERBUFFER_PROC*)glfwGetProcAddress("glIsRenderbuffer");
+    bindings->glBindRenderbuffer = (PFNGLBINDRENDERBUFFER_PROC*)glfwGetProcAddress("glBindRenderbuffer");
+    bindings->glDeleteRenderbuffers = (PFNGLDELETERENDERBUFFERS_PROC*)glfwGetProcAddress("glDeleteRenderbuffers");
+    bindings->glGenRenderbuffers = (PFNGLGENRENDERBUFFERS_PROC*)glfwGetProcAddress("glGenRenderbuffers");
+    bindings->glRenderbufferStorage = (PFNGLRENDERBUFFERSTORAGE_PROC*)glfwGetProcAddress("glRenderbufferStorage");
+    bindings->glGetRenderbufferParameteriv = (PFNGLGETRENDERBUFFERPARAMETERIV_PROC*)glfwGetProcAddress("glGetRenderbufferParameteriv");
+    bindings->glIsFramebuffer = (PFNGLISFRAMEBUFFER_PROC*)glfwGetProcAddress("glIsFramebuffer");
+    bindings->glBindFramebuffer = (PFNGLBINDFRAMEBUFFER_PROC*)glfwGetProcAddress("glBindFramebuffer");
+    bindings->glDeleteFramebuffers = (PFNGLDELETEFRAMEBUFFERS_PROC*)glfwGetProcAddress("glDeleteFramebuffers");
+    bindings->glGenFramebuffers = (PFNGLGENFRAMEBUFFERS_PROC*)glfwGetProcAddress("glGenFramebuffers");
+    bindings->glCheckFramebufferStatus = (PFNGLCHECKFRAMEBUFFERSTATUS_PROC*)glfwGetProcAddress("glCheckFramebufferStatus");
+    bindings->glFramebufferTexture1D = (PFNGLFRAMEBUFFERTEXTURE1D_PROC*)glfwGetProcAddress("glFramebufferTexture1D");
+    bindings->glFramebufferTexture2D = (PFNGLFRAMEBUFFERTEXTURE2D_PROC*)glfwGetProcAddress("glFramebufferTexture2D");
+    bindings->glFramebufferTexture3D = (PFNGLFRAMEBUFFERTEXTURE3D_PROC*)glfwGetProcAddress("glFramebufferTexture3D");
+    bindings->glFramebufferRenderbuffer = (PFNGLFRAMEBUFFERRENDERBUFFER_PROC*)glfwGetProcAddress("glFramebufferRenderbuffer");
+    bindings->glGetFramebufferAttachmentParameteriv = (PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIV_PROC*)glfwGetProcAddress("glGetFramebufferAttachmentParameteriv");
+    bindings->glGenerateMipmap = (PFNGLGENERATEMIPMAP_PROC*)glfwGetProcAddress("glGenerateMipmap");
+    bindings->glBlitFramebuffer = (PFNGLBLITFRAMEBUFFER_PROC*)glfwGetProcAddress("glBlitFramebuffer");
+    bindings->glRenderbufferStorageMultisample = (PFNGLRENDERBUFFERSTORAGEMULTISAMPLE_PROC*)glfwGetProcAddress("glRenderbufferStorageMultisample");
+    bindings->glFramebufferTextureLayer = (PFNGLFRAMEBUFFERTEXTURELAYER_PROC*)glfwGetProcAddress("glFramebufferTextureLayer");
+    bindings->glMapBufferRange = (PFNGLMAPBUFFERRANGE_PROC*)glfwGetProcAddress("glMapBufferRange");
+    bindings->glFlushMappedBufferRange = (PFNGLFLUSHMAPPEDBUFFERRANGE_PROC*)glfwGetProcAddress("glFlushMappedBufferRange");
+    bindings->glBindVertexArray = (PFNGLBINDVERTEXARRAY_PROC*)glfwGetProcAddress("glBindVertexArray");
+    bindings->glDeleteVertexArrays = (PFNGLDELETEVERTEXARRAYS_PROC*)glfwGetProcAddress("glDeleteVertexArrays");
+    bindings->glGenVertexArrays = (PFNGLGENVERTEXARRAYS_PROC*)glfwGetProcAddress("glGenVertexArrays");
+    bindings->glIsVertexArray = (PFNGLISVERTEXARRAY_PROC*)glfwGetProcAddress("glIsVertexArray");
+
+    /* GL_VERSION_3_1 */
+
+    bindings->glDrawArraysInstanced = (PFNGLDRAWARRAYSINSTANCED_PROC*)glfwGetProcAddress("glDrawArraysInstanced");
+    bindings->glDrawElementsInstanced = (PFNGLDRAWELEMENTSINSTANCED_PROC*)glfwGetProcAddress("glDrawElementsInstanced");
+    bindings->glTexBuffer = (PFNGLTEXBUFFER_PROC*)glfwGetProcAddress("glTexBuffer");
+    bindings->glPrimitiveRestartIndex = (PFNGLPRIMITIVERESTARTINDEX_PROC*)glfwGetProcAddress("glPrimitiveRestartIndex");
+    bindings->glCopyBufferSubData = (PFNGLCOPYBUFFERSUBDATA_PROC*)glfwGetProcAddress("glCopyBufferSubData");
+    bindings->glGetUniformIndices = (PFNGLGETUNIFORMINDICES_PROC*)glfwGetProcAddress("glGetUniformIndices");
+    bindings->glGetActiveUniformsiv = (PFNGLGETACTIVEUNIFORMSIV_PROC*)glfwGetProcAddress("glGetActiveUniformsiv");
+    bindings->glGetActiveUniformName = (PFNGLGETACTIVEUNIFORMNAME_PROC*)glfwGetProcAddress("glGetActiveUniformName");
+    bindings->glGetUniformBlockIndex = (PFNGLGETUNIFORMBLOCKINDEX_PROC*)glfwGetProcAddress("glGetUniformBlockIndex");
+    bindings->glGetActiveUniformBlockiv = (PFNGLGETACTIVEUNIFORMBLOCKIV_PROC*)glfwGetProcAddress("glGetActiveUniformBlockiv");
+    bindings->glGetActiveUniformBlockName = (PFNGLGETACTIVEUNIFORMBLOCKNAME_PROC*)glfwGetProcAddress("glGetActiveUniformBlockName");
+    bindings->glUniformBlockBinding = (PFNGLUNIFORMBLOCKBINDING_PROC*)glfwGetProcAddress("glUniformBlockBinding");
+
+    /* GL_VERSION_3_2 */
+
+    bindings->glDrawElementsBaseVertex = (PFNGLDRAWELEMENTSBASEVERTEX_PROC*)glfwGetProcAddress("glDrawElementsBaseVertex");
+    bindings->glDrawRangeElementsBaseVertex = (PFNGLDRAWRANGEELEMENTSBASEVERTEX_PROC*)glfwGetProcAddress("glDrawRangeElementsBaseVertex");
+    bindings->glDrawElementsInstancedBaseVertex = (PFNGLDRAWELEMENTSINSTANCEDBASEVERTEX_PROC*)glfwGetProcAddress("glDrawElementsInstancedBaseVertex");
+    bindings->glMultiDrawElementsBaseVertex = (PFNGLMULTIDRAWELEMENTSBASEVERTEX_PROC*)glfwGetProcAddress("glMultiDrawElementsBaseVertex");
+    bindings->glProvokingVertex = (PFNGLPROVOKINGVERTEX_PROC*)glfwGetProcAddress("glProvokingVertex");
+    bindings->glFenceSync = (PFNGLFENCESYNC_PROC*)glfwGetProcAddress("glFenceSync");
+    bindings->glIsSync = (PFNGLISSYNC_PROC*)glfwGetProcAddress("glIsSync");
+    bindings->glDeleteSync = (PFNGLDELETESYNC_PROC*)glfwGetProcAddress("glDeleteSync");
+    bindings->glClientWaitSync = (PFNGLCLIENTWAITSYNC_PROC*)glfwGetProcAddress("glClientWaitSync");
+    bindings->glWaitSync = (PFNGLWAITSYNC_PROC*)glfwGetProcAddress("glWaitSync");
+    bindings->glGetInteger64v = (PFNGLGETINTEGER64V_PROC*)glfwGetProcAddress("glGetInteger64v");
+    bindings->glGetSynciv = (PFNGLGETSYNCIV_PROC*)glfwGetProcAddress("glGetSynciv");
+    bindings->glGetInteger64i_v = (PFNGLGETINTEGER64I_V_PROC*)glfwGetProcAddress("glGetInteger64i_v");
+    bindings->glGetBufferParameteri64v = (PFNGLGETBUFFERPARAMETERI64V_PROC*)glfwGetProcAddress("glGetBufferParameteri64v");
+    bindings->glFramebufferTexture = (PFNGLFRAMEBUFFERTEXTURE_PROC*)glfwGetProcAddress("glFramebufferTexture");
+    bindings->glTexImage2DMultisample = (PFNGLTEXIMAGE2DMULTISAMPLE_PROC*)glfwGetProcAddress("glTexImage2DMultisample");
+    bindings->glTexImage3DMultisample = (PFNGLTEXIMAGE3DMULTISAMPLE_PROC*)glfwGetProcAddress("glTexImage3DMultisample");
+    bindings->glGetMultisamplefv = (PFNGLGETMULTISAMPLEFV_PROC*)glfwGetProcAddress("glGetMultisamplefv");
+    bindings->glSampleMaski = (PFNGLSAMPLEMASKI_PROC*)glfwGetProcAddress("glSampleMaski");
+
+    /* GL_VERSION_3_3 */
+
+    bindings->glBindFragDataLocationIndexed = (PFNGLBINDFRAGDATALOCATIONINDEXED_PROC*)glfwGetProcAddress("glBindFragDataLocationIndexed");
+    bindings->glGetFragDataIndex = (PFNGLGETFRAGDATAINDEX_PROC*)glfwGetProcAddress("glGetFragDataIndex");
+    bindings->glGenSamplers = (PFNGLGENSAMPLERS_PROC*)glfwGetProcAddress("glGenSamplers");
+    bindings->glDeleteSamplers = (PFNGLDELETESAMPLERS_PROC*)glfwGetProcAddress("glDeleteSamplers");
+    bindings->glIsSampler = (PFNGLISSAMPLER_PROC*)glfwGetProcAddress("glIsSampler");
+    bindings->glBindSampler = (PFNGLBINDSAMPLER_PROC*)glfwGetProcAddress("glBindSampler");
+    bindings->glSamplerParameteri = (PFNGLSAMPLERPARAMETERI_PROC*)glfwGetProcAddress("glSamplerParameteri");
+    bindings->glSamplerParameteriv = (PFNGLSAMPLERPARAMETERIV_PROC*)glfwGetProcAddress("glSamplerParameteriv");
+    bindings->glSamplerParameterf = (PFNGLSAMPLERPARAMETERF_PROC*)glfwGetProcAddress("glSamplerParameterf");
+    bindings->glSamplerParameterfv = (PFNGLSAMPLERPARAMETERFV_PROC*)glfwGetProcAddress("glSamplerParameterfv");
+    bindings->glSamplerParameterIiv = (PFNGLSAMPLERPARAMETERIIV_PROC*)glfwGetProcAddress("glSamplerParameterIiv");
+    bindings->glSamplerParameterIuiv = (PFNGLSAMPLERPARAMETERIUIV_PROC*)glfwGetProcAddress("glSamplerParameterIuiv");
+    bindings->glGetSamplerParameteriv = (PFNGLGETSAMPLERPARAMETERIV_PROC*)glfwGetProcAddress("glGetSamplerParameteriv");
+    bindings->glGetSamplerParameterIiv = (PFNGLGETSAMPLERPARAMETERIIV_PROC*)glfwGetProcAddress("glGetSamplerParameterIiv");
+    bindings->glGetSamplerParameterfv = (PFNGLGETSAMPLERPARAMETERFV_PROC*)glfwGetProcAddress("glGetSamplerParameterfv");
+    bindings->glGetSamplerParameterIuiv = (PFNGLGETSAMPLERPARAMETERIUIV_PROC*)glfwGetProcAddress("glGetSamplerParameterIuiv");
+    bindings->glQueryCounter = (PFNGLQUERYCOUNTER_PROC*)glfwGetProcAddress("glQueryCounter");
+    bindings->glGetQueryObjecti64v = (PFNGLGETQUERYOBJECTI64V_PROC*)glfwGetProcAddress("glGetQueryObjecti64v");
+    bindings->glGetQueryObjectui64v = (PFNGLGETQUERYOBJECTUI64V_PROC*)glfwGetProcAddress("glGetQueryObjectui64v");
+    bindings->glVertexAttribDivisor = (PFNGLVERTEXATTRIBDIVISOR_PROC*)glfwGetProcAddress("glVertexAttribDivisor");
+    bindings->glVertexAttribP1ui = (PFNGLVERTEXATTRIBP1UI_PROC*)glfwGetProcAddress("glVertexAttribP1ui");
+    bindings->glVertexAttribP1uiv = (PFNGLVERTEXATTRIBP1UIV_PROC*)glfwGetProcAddress("glVertexAttribP1uiv");
+    bindings->glVertexAttribP2ui = (PFNGLVERTEXATTRIBP2UI_PROC*)glfwGetProcAddress("glVertexAttribP2ui");
+    bindings->glVertexAttribP2uiv = (PFNGLVERTEXATTRIBP2UIV_PROC*)glfwGetProcAddress("glVertexAttribP2uiv");
+    bindings->glVertexAttribP3ui = (PFNGLVERTEXATTRIBP3UI_PROC*)glfwGetProcAddress("glVertexAttribP3ui");
+    bindings->glVertexAttribP3uiv = (PFNGLVERTEXATTRIBP3UIV_PROC*)glfwGetProcAddress("glVertexAttribP3uiv");
+    bindings->glVertexAttribP4ui = (PFNGLVERTEXATTRIBP4UI_PROC*)glfwGetProcAddress("glVertexAttribP4ui");
+    bindings->glVertexAttribP4uiv = (PFNGLVERTEXATTRIBP4UIV_PROC*)glfwGetProcAddress("glVertexAttribP4uiv");
+
+}
+
+/* ----------------------- Extension flag definitions ---------------------- */
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/examples/protonect/flextGL.h b/examples/protonect/flextGL.h
new file mode 100644
index 000000000..3da3d1c9c
--- /dev/null
+++ b/examples/protonect/flextGL.h
@@ -0,0 +1,1664 @@
+/* WARNING: This file was automatically generated */
+/* Do not edit. */
+
+#ifndef __gl_h_
+#define __gl_h_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Function declaration macros - to move into glplatform.h */
+
+#if defined(_WIN32) && !defined(APIENTRY) && !defined(__CYGWIN__) && !defined(__SCITECH_SNAP__)
+#define WIN32_LEAN_AND_MEAN 1
+#ifndef WINAPI
+#define WINAPI __stdcall
+#endif
+#define APIENTRY WINAPI
+#endif
+
+#ifndef APIENTRY
+#define APIENTRY
+#endif
+#ifndef APIENTRYP
+#define APIENTRYP APIENTRY *
+#endif
+#ifndef GLAPI
+#define GLAPI extern
+#endif
+
+/* -------------------------------- DATA TYPES ------------------------------- */
+
+#include <stddef.h>
+#ifndef GLEXT_64_TYPES_DEFINED
+/* This code block is duplicated in glxext.h, so must be protected */
+#define GLEXT_64_TYPES_DEFINED
+/* Define int32_t, int64_t, and uint64_t types for UST/MSC */
+/* (as used in the GL_EXT_timer_query extension). */
+#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
+#include <inttypes.h>
+#elif defined(__sun__) || defined(__digital__)
+#include <inttypes.h>
+#if defined(__STDC__)
+#if defined(__arch64__) || defined(_LP64)
+typedef long int int64_t;
+typedef unsigned long int uint64_t;
+#else
+typedef long long int int64_t;
+typedef unsigned long long int uint64_t;
+#endif /* __arch64__ */
+#endif /* __STDC__ */
+#elif defined( __VMS ) || defined(__sgi)
+#include <inttypes.h>
+#elif defined(__SCO__) || defined(__USLC__)
+#include <stdint.h>
+#elif defined(__UNIXOS2__) || defined(__SOL64__)
+typedef long int int32_t;
+typedef long long int int64_t;
+typedef unsigned long long int uint64_t;
+#elif defined(_WIN32) && defined(__GNUC__)
+#include <stdint.h>
+#elif defined(_WIN32)
+typedef __int32 int32_t;
+typedef __int64 int64_t;
+typedef unsigned __int64 uint64_t;
+#else
+/* Fallback if nothing above works */
+#include <inttypes.h>
+#endif
+#endif
+typedef unsigned int GLenum;
+typedef unsigned char GLboolean;
+typedef unsigned int GLbitfield;
+typedef void GLvoid;
+typedef signed char GLbyte;
+typedef short GLshort;
+typedef int GLint;
+typedef unsigned char GLubyte;
+typedef unsigned short GLushort;
+typedef unsigned int GLuint;
+typedef int GLsizei;
+typedef float GLfloat;
+typedef float GLclampf;
+typedef double GLdouble;
+typedef double GLclampd;
+typedef char GLchar;
+typedef unsigned short GLhalf;
+typedef ptrdiff_t GLintptr;
+typedef ptrdiff_t GLsizeiptr;
+typedef int64_t GLint64;
+typedef uint64_t GLuint64;
+typedef struct __GLsync *GLsync;
+
+/* ----------------------------------- ENUMS --------------------------------- */
+
+/* GL_VERSION_1_1 */
+
+#define GL_DEPTH_BUFFER_BIT 0x00000100
+#define GL_STENCIL_BUFFER_BIT 0x00000400
+#define GL_COLOR_BUFFER_BIT 0x00004000
+#define GL_FALSE 0
+#define GL_TRUE 1
+#define GL_POINTS 0x0000
+#define GL_LINES 0x0001
+#define GL_LINE_LOOP 0x0002
+#define GL_LINE_STRIP 0x0003
+#define GL_TRIANGLES 0x0004
+#define GL_TRIANGLE_STRIP 0x0005
+#define GL_TRIANGLE_FAN 0x0006
+#define GL_NEVER 0x0200
+#define GL_LESS 0x0201
+#define GL_EQUAL 0x0202
+#define GL_LEQUAL 0x0203
+#define GL_GREATER 0x0204
+#define GL_NOTEQUAL 0x0205
+#define GL_GEQUAL 0x0206
+#define GL_ALWAYS 0x0207
+#define GL_ZERO 0
+#define GL_ONE 1
+#define GL_SRC_COLOR 0x0300
+#define GL_ONE_MINUS_SRC_COLOR 0x0301
+#define GL_SRC_ALPHA 0x0302
+#define GL_ONE_MINUS_SRC_ALPHA 0x0303
+#define GL_DST_ALPHA 0x0304
+#define GL_ONE_MINUS_DST_ALPHA 0x0305
+#define GL_DST_COLOR 0x0306
+#define GL_ONE_MINUS_DST_COLOR 0x0307
+#define GL_SRC_ALPHA_SATURATE 0x0308
+#define GL_NONE 0
+#define GL_FRONT_LEFT 0x0400
+#define GL_FRONT_RIGHT 0x0401
+#define GL_BACK_LEFT 0x0402
+#define GL_BACK_RIGHT 0x0403
+#define GL_FRONT 0x0404
+#define GL_BACK 0x0405
+#define GL_LEFT 0x0406
+#define GL_RIGHT 0x0407
+#define GL_FRONT_AND_BACK 0x0408
+#define GL_NO_ERROR 0
+#define GL_INVALID_ENUM 0x0500
+#define GL_INVALID_VALUE 0x0501
+#define GL_INVALID_OPERATION 0x0502
+#define GL_OUT_OF_MEMORY 0x0505
+#define GL_CW 0x0900
+#define GL_CCW 0x0901
+#define GL_POINT_SIZE 0x0B11
+#define GL_POINT_SIZE_RANGE 0x0B12
+#define GL_POINT_SIZE_GRANULARITY 0x0B13
+#define GL_LINE_SMOOTH 0x0B20
+#define GL_LINE_WIDTH 0x0B21
+#define GL_LINE_WIDTH_RANGE 0x0B22
+#define GL_LINE_WIDTH_GRANULARITY 0x0B23
+#define GL_POLYGON_MODE 0x0B40
+#define GL_POLYGON_SMOOTH 0x0B41
+#define GL_CULL_FACE 0x0B44
+#define GL_CULL_FACE_MODE 0x0B45
+#define GL_FRONT_FACE 0x0B46
+#define GL_DEPTH_RANGE 0x0B70
+#define GL_DEPTH_TEST 0x0B71
+#define GL_DEPTH_WRITEMASK 0x0B72
+#define GL_DEPTH_CLEAR_VALUE 0x0B73
+#define GL_DEPTH_FUNC 0x0B74
+#define GL_STENCIL_TEST 0x0B90
+#define GL_STENCIL_CLEAR_VALUE 0x0B91
+#define GL_STENCIL_FUNC 0x0B92
+#define GL_STENCIL_VALUE_MASK 0x0B93
+#define GL_STENCIL_FAIL 0x0B94
+#define GL_STENCIL_PASS_DEPTH_FAIL 0x0B95
+#define GL_STENCIL_PASS_DEPTH_PASS 0x0B96
+#define GL_STENCIL_REF 0x0B97
+#define GL_STENCIL_WRITEMASK 0x0B98
+#define GL_VIEWPORT 0x0BA2
+#define GL_DITHER 0x0BD0
+#define GL_BLEND_DST 0x0BE0
+#define GL_BLEND_SRC 0x0BE1
+#define GL_BLEND 0x0BE2
+#define GL_LOGIC_OP_MODE 0x0BF0
+#define GL_COLOR_LOGIC_OP 0x0BF2
+#define GL_DRAW_BUFFER 0x0C01
+#define GL_READ_BUFFER 0x0C02
+#define GL_SCISSOR_BOX 0x0C10
+#define GL_SCISSOR_TEST 0x0C11
+#define GL_COLOR_CLEAR_VALUE 0x0C22
+#define GL_COLOR_WRITEMASK 0x0C23
+#define GL_DOUBLEBUFFER 0x0C32
+#define GL_STEREO 0x0C33
+#define GL_LINE_SMOOTH_HINT 0x0C52
+#define GL_POLYGON_SMOOTH_HINT 0x0C53
+#define GL_UNPACK_SWAP_BYTES 0x0CF0
+#define GL_UNPACK_LSB_FIRST 0x0CF1
+#define GL_UNPACK_ROW_LENGTH 0x0CF2
+#define GL_UNPACK_SKIP_ROWS 0x0CF3
+#define GL_UNPACK_SKIP_PIXELS 0x0CF4
+#define GL_UNPACK_ALIGNMENT 0x0CF5
+#define GL_PACK_SWAP_BYTES 0x0D00
+#define GL_PACK_LSB_FIRST 0x0D01
+#define GL_PACK_ROW_LENGTH 0x0D02
+#define GL_PACK_SKIP_ROWS 0x0D03
+#define GL_PACK_SKIP_PIXELS 0x0D04
+#define GL_PACK_ALIGNMENT 0x0D05
+#define GL_MAX_TEXTURE_SIZE 0x0D33
+#define GL_MAX_VIEWPORT_DIMS 0x0D3A
+#define GL_SUBPIXEL_BITS 0x0D50
+#define GL_TEXTURE_1D 0x0DE0
+#define GL_TEXTURE_2D 0x0DE1
+#define GL_POLYGON_OFFSET_UNITS 0x2A00
+#define GL_POLYGON_OFFSET_POINT 0x2A01
+#define GL_POLYGON_OFFSET_LINE 0x2A02
+#define GL_POLYGON_OFFSET_FILL 0x8037
+#define GL_POLYGON_OFFSET_FACTOR 0x8038
+#define GL_TEXTURE_BINDING_1D 0x8068
+#define GL_TEXTURE_BINDING_2D 0x8069
+#define GL_TEXTURE_WIDTH 0x1000
+#define GL_TEXTURE_HEIGHT 0x1001
+#define GL_TEXTURE_INTERNAL_FORMAT 0x1003
+#define GL_TEXTURE_BORDER_COLOR 0x1004
+#define GL_TEXTURE_RED_SIZE 0x805C
+#define GL_TEXTURE_GREEN_SIZE 0x805D
+#define GL_TEXTURE_BLUE_SIZE 0x805E
+#define GL_TEXTURE_ALPHA_SIZE 0x805F
+#define GL_DONT_CARE 0x1100
+#define GL_FASTEST 0x1101
+#define GL_NICEST 0x1102
+#define GL_BYTE 0x1400
+#define GL_UNSIGNED_BYTE 0x1401
+#define GL_SHORT 0x1402
+#define GL_UNSIGNED_SHORT 0x1403
+#define GL_INT 0x1404
+#define GL_UNSIGNED_INT 0x1405
+#define GL_FLOAT 0x1406
+#define GL_DOUBLE 0x140A
+#define GL_CLEAR 0x1500
+#define GL_AND 0x1501
+#define GL_AND_REVERSE 0x1502
+#define GL_COPY 0x1503
+#define GL_AND_INVERTED 0x1504
+#define GL_NOOP 0x1505
+#define GL_XOR 0x1506
+#define GL_OR 0x1507
+#define GL_NOR 0x1508
+#define GL_EQUIV 0x1509
+#define GL_INVERT 0x150A
+#define GL_OR_REVERSE 0x150B
+#define GL_COPY_INVERTED 0x150C
+#define GL_OR_INVERTED 0x150D
+#define GL_NAND 0x150E
+#define GL_SET 0x150F
+#define GL_TEXTURE 0x1702
+#define GL_COLOR 0x1800
+#define GL_DEPTH 0x1801
+#define GL_STENCIL 0x1802
+#define GL_STENCIL_INDEX 0x1901
+#define GL_DEPTH_COMPONENT 0x1902
+#define GL_RED 0x1903
+#define GL_GREEN 0x1904
+#define GL_BLUE 0x1905
+#define GL_ALPHA 0x1906
+#define GL_RGB 0x1907
+#define GL_RGBA 0x1908
+#define GL_POINT 0x1B00
+#define GL_LINE 0x1B01
+#define GL_FILL 0x1B02
+#define GL_KEEP 0x1E00
+#define GL_REPLACE 0x1E01
+#define GL_INCR 0x1E02
+#define GL_DECR 0x1E03
+#define GL_VENDOR 0x1F00
+#define GL_RENDERER 0x1F01
+#define GL_VERSION 0x1F02
+#define GL_EXTENSIONS 0x1F03
+#define GL_NEAREST 0x2600
+#define GL_LINEAR 0x2601
+#define GL_NEAREST_MIPMAP_NEAREST 0x2700
+#define GL_LINEAR_MIPMAP_NEAREST 0x2701
+#define GL_NEAREST_MIPMAP_LINEAR 0x2702
+#define GL_LINEAR_MIPMAP_LINEAR 0x2703
+#define GL_TEXTURE_MAG_FILTER 0x2800
+#define GL_TEXTURE_MIN_FILTER 0x2801
+#define GL_TEXTURE_WRAP_S 0x2802
+#define GL_TEXTURE_WRAP_T 0x2803
+#define GL_PROXY_TEXTURE_1D 0x8063
+#define GL_PROXY_TEXTURE_2D 0x8064
+#define GL_REPEAT 0x2901
+#define GL_R3_G3_B2 0x2A10
+#define GL_RGB4 0x804F
+#define GL_RGB5 0x8050
+#define GL_RGB8 0x8051
+#define GL_RGB10 0x8052
+#define GL_RGB12 0x8053
+#define GL_RGB16 0x8054
+#define GL_RGBA2 0x8055
+#define GL_RGBA4 0x8056
+#define GL_RGB5_A1 0x8057
+#define GL_RGBA8 0x8058
+#define GL_RGB10_A2 0x8059
+#define GL_RGBA12 0x805A
+#define GL_RGBA16 0x805B
+
+/* GL_VERSION_1_2 */
+
+#define GL_UNSIGNED_BYTE_3_3_2 0x8032
+#define GL_UNSIGNED_SHORT_4_4_4_4 0x8033
+#define GL_UNSIGNED_SHORT_5_5_5_1 0x8034
+#define GL_UNSIGNED_INT_8_8_8_8 0x8035
+#define GL_UNSIGNED_INT_10_10_10_2 0x8036
+#define GL_TEXTURE_BINDING_3D 0x806A
+#define GL_PACK_SKIP_IMAGES 0x806B
+#define GL_PACK_IMAGE_HEIGHT 0x806C
+#define GL_UNPACK_SKIP_IMAGES 0x806D
+#define GL_UNPACK_IMAGE_HEIGHT 0x806E
+#define GL_TEXTURE_3D 0x806F
+#define GL_PROXY_TEXTURE_3D 0x8070
+#define GL_TEXTURE_DEPTH 0x8071
+#define GL_TEXTURE_WRAP_R 0x8072
+#define GL_MAX_3D_TEXTURE_SIZE 0x8073
+#define GL_UNSIGNED_BYTE_2_3_3_REV 0x8362
+#define GL_UNSIGNED_SHORT_5_6_5 0x8363
+#define GL_UNSIGNED_SHORT_5_6_5_REV 0x8364
+#define GL_UNSIGNED_SHORT_4_4_4_4_REV 0x8365
+#define GL_UNSIGNED_SHORT_1_5_5_5_REV 0x8366
+#define GL_UNSIGNED_INT_8_8_8_8_REV 0x8367
+#define GL_UNSIGNED_INT_2_10_10_10_REV 0x8368
+#define GL_BGR 0x80E0
+#define GL_BGRA 0x80E1
+#define GL_MAX_ELEMENTS_VERTICES 0x80E8
+#define GL_MAX_ELEMENTS_INDICES 0x80E9
+#define GL_CLAMP_TO_EDGE 0x812F
+#define GL_TEXTURE_MIN_LOD 0x813A
+#define GL_TEXTURE_MAX_LOD 0x813B
+#define GL_TEXTURE_BASE_LEVEL 0x813C
+#define GL_TEXTURE_MAX_LEVEL 0x813D
+#define GL_SMOOTH_POINT_SIZE_RANGE 0x0B12
+#define GL_SMOOTH_POINT_SIZE_GRANULARITY 0x0B13
+#define GL_SMOOTH_LINE_WIDTH_RANGE 0x0B22
+#define GL_SMOOTH_LINE_WIDTH_GRANULARITY 0x0B23
+#define GL_ALIASED_LINE_WIDTH_RANGE 0x846E
+
+/* GL_VERSION_1_3 */
+
+#define GL_TEXTURE0 0x84C0
+#define GL_TEXTURE1 0x84C1
+#define GL_TEXTURE2 0x84C2
+#define GL_TEXTURE3 0x84C3
+#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_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_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_TEXTURE30 0x84DE
+#define GL_TEXTURE31 0x84DF
+#define GL_ACTIVE_TEXTURE 0x84E0
+#define GL_MULTISAMPLE 0x809D
+#define GL_SAMPLE_ALPHA_TO_COVERAGE 0x809E
+#define GL_SAMPLE_ALPHA_TO_ONE 0x809F
+#define GL_SAMPLE_COVERAGE 0x80A0
+#define GL_SAMPLE_BUFFERS 0x80A8
+#define GL_SAMPLES 0x80A9
+#define GL_SAMPLE_COVERAGE_VALUE 0x80AA
+#define GL_SAMPLE_COVERAGE_INVERT 0x80AB
+#define GL_TEXTURE_CUBE_MAP 0x8513
+#define GL_TEXTURE_BINDING_CUBE_MAP 0x8514
+#define GL_TEXTURE_CUBE_MAP_POSITIVE_X 0x8515
+#define GL_TEXTURE_CUBE_MAP_NEGATIVE_X 0x8516
+#define GL_TEXTURE_CUBE_MAP_POSITIVE_Y 0x8517
+#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Y 0x8518
+#define GL_TEXTURE_CUBE_MAP_POSITIVE_Z 0x8519
+#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Z 0x851A
+#define GL_PROXY_TEXTURE_CUBE_MAP 0x851B
+#define GL_MAX_CUBE_MAP_TEXTURE_SIZE 0x851C
+#define GL_COMPRESSED_RGB 0x84ED
+#define GL_COMPRESSED_RGBA 0x84EE
+#define GL_TEXTURE_COMPRESSION_HINT 0x84EF
+#define GL_TEXTURE_COMPRESSED_IMAGE_SIZE 0x86A0
+#define GL_TEXTURE_COMPRESSED 0x86A1
+#define GL_NUM_COMPRESSED_TEXTURE_FORMATS 0x86A2
+#define GL_COMPRESSED_TEXTURE_FORMATS 0x86A3
+#define GL_CLAMP_TO_BORDER 0x812D
+
+/* GL_VERSION_1_4 */
+
+#define GL_BLEND_DST_RGB 0x80C8
+#define GL_BLEND_SRC_RGB 0x80C9
+#define GL_BLEND_DST_ALPHA 0x80CA
+#define GL_BLEND_SRC_ALPHA 0x80CB
+#define GL_POINT_FADE_THRESHOLD_SIZE 0x8128
+#define GL_DEPTH_COMPONENT16 0x81A5
+#define GL_DEPTH_COMPONENT24 0x81A6
+#define GL_DEPTH_COMPONENT32 0x81A7
+#define GL_MIRRORED_REPEAT 0x8370
+#define GL_MAX_TEXTURE_LOD_BIAS 0x84FD
+#define GL_TEXTURE_LOD_BIAS 0x8501
+#define GL_INCR_WRAP 0x8507
+#define GL_DECR_WRAP 0x8508
+#define GL_TEXTURE_DEPTH_SIZE 0x884A
+#define GL_TEXTURE_COMPARE_MODE 0x884C
+#define GL_TEXTURE_COMPARE_FUNC 0x884D
+#define GL_FUNC_ADD 0x8006
+#define GL_FUNC_SUBTRACT 0x800A
+#define GL_FUNC_REVERSE_SUBTRACT 0x800B
+#define GL_MIN 0x8007
+#define GL_MAX 0x8008
+#define GL_CONSTANT_COLOR 0x8001
+#define GL_ONE_MINUS_CONSTANT_COLOR 0x8002
+#define GL_CONSTANT_ALPHA 0x8003
+#define GL_ONE_MINUS_CONSTANT_ALPHA 0x8004
+
+/* GL_VERSION_1_5 */
+
+#define GL_BUFFER_SIZE 0x8764
+#define GL_BUFFER_USAGE 0x8765
+#define GL_QUERY_COUNTER_BITS 0x8864
+#define GL_CURRENT_QUERY 0x8865
+#define GL_QUERY_RESULT 0x8866
+#define GL_QUERY_RESULT_AVAILABLE 0x8867
+#define GL_ARRAY_BUFFER 0x8892
+#define GL_ELEMENT_ARRAY_BUFFER 0x8893
+#define GL_ARRAY_BUFFER_BINDING 0x8894
+#define GL_ELEMENT_ARRAY_BUFFER_BINDING 0x8895
+#define GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING 0x889F
+#define GL_READ_ONLY 0x88B8
+#define GL_WRITE_ONLY 0x88B9
+#define GL_READ_WRITE 0x88BA
+#define GL_BUFFER_ACCESS 0x88BB
+#define GL_BUFFER_MAPPED 0x88BC
+#define GL_BUFFER_MAP_POINTER 0x88BD
+#define GL_STREAM_DRAW 0x88E0
+#define GL_STREAM_READ 0x88E1
+#define GL_STREAM_COPY 0x88E2
+#define GL_STATIC_DRAW 0x88E4
+#define GL_STATIC_READ 0x88E5
+#define GL_STATIC_COPY 0x88E6
+#define GL_DYNAMIC_DRAW 0x88E8
+#define GL_DYNAMIC_READ 0x88E9
+#define GL_DYNAMIC_COPY 0x88EA
+#define GL_SAMPLES_PASSED 0x8914
+#define GL_SRC1_ALPHA 0x8589
+
+/* GL_VERSION_2_0 */
+
+#define GL_BLEND_EQUATION_RGB 0x8009
+#define GL_VERTEX_ATTRIB_ARRAY_ENABLED 0x8622
+#define GL_VERTEX_ATTRIB_ARRAY_SIZE 0x8623
+#define GL_VERTEX_ATTRIB_ARRAY_STRIDE 0x8624
+#define GL_VERTEX_ATTRIB_ARRAY_TYPE 0x8625
+#define GL_CURRENT_VERTEX_ATTRIB 0x8626
+#define GL_VERTEX_PROGRAM_POINT_SIZE 0x8642
+#define GL_VERTEX_ATTRIB_ARRAY_POINTER 0x8645
+#define GL_STENCIL_BACK_FUNC 0x8800
+#define GL_STENCIL_BACK_FAIL 0x8801
+#define GL_STENCIL_BACK_PASS_DEPTH_FAIL 0x8802
+#define GL_STENCIL_BACK_PASS_DEPTH_PASS 0x8803
+#define GL_MAX_DRAW_BUFFERS 0x8824
+#define GL_DRAW_BUFFER0 0x8825
+#define GL_DRAW_BUFFER1 0x8826
+#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_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_BLEND_EQUATION_ALPHA 0x883D
+#define GL_MAX_VERTEX_ATTRIBS 0x8869
+#define GL_VERTEX_ATTRIB_ARRAY_NORMALIZED 0x886A
+#define GL_MAX_TEXTURE_IMAGE_UNITS 0x8872
+#define GL_FRAGMENT_SHADER 0x8B30
+#define GL_VERTEX_SHADER 0x8B31
+#define GL_MAX_FRAGMENT_UNIFORM_COMPONENTS 0x8B49
+#define GL_MAX_VERTEX_UNIFORM_COMPONENTS 0x8B4A
+#define GL_MAX_VARYING_FLOATS 0x8B4B
+#define GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS 0x8B4C
+#define GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS 0x8B4D
+#define GL_SHADER_TYPE 0x8B4F
+#define GL_FLOAT_VEC2 0x8B50
+#define GL_FLOAT_VEC3 0x8B51
+#define GL_FLOAT_VEC4 0x8B52
+#define GL_INT_VEC2 0x8B53
+#define GL_INT_VEC3 0x8B54
+#define GL_INT_VEC4 0x8B55
+#define GL_BOOL 0x8B56
+#define GL_BOOL_VEC2 0x8B57
+#define GL_BOOL_VEC3 0x8B58
+#define GL_BOOL_VEC4 0x8B59
+#define GL_FLOAT_MAT2 0x8B5A
+#define GL_FLOAT_MAT3 0x8B5B
+#define GL_FLOAT_MAT4 0x8B5C
+#define GL_SAMPLER_1D 0x8B5D
+#define GL_SAMPLER_2D 0x8B5E
+#define GL_SAMPLER_3D 0x8B5F
+#define GL_SAMPLER_CUBE 0x8B60
+#define GL_SAMPLER_1D_SHADOW 0x8B61
+#define GL_SAMPLER_2D_SHADOW 0x8B62
+#define GL_DELETE_STATUS 0x8B80
+#define GL_COMPILE_STATUS 0x8B81
+#define GL_LINK_STATUS 0x8B82
+#define GL_VALIDATE_STATUS 0x8B83
+#define GL_INFO_LOG_LENGTH 0x8B84
+#define GL_ATTACHED_SHADERS 0x8B85
+#define GL_ACTIVE_UNIFORMS 0x8B86
+#define GL_ACTIVE_UNIFORM_MAX_LENGTH 0x8B87
+#define GL_SHADER_SOURCE_LENGTH 0x8B88
+#define GL_ACTIVE_ATTRIBUTES 0x8B89
+#define GL_ACTIVE_ATTRIBUTE_MAX_LENGTH 0x8B8A
+#define GL_FRAGMENT_SHADER_DERIVATIVE_HINT 0x8B8B
+#define GL_SHADING_LANGUAGE_VERSION 0x8B8C
+#define GL_CURRENT_PROGRAM 0x8B8D
+#define GL_POINT_SPRITE_COORD_ORIGIN 0x8CA0
+#define GL_LOWER_LEFT 0x8CA1
+#define GL_UPPER_LEFT 0x8CA2
+#define GL_STENCIL_BACK_REF 0x8CA3
+#define GL_STENCIL_BACK_VALUE_MASK 0x8CA4
+#define GL_STENCIL_BACK_WRITEMASK 0x8CA5
+
+/* GL_VERSION_2_1 */
+
+#define GL_PIXEL_PACK_BUFFER 0x88EB
+#define GL_PIXEL_UNPACK_BUFFER 0x88EC
+#define GL_PIXEL_PACK_BUFFER_BINDING 0x88ED
+#define GL_PIXEL_UNPACK_BUFFER_BINDING 0x88EF
+#define GL_FLOAT_MAT2x3 0x8B65
+#define GL_FLOAT_MAT2x4 0x8B66
+#define GL_FLOAT_MAT3x2 0x8B67
+#define GL_FLOAT_MAT3x4 0x8B68
+#define GL_FLOAT_MAT4x2 0x8B69
+#define GL_FLOAT_MAT4x3 0x8B6A
+#define GL_SRGB 0x8C40
+#define GL_SRGB8 0x8C41
+#define GL_SRGB_ALPHA 0x8C42
+#define GL_SRGB8_ALPHA8 0x8C43
+#define GL_COMPRESSED_SRGB 0x8C48
+#define GL_COMPRESSED_SRGB_ALPHA 0x8C49
+
+/* GL_VERSION_3_0 */
+
+#define GL_COMPARE_REF_TO_TEXTURE 0x884E
+#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_MAX_CLIP_DISTANCES 0x0D32
+#define GL_MAJOR_VERSION 0x821B
+#define GL_MINOR_VERSION 0x821C
+#define GL_NUM_EXTENSIONS 0x821D
+#define GL_CONTEXT_FLAGS 0x821E
+#define GL_COMPRESSED_RED 0x8225
+#define GL_COMPRESSED_RG 0x8226
+#define GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT 0x00000001
+#define GL_RGBA32F 0x8814
+#define GL_RGB32F 0x8815
+#define GL_RGBA16F 0x881A
+#define GL_RGB16F 0x881B
+#define GL_VERTEX_ATTRIB_ARRAY_INTEGER 0x88FD
+#define GL_MAX_ARRAY_TEXTURE_LAYERS 0x88FF
+#define GL_MIN_PROGRAM_TEXEL_OFFSET 0x8904
+#define GL_MAX_PROGRAM_TEXEL_OFFSET 0x8905
+#define GL_CLAMP_READ_COLOR 0x891C
+#define GL_FIXED_ONLY 0x891D
+#define GL_MAX_VARYING_COMPONENTS 0x8B4B
+#define GL_TEXTURE_1D_ARRAY 0x8C18
+#define GL_PROXY_TEXTURE_1D_ARRAY 0x8C19
+#define GL_TEXTURE_2D_ARRAY 0x8C1A
+#define GL_PROXY_TEXTURE_2D_ARRAY 0x8C1B
+#define GL_TEXTURE_BINDING_1D_ARRAY 0x8C1C
+#define GL_TEXTURE_BINDING_2D_ARRAY 0x8C1D
+#define GL_R11F_G11F_B10F 0x8C3A
+#define GL_UNSIGNED_INT_10F_11F_11F_REV 0x8C3B
+#define GL_RGB9_E5 0x8C3D
+#define GL_UNSIGNED_INT_5_9_9_9_REV 0x8C3E
+#define GL_TEXTURE_SHARED_SIZE 0x8C3F
+#define GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH 0x8C76
+#define GL_TRANSFORM_FEEDBACK_BUFFER_MODE 0x8C7F
+#define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS 0x8C80
+#define GL_TRANSFORM_FEEDBACK_VARYINGS 0x8C83
+#define GL_TRANSFORM_FEEDBACK_BUFFER_START 0x8C84
+#define GL_TRANSFORM_FEEDBACK_BUFFER_SIZE 0x8C85
+#define GL_PRIMITIVES_GENERATED 0x8C87
+#define GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN 0x8C88
+#define GL_RASTERIZER_DISCARD 0x8C89
+#define GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS 0x8C8A
+#define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS 0x8C8B
+#define GL_INTERLEAVED_ATTRIBS 0x8C8C
+#define GL_SEPARATE_ATTRIBS 0x8C8D
+#define GL_TRANSFORM_FEEDBACK_BUFFER 0x8C8E
+#define GL_TRANSFORM_FEEDBACK_BUFFER_BINDING 0x8C8F
+#define GL_RGBA32UI 0x8D70
+#define GL_RGB32UI 0x8D71
+#define GL_RGBA16UI 0x8D76
+#define GL_RGB16UI 0x8D77
+#define GL_RGBA8UI 0x8D7C
+#define GL_RGB8UI 0x8D7D
+#define GL_RGBA32I 0x8D82
+#define GL_RGB32I 0x8D83
+#define GL_RGBA16I 0x8D88
+#define GL_RGB16I 0x8D89
+#define GL_RGBA8I 0x8D8E
+#define GL_RGB8I 0x8D8F
+#define GL_RED_INTEGER 0x8D94
+#define GL_GREEN_INTEGER 0x8D95
+#define GL_BLUE_INTEGER 0x8D96
+#define GL_RGB_INTEGER 0x8D98
+#define GL_RGBA_INTEGER 0x8D99
+#define GL_BGR_INTEGER 0x8D9A
+#define GL_BGRA_INTEGER 0x8D9B
+#define GL_SAMPLER_1D_ARRAY 0x8DC0
+#define GL_SAMPLER_2D_ARRAY 0x8DC1
+#define GL_SAMPLER_1D_ARRAY_SHADOW 0x8DC3
+#define GL_SAMPLER_2D_ARRAY_SHADOW 0x8DC4
+#define GL_SAMPLER_CUBE_SHADOW 0x8DC5
+#define GL_UNSIGNED_INT_VEC2 0x8DC6
+#define GL_UNSIGNED_INT_VEC3 0x8DC7
+#define GL_UNSIGNED_INT_VEC4 0x8DC8
+#define GL_INT_SAMPLER_1D 0x8DC9
+#define GL_INT_SAMPLER_2D 0x8DCA
+#define GL_INT_SAMPLER_3D 0x8DCB
+#define GL_INT_SAMPLER_CUBE 0x8DCC
+#define GL_INT_SAMPLER_1D_ARRAY 0x8DCE
+#define GL_INT_SAMPLER_2D_ARRAY 0x8DCF
+#define GL_UNSIGNED_INT_SAMPLER_1D 0x8DD1
+#define GL_UNSIGNED_INT_SAMPLER_2D 0x8DD2
+#define GL_UNSIGNED_INT_SAMPLER_3D 0x8DD3
+#define GL_UNSIGNED_INT_SAMPLER_CUBE 0x8DD4
+#define GL_UNSIGNED_INT_SAMPLER_1D_ARRAY 0x8DD6
+#define GL_UNSIGNED_INT_SAMPLER_2D_ARRAY 0x8DD7
+#define GL_QUERY_WAIT 0x8E13
+#define GL_QUERY_NO_WAIT 0x8E14
+#define GL_QUERY_BY_REGION_WAIT 0x8E15
+#define GL_QUERY_BY_REGION_NO_WAIT 0x8E16
+#define GL_BUFFER_ACCESS_FLAGS 0x911F
+#define GL_BUFFER_MAP_LENGTH 0x9120
+#define GL_BUFFER_MAP_OFFSET 0x9121
+#define GL_DEPTH_COMPONENT32F 0x8CAC
+#define GL_DEPTH32F_STENCIL8 0x8CAD
+#define GL_FLOAT_32_UNSIGNED_INT_24_8_REV 0x8DAD
+#define GL_INVALID_FRAMEBUFFER_OPERATION 0x0506
+#define GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING 0x8210
+#define GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE 0x8211
+#define GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE 0x8212
+#define GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE 0x8213
+#define GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE 0x8214
+#define GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE 0x8215
+#define GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE 0x8216
+#define GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE 0x8217
+#define GL_FRAMEBUFFER_DEFAULT 0x8218
+#define GL_FRAMEBUFFER_UNDEFINED 0x8219
+#define GL_DEPTH_STENCIL_ATTACHMENT 0x821A
+#define GL_MAX_RENDERBUFFER_SIZE 0x84E8
+#define GL_DEPTH_STENCIL 0x84F9
+#define GL_UNSIGNED_INT_24_8 0x84FA
+#define GL_DEPTH24_STENCIL8 0x88F0
+#define GL_TEXTURE_STENCIL_SIZE 0x88F1
+#define GL_TEXTURE_RED_TYPE 0x8C10
+#define GL_TEXTURE_GREEN_TYPE 0x8C11
+#define GL_TEXTURE_BLUE_TYPE 0x8C12
+#define GL_TEXTURE_ALPHA_TYPE 0x8C13
+#define GL_TEXTURE_DEPTH_TYPE 0x8C16
+#define GL_UNSIGNED_NORMALIZED 0x8C17
+#define GL_FRAMEBUFFER_BINDING 0x8CA6
+#define GL_DRAW_FRAMEBUFFER_BINDING 0x8CA6
+#define GL_RENDERBUFFER_BINDING 0x8CA7
+#define GL_READ_FRAMEBUFFER 0x8CA8
+#define GL_DRAW_FRAMEBUFFER 0x8CA9
+#define GL_READ_FRAMEBUFFER_BINDING 0x8CAA
+#define GL_RENDERBUFFER_SAMPLES 0x8CAB
+#define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE 0x8CD0
+#define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME 0x8CD1
+#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL 0x8CD2
+#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE 0x8CD3
+#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER 0x8CD4
+#define GL_FRAMEBUFFER_COMPLETE 0x8CD5
+#define GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT 0x8CD6
+#define GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT 0x8CD7
+#define GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER 0x8CDB
+#define GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER 0x8CDC
+#define GL_FRAMEBUFFER_UNSUPPORTED 0x8CDD
+#define GL_MAX_COLOR_ATTACHMENTS 0x8CDF
+#define GL_COLOR_ATTACHMENT0 0x8CE0
+#define GL_COLOR_ATTACHMENT1 0x8CE1
+#define GL_COLOR_ATTACHMENT2 0x8CE2
+#define GL_COLOR_ATTACHMENT3 0x8CE3
+#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_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_DEPTH_ATTACHMENT 0x8D00
+#define GL_STENCIL_ATTACHMENT 0x8D20
+#define GL_FRAMEBUFFER 0x8D40
+#define GL_RENDERBUFFER 0x8D41
+#define GL_RENDERBUFFER_WIDTH 0x8D42
+#define GL_RENDERBUFFER_HEIGHT 0x8D43
+#define GL_RENDERBUFFER_INTERNAL_FORMAT 0x8D44
+#define GL_STENCIL_INDEX1 0x8D46
+#define GL_STENCIL_INDEX4 0x8D47
+#define GL_STENCIL_INDEX8 0x8D48
+#define GL_STENCIL_INDEX16 0x8D49
+#define GL_RENDERBUFFER_RED_SIZE 0x8D50
+#define GL_RENDERBUFFER_GREEN_SIZE 0x8D51
+#define GL_RENDERBUFFER_BLUE_SIZE 0x8D52
+#define GL_RENDERBUFFER_ALPHA_SIZE 0x8D53
+#define GL_RENDERBUFFER_DEPTH_SIZE 0x8D54
+#define GL_RENDERBUFFER_STENCIL_SIZE 0x8D55
+#define GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE 0x8D56
+#define GL_MAX_SAMPLES 0x8D57
+#define GL_FRAMEBUFFER_SRGB 0x8DB9
+#define GL_HALF_FLOAT 0x140B
+#define GL_MAP_READ_BIT 0x0001
+#define GL_MAP_WRITE_BIT 0x0002
+#define GL_MAP_INVALIDATE_RANGE_BIT 0x0004
+#define GL_MAP_INVALIDATE_BUFFER_BIT 0x0008
+#define GL_MAP_FLUSH_EXPLICIT_BIT 0x0010
+#define GL_MAP_UNSYNCHRONIZED_BIT 0x0020
+#define GL_COMPRESSED_RED_RGTC1 0x8DBB
+#define GL_COMPRESSED_SIGNED_RED_RGTC1 0x8DBC
+#define GL_COMPRESSED_RG_RGTC2 0x8DBD
+#define GL_COMPRESSED_SIGNED_RG_RGTC2 0x8DBE
+#define GL_RG 0x8227
+#define GL_RG_INTEGER 0x8228
+#define GL_R8 0x8229
+#define GL_R16 0x822A
+#define GL_RG8 0x822B
+#define GL_RG16 0x822C
+#define GL_R16F 0x822D
+#define GL_R32F 0x822E
+#define GL_RG16F 0x822F
+#define GL_RG32F 0x8230
+#define GL_R8I 0x8231
+#define GL_R8UI 0x8232
+#define GL_R16I 0x8233
+#define GL_R16UI 0x8234
+#define GL_R32I 0x8235
+#define GL_R32UI 0x8236
+#define GL_RG8I 0x8237
+#define GL_RG8UI 0x8238
+#define GL_RG16I 0x8239
+#define GL_RG16UI 0x823A
+#define GL_RG32I 0x823B
+#define GL_RG32UI 0x823C
+#define GL_VERTEX_ARRAY_BINDING 0x85B5
+
+/* GL_VERSION_3_1 */
+
+#define GL_SAMPLER_2D_RECT 0x8B63
+#define GL_SAMPLER_2D_RECT_SHADOW 0x8B64
+#define GL_SAMPLER_BUFFER 0x8DC2
+#define GL_INT_SAMPLER_2D_RECT 0x8DCD
+#define GL_INT_SAMPLER_BUFFER 0x8DD0
+#define GL_UNSIGNED_INT_SAMPLER_2D_RECT 0x8DD5
+#define GL_UNSIGNED_INT_SAMPLER_BUFFER 0x8DD8
+#define GL_TEXTURE_BUFFER 0x8C2A
+#define GL_MAX_TEXTURE_BUFFER_SIZE 0x8C2B
+#define GL_TEXTURE_BINDING_BUFFER 0x8C2C
+#define GL_TEXTURE_BUFFER_DATA_STORE_BINDING 0x8C2D
+#define GL_TEXTURE_RECTANGLE 0x84F5
+#define GL_TEXTURE_BINDING_RECTANGLE 0x84F6
+#define GL_PROXY_TEXTURE_RECTANGLE 0x84F7
+#define GL_MAX_RECTANGLE_TEXTURE_SIZE 0x84F8
+#define GL_R8_SNORM 0x8F94
+#define GL_RG8_SNORM 0x8F95
+#define GL_RGB8_SNORM 0x8F96
+#define GL_RGBA8_SNORM 0x8F97
+#define GL_R16_SNORM 0x8F98
+#define GL_RG16_SNORM 0x8F99
+#define GL_RGB16_SNORM 0x8F9A
+#define GL_RGBA16_SNORM 0x8F9B
+#define GL_SIGNED_NORMALIZED 0x8F9C
+#define GL_PRIMITIVE_RESTART 0x8F9D
+#define GL_PRIMITIVE_RESTART_INDEX 0x8F9E
+#define GL_COPY_READ_BUFFER 0x8F36
+#define GL_COPY_WRITE_BUFFER 0x8F37
+#define GL_UNIFORM_BUFFER 0x8A11
+#define GL_UNIFORM_BUFFER_BINDING 0x8A28
+#define GL_UNIFORM_BUFFER_START 0x8A29
+#define GL_UNIFORM_BUFFER_SIZE 0x8A2A
+#define GL_MAX_VERTEX_UNIFORM_BLOCKS 0x8A2B
+#define GL_MAX_GEOMETRY_UNIFORM_BLOCKS 0x8A2C
+#define GL_MAX_FRAGMENT_UNIFORM_BLOCKS 0x8A2D
+#define GL_MAX_COMBINED_UNIFORM_BLOCKS 0x8A2E
+#define GL_MAX_UNIFORM_BUFFER_BINDINGS 0x8A2F
+#define GL_MAX_UNIFORM_BLOCK_SIZE 0x8A30
+#define GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS 0x8A31
+#define GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS 0x8A32
+#define GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS 0x8A33
+#define GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT 0x8A34
+#define GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH 0x8A35
+#define GL_ACTIVE_UNIFORM_BLOCKS 0x8A36
+#define GL_UNIFORM_TYPE 0x8A37
+#define GL_UNIFORM_SIZE 0x8A38
+#define GL_UNIFORM_NAME_LENGTH 0x8A39
+#define GL_UNIFORM_BLOCK_INDEX 0x8A3A
+#define GL_UNIFORM_OFFSET 0x8A3B
+#define GL_UNIFORM_ARRAY_STRIDE 0x8A3C
+#define GL_UNIFORM_MATRIX_STRIDE 0x8A3D
+#define GL_UNIFORM_IS_ROW_MAJOR 0x8A3E
+#define GL_UNIFORM_BLOCK_BINDING 0x8A3F
+#define GL_UNIFORM_BLOCK_DATA_SIZE 0x8A40
+#define GL_UNIFORM_BLOCK_NAME_LENGTH 0x8A41
+#define GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS 0x8A42
+#define GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES 0x8A43
+#define GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER 0x8A44
+#define GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER 0x8A45
+#define GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER 0x8A46
+#define GL_INVALID_INDEX 0xFFFFFFFFu
+
+/* GL_VERSION_3_2 */
+
+#define GL_CONTEXT_CORE_PROFILE_BIT 0x00000001
+#define GL_CONTEXT_COMPATIBILITY_PROFILE_BIT 0x00000002
+#define GL_LINES_ADJACENCY 0x000A
+#define GL_LINE_STRIP_ADJACENCY 0x000B
+#define GL_TRIANGLES_ADJACENCY 0x000C
+#define GL_TRIANGLE_STRIP_ADJACENCY 0x000D
+#define GL_PROGRAM_POINT_SIZE 0x8642
+#define GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS 0x8C29
+#define GL_FRAMEBUFFER_ATTACHMENT_LAYERED 0x8DA7
+#define GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS 0x8DA8
+#define GL_GEOMETRY_SHADER 0x8DD9
+#define GL_GEOMETRY_VERTICES_OUT 0x8916
+#define GL_GEOMETRY_INPUT_TYPE 0x8917
+#define GL_GEOMETRY_OUTPUT_TYPE 0x8918
+#define GL_MAX_GEOMETRY_UNIFORM_COMPONENTS 0x8DDF
+#define GL_MAX_GEOMETRY_OUTPUT_VERTICES 0x8DE0
+#define GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS 0x8DE1
+#define GL_MAX_VERTEX_OUTPUT_COMPONENTS 0x9122
+#define GL_MAX_GEOMETRY_INPUT_COMPONENTS 0x9123
+#define GL_MAX_GEOMETRY_OUTPUT_COMPONENTS 0x9124
+#define GL_MAX_FRAGMENT_INPUT_COMPONENTS 0x9125
+#define GL_CONTEXT_PROFILE_MASK 0x9126
+#define GL_DEPTH_CLAMP 0x864F
+#define GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION 0x8E4C
+#define GL_FIRST_VERTEX_CONVENTION 0x8E4D
+#define GL_LAST_VERTEX_CONVENTION 0x8E4E
+#define GL_PROVOKING_VERTEX 0x8E4F
+#define GL_TEXTURE_CUBE_MAP_SEAMLESS 0x884F
+#define GL_MAX_SERVER_WAIT_TIMEOUT 0x9111
+#define GL_OBJECT_TYPE 0x9112
+#define GL_SYNC_CONDITION 0x9113
+#define GL_SYNC_STATUS 0x9114
+#define GL_SYNC_FLAGS 0x9115
+#define GL_SYNC_FENCE 0x9116
+#define GL_SYNC_GPU_COMMANDS_COMPLETE 0x9117
+#define GL_UNSIGNALED 0x9118
+#define GL_SIGNALED 0x9119
+#define GL_ALREADY_SIGNALED 0x911A
+#define GL_TIMEOUT_EXPIRED 0x911B
+#define GL_CONDITION_SATISFIED 0x911C
+#define GL_WAIT_FAILED 0x911D
+#define GL_TIMEOUT_IGNORED 0xFFFFFFFFFFFFFFFFull
+#define GL_SYNC_FLUSH_COMMANDS_BIT 0x00000001
+#define GL_SAMPLE_POSITION 0x8E50
+#define GL_SAMPLE_MASK 0x8E51
+#define GL_SAMPLE_MASK_VALUE 0x8E52
+#define GL_MAX_SAMPLE_MASK_WORDS 0x8E59
+#define GL_TEXTURE_2D_MULTISAMPLE 0x9100
+#define GL_PROXY_TEXTURE_2D_MULTISAMPLE 0x9101
+#define GL_TEXTURE_2D_MULTISAMPLE_ARRAY 0x9102
+#define GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY 0x9103
+#define GL_TEXTURE_BINDING_2D_MULTISAMPLE 0x9104
+#define GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY 0x9105
+#define GL_TEXTURE_SAMPLES 0x9106
+#define GL_TEXTURE_FIXED_SAMPLE_LOCATIONS 0x9107
+#define GL_SAMPLER_2D_MULTISAMPLE 0x9108
+#define GL_INT_SAMPLER_2D_MULTISAMPLE 0x9109
+#define GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE 0x910A
+#define GL_SAMPLER_2D_MULTISAMPLE_ARRAY 0x910B
+#define GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY 0x910C
+#define GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY 0x910D
+#define GL_MAX_COLOR_TEXTURE_SAMPLES 0x910E
+#define GL_MAX_DEPTH_TEXTURE_SAMPLES 0x910F
+#define GL_MAX_INTEGER_SAMPLES 0x9110
+
+/* GL_VERSION_3_3 */
+
+#define GL_VERTEX_ATTRIB_ARRAY_DIVISOR 0x88FE
+#define GL_SRC1_COLOR 0x88F9
+#define GL_ONE_MINUS_SRC1_COLOR 0x88FA
+#define GL_ONE_MINUS_SRC1_ALPHA 0x88FB
+#define GL_MAX_DUAL_SOURCE_DRAW_BUFFERS 0x88FC
+#define GL_ANY_SAMPLES_PASSED 0x8C2F
+#define GL_SAMPLER_BINDING 0x8919
+#define GL_RGB10_A2UI 0x906F
+#define GL_TEXTURE_SWIZZLE_R 0x8E42
+#define GL_TEXTURE_SWIZZLE_G 0x8E43
+#define GL_TEXTURE_SWIZZLE_B 0x8E44
+#define GL_TEXTURE_SWIZZLE_A 0x8E45
+#define GL_TEXTURE_SWIZZLE_RGBA 0x8E46
+#define GL_TIME_ELAPSED 0x88BF
+#define GL_TIMESTAMP 0x8E28
+#define GL_INT_2_10_10_10_REV 0x8D9F
+
+/* --------------------------- FUNCTION PROTOTYPES --------------------------- */
+
+    
+/* GL_VERSION_1_0 */
+
+GLAPI void APIENTRY glCullFace (GLenum mode);
+GLAPI void APIENTRY glFrontFace (GLenum mode);
+GLAPI void APIENTRY glHint (GLenum target, GLenum mode);
+GLAPI void APIENTRY glLineWidth (GLfloat width);
+GLAPI void APIENTRY glPointSize (GLfloat size);
+GLAPI void APIENTRY glPolygonMode (GLenum face, GLenum mode);
+GLAPI void APIENTRY glScissor (GLint x, GLint y, GLsizei width, GLsizei height);
+GLAPI void APIENTRY glTexParameterf (GLenum target, GLenum pname, GLfloat param);
+GLAPI void APIENTRY glTexParameterfv (GLenum target, GLenum pname, const GLfloat * params);
+GLAPI void APIENTRY glTexParameteri (GLenum target, GLenum pname, GLint param);
+GLAPI void APIENTRY glTexParameteriv (GLenum target, GLenum pname, const GLint * params);
+GLAPI void APIENTRY glTexImage1D (GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void * pixels);
+GLAPI void APIENTRY glTexImage2D (GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void * pixels);
+GLAPI void APIENTRY glDrawBuffer (GLenum buf);
+GLAPI void APIENTRY glClear (GLbitfield mask);
+GLAPI void APIENTRY glClearColor (GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
+GLAPI void APIENTRY glClearStencil (GLint s);
+GLAPI void APIENTRY glClearDepth (GLdouble depth);
+GLAPI void APIENTRY glStencilMask (GLuint mask);
+GLAPI void APIENTRY glColorMask (GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
+GLAPI void APIENTRY glDepthMask (GLboolean flag);
+GLAPI void APIENTRY glDisable (GLenum cap);
+GLAPI void APIENTRY glEnable (GLenum cap);
+GLAPI void APIENTRY glFinish (void);
+GLAPI void APIENTRY glFlush (void);
+GLAPI void APIENTRY glBlendFunc (GLenum sfactor, GLenum dfactor);
+GLAPI void APIENTRY glLogicOp (GLenum opcode);
+GLAPI void APIENTRY glStencilFunc (GLenum func, GLint ref, GLuint mask);
+GLAPI void APIENTRY glStencilOp (GLenum fail, GLenum zfail, GLenum zpass);
+GLAPI void APIENTRY glDepthFunc (GLenum func);
+GLAPI void APIENTRY glPixelStoref (GLenum pname, GLfloat param);
+GLAPI void APIENTRY glPixelStorei (GLenum pname, GLint param);
+GLAPI void APIENTRY glReadBuffer (GLenum src);
+GLAPI void APIENTRY glReadPixels (GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void * pixels);
+GLAPI void APIENTRY glGetBooleanv (GLenum pname, GLboolean * data);
+GLAPI void APIENTRY glGetDoublev (GLenum pname, GLdouble * data);
+GLAPI GLenum APIENTRY glGetError (void);
+GLAPI void APIENTRY glGetFloatv (GLenum pname, GLfloat * data);
+GLAPI void APIENTRY glGetIntegerv (GLenum pname, GLint * data);
+GLAPI const GLubyte * APIENTRY glGetString (GLenum name);
+GLAPI void APIENTRY glGetTexImage (GLenum target, GLint level, GLenum format, GLenum type, void * pixels);
+GLAPI void APIENTRY glGetTexParameterfv (GLenum target, GLenum pname, GLfloat * params);
+GLAPI void APIENTRY glGetTexParameteriv (GLenum target, GLenum pname, GLint * params);
+GLAPI void APIENTRY glGetTexLevelParameterfv (GLenum target, GLint level, GLenum pname, GLfloat * params);
+GLAPI void APIENTRY glGetTexLevelParameteriv (GLenum target, GLint level, GLenum pname, GLint * params);
+GLAPI GLboolean APIENTRY glIsEnabled (GLenum cap);
+GLAPI void APIENTRY glDepthRange (GLdouble near, GLdouble far);
+GLAPI void APIENTRY glViewport (GLint x, GLint y, GLsizei width, GLsizei height);
+    
+/* GL_VERSION_1_1 */
+
+GLAPI void APIENTRY glDrawArrays (GLenum mode, GLint first, GLsizei count);
+GLAPI void APIENTRY glDrawElements (GLenum mode, GLsizei count, GLenum type, const void * indices);
+GLAPI void APIENTRY glPolygonOffset (GLfloat factor, GLfloat units);
+GLAPI void APIENTRY glCopyTexImage1D (GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border);
+GLAPI void APIENTRY glCopyTexImage2D (GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
+GLAPI void APIENTRY glCopyTexSubImage1D (GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
+GLAPI void APIENTRY glCopyTexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
+GLAPI void APIENTRY glTexSubImage1D (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void * pixels);
+GLAPI void APIENTRY glTexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void * pixels);
+GLAPI void APIENTRY glBindTexture (GLenum target, GLuint texture);
+GLAPI void APIENTRY glDeleteTextures (GLsizei n, const GLuint * textures);
+GLAPI void APIENTRY glGenTextures (GLsizei n, GLuint * textures);
+GLAPI GLboolean APIENTRY glIsTexture (GLuint texture);
+
+    
+/* GL_VERSION_1_2 */
+  
+typedef void (APIENTRY PFNGLDRAWRANGEELEMENTS_PROC (GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void * indices));
+typedef void (APIENTRY PFNGLTEXIMAGE3D_PROC (GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void * pixels));
+typedef void (APIENTRY PFNGLTEXSUBIMAGE3D_PROC (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 (APIENTRY PFNGLCOPYTEXSUBIMAGE3D_PROC (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height));
+    
+/* GL_VERSION_1_3 */
+  
+typedef void (APIENTRY PFNGLACTIVETEXTURE_PROC (GLenum texture));
+typedef void (APIENTRY PFNGLSAMPLECOVERAGE_PROC (GLfloat value, GLboolean invert));
+typedef void (APIENTRY PFNGLCOMPRESSEDTEXIMAGE3D_PROC (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void * data));
+typedef void (APIENTRY PFNGLCOMPRESSEDTEXIMAGE2D_PROC (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void * data));
+typedef void (APIENTRY PFNGLCOMPRESSEDTEXIMAGE1D_PROC (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void * data));
+typedef void (APIENTRY PFNGLCOMPRESSEDTEXSUBIMAGE3D_PROC (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 (APIENTRY PFNGLCOMPRESSEDTEXSUBIMAGE2D_PROC (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void * data));
+typedef void (APIENTRY PFNGLCOMPRESSEDTEXSUBIMAGE1D_PROC (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void * data));
+typedef void (APIENTRY PFNGLGETCOMPRESSEDTEXIMAGE_PROC (GLenum target, GLint level, void * img));
+    
+/* GL_VERSION_1_4 */
+  
+typedef void (APIENTRY PFNGLBLENDFUNCSEPARATE_PROC (GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha));
+typedef void (APIENTRY PFNGLMULTIDRAWARRAYS_PROC (GLenum mode, const GLint * first, const GLsizei * count, GLsizei drawcount));
+typedef void (APIENTRY PFNGLMULTIDRAWELEMENTS_PROC (GLenum mode, const GLsizei * count, GLenum type, const void *const* indices, GLsizei drawcount));
+typedef void (APIENTRY PFNGLPOINTPARAMETERF_PROC (GLenum pname, GLfloat param));
+typedef void (APIENTRY PFNGLPOINTPARAMETERFV_PROC (GLenum pname, const GLfloat * params));
+typedef void (APIENTRY PFNGLPOINTPARAMETERI_PROC (GLenum pname, GLint param));
+typedef void (APIENTRY PFNGLPOINTPARAMETERIV_PROC (GLenum pname, const GLint * params));
+typedef void (APIENTRY PFNGLBLENDCOLOR_PROC (GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha));
+typedef void (APIENTRY PFNGLBLENDEQUATION_PROC (GLenum mode));
+    
+/* GL_VERSION_1_5 */
+  
+typedef void (APIENTRY PFNGLGENQUERIES_PROC (GLsizei n, GLuint * ids));
+typedef void (APIENTRY PFNGLDELETEQUERIES_PROC (GLsizei n, const GLuint * ids));
+typedef GLboolean (APIENTRY PFNGLISQUERY_PROC (GLuint id));
+typedef void (APIENTRY PFNGLBEGINQUERY_PROC (GLenum target, GLuint id));
+typedef void (APIENTRY PFNGLENDQUERY_PROC (GLenum target));
+typedef void (APIENTRY PFNGLGETQUERYIV_PROC (GLenum target, GLenum pname, GLint * params));
+typedef void (APIENTRY PFNGLGETQUERYOBJECTIV_PROC (GLuint id, GLenum pname, GLint * params));
+typedef void (APIENTRY PFNGLGETQUERYOBJECTUIV_PROC (GLuint id, GLenum pname, GLuint * params));
+typedef void (APIENTRY PFNGLBINDBUFFER_PROC (GLenum target, GLuint buffer));
+typedef void (APIENTRY PFNGLDELETEBUFFERS_PROC (GLsizei n, const GLuint * buffers));
+typedef void (APIENTRY PFNGLGENBUFFERS_PROC (GLsizei n, GLuint * buffers));
+typedef GLboolean (APIENTRY PFNGLISBUFFER_PROC (GLuint buffer));
+typedef void (APIENTRY PFNGLBUFFERDATA_PROC (GLenum target, GLsizeiptr size, const void * data, GLenum usage));
+typedef void (APIENTRY PFNGLBUFFERSUBDATA_PROC (GLenum target, GLintptr offset, GLsizeiptr size, const void * data));
+typedef void (APIENTRY PFNGLGETBUFFERSUBDATA_PROC (GLenum target, GLintptr offset, GLsizeiptr size, void * data));
+typedef void * (APIENTRY PFNGLMAPBUFFER_PROC (GLenum target, GLenum access));
+typedef GLboolean (APIENTRY PFNGLUNMAPBUFFER_PROC (GLenum target));
+typedef void (APIENTRY PFNGLGETBUFFERPARAMETERIV_PROC (GLenum target, GLenum pname, GLint * params));
+typedef void (APIENTRY PFNGLGETBUFFERPOINTERV_PROC (GLenum target, GLenum pname, void ** params));
+    
+/* GL_VERSION_2_0 */
+  
+typedef void (APIENTRY PFNGLBLENDEQUATIONSEPARATE_PROC (GLenum modeRGB, GLenum modeAlpha));
+typedef void (APIENTRY PFNGLDRAWBUFFERS_PROC (GLsizei n, const GLenum * bufs));
+typedef void (APIENTRY PFNGLSTENCILOPSEPARATE_PROC (GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass));
+typedef void (APIENTRY PFNGLSTENCILFUNCSEPARATE_PROC (GLenum face, GLenum func, GLint ref, GLuint mask));
+typedef void (APIENTRY PFNGLSTENCILMASKSEPARATE_PROC (GLenum face, GLuint mask));
+typedef void (APIENTRY PFNGLATTACHSHADER_PROC (GLuint program, GLuint shader));
+typedef void (APIENTRY PFNGLBINDATTRIBLOCATION_PROC (GLuint program, GLuint index, const GLchar * name));
+typedef void (APIENTRY PFNGLCOMPILESHADER_PROC (GLuint shader));
+typedef GLuint (APIENTRY PFNGLCREATEPROGRAM_PROC (void));
+typedef GLuint (APIENTRY PFNGLCREATESHADER_PROC (GLenum type));
+typedef void (APIENTRY PFNGLDELETEPROGRAM_PROC (GLuint program));
+typedef void (APIENTRY PFNGLDELETESHADER_PROC (GLuint shader));
+typedef void (APIENTRY PFNGLDETACHSHADER_PROC (GLuint program, GLuint shader));
+typedef void (APIENTRY PFNGLDISABLEVERTEXATTRIBARRAY_PROC (GLuint index));
+typedef void (APIENTRY PFNGLENABLEVERTEXATTRIBARRAY_PROC (GLuint index));
+typedef void (APIENTRY PFNGLGETACTIVEATTRIB_PROC (GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLint * size, GLenum * type, GLchar * name));
+typedef void (APIENTRY PFNGLGETACTIVEUNIFORM_PROC (GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLint * size, GLenum * type, GLchar * name));
+typedef void (APIENTRY PFNGLGETATTACHEDSHADERS_PROC (GLuint program, GLsizei maxCount, GLsizei * count, GLuint * shaders));
+typedef GLint (APIENTRY PFNGLGETATTRIBLOCATION_PROC (GLuint program, const GLchar * name));
+typedef void (APIENTRY PFNGLGETPROGRAMIV_PROC (GLuint program, GLenum pname, GLint * params));
+typedef void (APIENTRY PFNGLGETPROGRAMINFOLOG_PROC (GLuint program, GLsizei bufSize, GLsizei * length, GLchar * infoLog));
+typedef void (APIENTRY PFNGLGETSHADERIV_PROC (GLuint shader, GLenum pname, GLint * params));
+typedef void (APIENTRY PFNGLGETSHADERINFOLOG_PROC (GLuint shader, GLsizei bufSize, GLsizei * length, GLchar * infoLog));
+typedef void (APIENTRY PFNGLGETSHADERSOURCE_PROC (GLuint shader, GLsizei bufSize, GLsizei * length, GLchar * source));
+typedef GLint (APIENTRY PFNGLGETUNIFORMLOCATION_PROC (GLuint program, const GLchar * name));
+typedef void (APIENTRY PFNGLGETUNIFORMFV_PROC (GLuint program, GLint location, GLfloat * params));
+typedef void (APIENTRY PFNGLGETUNIFORMIV_PROC (GLuint program, GLint location, GLint * params));
+typedef void (APIENTRY PFNGLGETVERTEXATTRIBDV_PROC (GLuint index, GLenum pname, GLdouble * params));
+typedef void (APIENTRY PFNGLGETVERTEXATTRIBFV_PROC (GLuint index, GLenum pname, GLfloat * params));
+typedef void (APIENTRY PFNGLGETVERTEXATTRIBIV_PROC (GLuint index, GLenum pname, GLint * params));
+typedef void (APIENTRY PFNGLGETVERTEXATTRIBPOINTERV_PROC (GLuint index, GLenum pname, void ** pointer));
+typedef GLboolean (APIENTRY PFNGLISPROGRAM_PROC (GLuint program));
+typedef GLboolean (APIENTRY PFNGLISSHADER_PROC (GLuint shader));
+typedef void (APIENTRY PFNGLLINKPROGRAM_PROC (GLuint program));
+typedef void (APIENTRY PFNGLSHADERSOURCE_PROC (GLuint shader, GLsizei count, const GLchar *const* string, const GLint * length));
+typedef void (APIENTRY PFNGLUSEPROGRAM_PROC (GLuint program));
+typedef void (APIENTRY PFNGLUNIFORM1F_PROC (GLint location, GLfloat v0));
+typedef void (APIENTRY PFNGLUNIFORM2F_PROC (GLint location, GLfloat v0, GLfloat v1));
+typedef void (APIENTRY PFNGLUNIFORM3F_PROC (GLint location, GLfloat v0, GLfloat v1, GLfloat v2));
+typedef void (APIENTRY PFNGLUNIFORM4F_PROC (GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3));
+typedef void (APIENTRY PFNGLUNIFORM1I_PROC (GLint location, GLint v0));
+typedef void (APIENTRY PFNGLUNIFORM2I_PROC (GLint location, GLint v0, GLint v1));
+typedef void (APIENTRY PFNGLUNIFORM3I_PROC (GLint location, GLint v0, GLint v1, GLint v2));
+typedef void (APIENTRY PFNGLUNIFORM4I_PROC (GLint location, GLint v0, GLint v1, GLint v2, GLint v3));
+typedef void (APIENTRY PFNGLUNIFORM1FV_PROC (GLint location, GLsizei count, const GLfloat * value));
+typedef void (APIENTRY PFNGLUNIFORM2FV_PROC (GLint location, GLsizei count, const GLfloat * value));
+typedef void (APIENTRY PFNGLUNIFORM3FV_PROC (GLint location, GLsizei count, const GLfloat * value));
+typedef void (APIENTRY PFNGLUNIFORM4FV_PROC (GLint location, GLsizei count, const GLfloat * value));
+typedef void (APIENTRY PFNGLUNIFORM1IV_PROC (GLint location, GLsizei count, const GLint * value));
+typedef void (APIENTRY PFNGLUNIFORM2IV_PROC (GLint location, GLsizei count, const GLint * value));
+typedef void (APIENTRY PFNGLUNIFORM3IV_PROC (GLint location, GLsizei count, const GLint * value));
+typedef void (APIENTRY PFNGLUNIFORM4IV_PROC (GLint location, GLsizei count, const GLint * value));
+typedef void (APIENTRY PFNGLUNIFORMMATRIX2FV_PROC (GLint location, GLsizei count, GLboolean transpose, const GLfloat * value));
+typedef void (APIENTRY PFNGLUNIFORMMATRIX3FV_PROC (GLint location, GLsizei count, GLboolean transpose, const GLfloat * value));
+typedef void (APIENTRY PFNGLUNIFORMMATRIX4FV_PROC (GLint location, GLsizei count, GLboolean transpose, const GLfloat * value));
+typedef void (APIENTRY PFNGLVALIDATEPROGRAM_PROC (GLuint program));
+typedef void (APIENTRY PFNGLVERTEXATTRIB1D_PROC (GLuint index, GLdouble x));
+typedef void (APIENTRY PFNGLVERTEXATTRIB1DV_PROC (GLuint index, const GLdouble * v));
+typedef void (APIENTRY PFNGLVERTEXATTRIB1F_PROC (GLuint index, GLfloat x));
+typedef void (APIENTRY PFNGLVERTEXATTRIB1FV_PROC (GLuint index, const GLfloat * v));
+typedef void (APIENTRY PFNGLVERTEXATTRIB1S_PROC (GLuint index, GLshort x));
+typedef void (APIENTRY PFNGLVERTEXATTRIB1SV_PROC (GLuint index, const GLshort * v));
+typedef void (APIENTRY PFNGLVERTEXATTRIB2D_PROC (GLuint index, GLdouble x, GLdouble y));
+typedef void (APIENTRY PFNGLVERTEXATTRIB2DV_PROC (GLuint index, const GLdouble * v));
+typedef void (APIENTRY PFNGLVERTEXATTRIB2F_PROC (GLuint index, GLfloat x, GLfloat y));
+typedef void (APIENTRY PFNGLVERTEXATTRIB2FV_PROC (GLuint index, const GLfloat * v));
+typedef void (APIENTRY PFNGLVERTEXATTRIB2S_PROC (GLuint index, GLshort x, GLshort y));
+typedef void (APIENTRY PFNGLVERTEXATTRIB2SV_PROC (GLuint index, const GLshort * v));
+typedef void (APIENTRY PFNGLVERTEXATTRIB3D_PROC (GLuint index, GLdouble x, GLdouble y, GLdouble z));
+typedef void (APIENTRY PFNGLVERTEXATTRIB3DV_PROC (GLuint index, const GLdouble * v));
+typedef void (APIENTRY PFNGLVERTEXATTRIB3F_PROC (GLuint index, GLfloat x, GLfloat y, GLfloat z));
+typedef void (APIENTRY PFNGLVERTEXATTRIB3FV_PROC (GLuint index, const GLfloat * v));
+typedef void (APIENTRY PFNGLVERTEXATTRIB3S_PROC (GLuint index, GLshort x, GLshort y, GLshort z));
+typedef void (APIENTRY PFNGLVERTEXATTRIB3SV_PROC (GLuint index, const GLshort * v));
+typedef void (APIENTRY PFNGLVERTEXATTRIB4NBV_PROC (GLuint index, const GLbyte * v));
+typedef void (APIENTRY PFNGLVERTEXATTRIB4NIV_PROC (GLuint index, const GLint * v));
+typedef void (APIENTRY PFNGLVERTEXATTRIB4NSV_PROC (GLuint index, const GLshort * v));
+typedef void (APIENTRY PFNGLVERTEXATTRIB4NUB_PROC (GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w));
+typedef void (APIENTRY PFNGLVERTEXATTRIB4NUBV_PROC (GLuint index, const GLubyte * v));
+typedef void (APIENTRY PFNGLVERTEXATTRIB4NUIV_PROC (GLuint index, const GLuint * v));
+typedef void (APIENTRY PFNGLVERTEXATTRIB4NUSV_PROC (GLuint index, const GLushort * v));
+typedef void (APIENTRY PFNGLVERTEXATTRIB4BV_PROC (GLuint index, const GLbyte * v));
+typedef void (APIENTRY PFNGLVERTEXATTRIB4D_PROC (GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w));
+typedef void (APIENTRY PFNGLVERTEXATTRIB4DV_PROC (GLuint index, const GLdouble * v));
+typedef void (APIENTRY PFNGLVERTEXATTRIB4F_PROC (GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w));
+typedef void (APIENTRY PFNGLVERTEXATTRIB4FV_PROC (GLuint index, const GLfloat * v));
+typedef void (APIENTRY PFNGLVERTEXATTRIB4IV_PROC (GLuint index, const GLint * v));
+typedef void (APIENTRY PFNGLVERTEXATTRIB4S_PROC (GLuint index, GLshort x, GLshort y, GLshort z, GLshort w));
+typedef void (APIENTRY PFNGLVERTEXATTRIB4SV_PROC (GLuint index, const GLshort * v));
+typedef void (APIENTRY PFNGLVERTEXATTRIB4UBV_PROC (GLuint index, const GLubyte * v));
+typedef void (APIENTRY PFNGLVERTEXATTRIB4UIV_PROC (GLuint index, const GLuint * v));
+typedef void (APIENTRY PFNGLVERTEXATTRIB4USV_PROC (GLuint index, const GLushort * v));
+typedef void (APIENTRY PFNGLVERTEXATTRIBPOINTER_PROC (GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void * pointer));
+    
+/* GL_VERSION_2_1 */
+  
+typedef void (APIENTRY PFNGLUNIFORMMATRIX2X3FV_PROC (GLint location, GLsizei count, GLboolean transpose, const GLfloat * value));
+typedef void (APIENTRY PFNGLUNIFORMMATRIX3X2FV_PROC (GLint location, GLsizei count, GLboolean transpose, const GLfloat * value));
+typedef void (APIENTRY PFNGLUNIFORMMATRIX2X4FV_PROC (GLint location, GLsizei count, GLboolean transpose, const GLfloat * value));
+typedef void (APIENTRY PFNGLUNIFORMMATRIX4X2FV_PROC (GLint location, GLsizei count, GLboolean transpose, const GLfloat * value));
+typedef void (APIENTRY PFNGLUNIFORMMATRIX3X4FV_PROC (GLint location, GLsizei count, GLboolean transpose, const GLfloat * value));
+typedef void (APIENTRY PFNGLUNIFORMMATRIX4X3FV_PROC (GLint location, GLsizei count, GLboolean transpose, const GLfloat * value));
+    
+/* GL_VERSION_3_0 */
+  
+typedef void (APIENTRY PFNGLCOLORMASKI_PROC (GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a));
+typedef void (APIENTRY PFNGLGETBOOLEANI_V_PROC (GLenum target, GLuint index, GLboolean * data));
+typedef void (APIENTRY PFNGLGETINTEGERI_V_PROC (GLenum target, GLuint index, GLint * data));
+typedef void (APIENTRY PFNGLENABLEI_PROC (GLenum target, GLuint index));
+typedef void (APIENTRY PFNGLDISABLEI_PROC (GLenum target, GLuint index));
+typedef GLboolean (APIENTRY PFNGLISENABLEDI_PROC (GLenum target, GLuint index));
+typedef void (APIENTRY PFNGLBEGINTRANSFORMFEEDBACK_PROC (GLenum primitiveMode));
+typedef void (APIENTRY PFNGLENDTRANSFORMFEEDBACK_PROC (void));
+typedef void (APIENTRY PFNGLBINDBUFFERRANGE_PROC (GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size));
+typedef void (APIENTRY PFNGLBINDBUFFERBASE_PROC (GLenum target, GLuint index, GLuint buffer));
+typedef void (APIENTRY PFNGLTRANSFORMFEEDBACKVARYINGS_PROC (GLuint program, GLsizei count, const GLchar *const* varyings, GLenum bufferMode));
+typedef void (APIENTRY PFNGLGETTRANSFORMFEEDBACKVARYING_PROC (GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLsizei * size, GLenum * type, GLchar * name));
+typedef void (APIENTRY PFNGLCLAMPCOLOR_PROC (GLenum target, GLenum clamp));
+typedef void (APIENTRY PFNGLBEGINCONDITIONALRENDER_PROC (GLuint id, GLenum mode));
+typedef void (APIENTRY PFNGLENDCONDITIONALRENDER_PROC (void));
+typedef void (APIENTRY PFNGLVERTEXATTRIBIPOINTER_PROC (GLuint index, GLint size, GLenum type, GLsizei stride, const void * pointer));
+typedef void (APIENTRY PFNGLGETVERTEXATTRIBIIV_PROC (GLuint index, GLenum pname, GLint * params));
+typedef void (APIENTRY PFNGLGETVERTEXATTRIBIUIV_PROC (GLuint index, GLenum pname, GLuint * params));
+typedef void (APIENTRY PFNGLVERTEXATTRIBI1I_PROC (GLuint index, GLint x));
+typedef void (APIENTRY PFNGLVERTEXATTRIBI2I_PROC (GLuint index, GLint x, GLint y));
+typedef void (APIENTRY PFNGLVERTEXATTRIBI3I_PROC (GLuint index, GLint x, GLint y, GLint z));
+typedef void (APIENTRY PFNGLVERTEXATTRIBI4I_PROC (GLuint index, GLint x, GLint y, GLint z, GLint w));
+typedef void (APIENTRY PFNGLVERTEXATTRIBI1UI_PROC (GLuint index, GLuint x));
+typedef void (APIENTRY PFNGLVERTEXATTRIBI2UI_PROC (GLuint index, GLuint x, GLuint y));
+typedef void (APIENTRY PFNGLVERTEXATTRIBI3UI_PROC (GLuint index, GLuint x, GLuint y, GLuint z));
+typedef void (APIENTRY PFNGLVERTEXATTRIBI4UI_PROC (GLuint index, GLuint x, GLuint y, GLuint z, GLuint w));
+typedef void (APIENTRY PFNGLVERTEXATTRIBI1IV_PROC (GLuint index, const GLint * v));
+typedef void (APIENTRY PFNGLVERTEXATTRIBI2IV_PROC (GLuint index, const GLint * v));
+typedef void (APIENTRY PFNGLVERTEXATTRIBI3IV_PROC (GLuint index, const GLint * v));
+typedef void (APIENTRY PFNGLVERTEXATTRIBI4IV_PROC (GLuint index, const GLint * v));
+typedef void (APIENTRY PFNGLVERTEXATTRIBI1UIV_PROC (GLuint index, const GLuint * v));
+typedef void (APIENTRY PFNGLVERTEXATTRIBI2UIV_PROC (GLuint index, const GLuint * v));
+typedef void (APIENTRY PFNGLVERTEXATTRIBI3UIV_PROC (GLuint index, const GLuint * v));
+typedef void (APIENTRY PFNGLVERTEXATTRIBI4UIV_PROC (GLuint index, const GLuint * v));
+typedef void (APIENTRY PFNGLVERTEXATTRIBI4BV_PROC (GLuint index, const GLbyte * v));
+typedef void (APIENTRY PFNGLVERTEXATTRIBI4SV_PROC (GLuint index, const GLshort * v));
+typedef void (APIENTRY PFNGLVERTEXATTRIBI4UBV_PROC (GLuint index, const GLubyte * v));
+typedef void (APIENTRY PFNGLVERTEXATTRIBI4USV_PROC (GLuint index, const GLushort * v));
+typedef void (APIENTRY PFNGLGETUNIFORMUIV_PROC (GLuint program, GLint location, GLuint * params));
+typedef void (APIENTRY PFNGLBINDFRAGDATALOCATION_PROC (GLuint program, GLuint color, const GLchar * name));
+typedef GLint (APIENTRY PFNGLGETFRAGDATALOCATION_PROC (GLuint program, const GLchar * name));
+typedef void (APIENTRY PFNGLUNIFORM1UI_PROC (GLint location, GLuint v0));
+typedef void (APIENTRY PFNGLUNIFORM2UI_PROC (GLint location, GLuint v0, GLuint v1));
+typedef void (APIENTRY PFNGLUNIFORM3UI_PROC (GLint location, GLuint v0, GLuint v1, GLuint v2));
+typedef void (APIENTRY PFNGLUNIFORM4UI_PROC (GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3));
+typedef void (APIENTRY PFNGLUNIFORM1UIV_PROC (GLint location, GLsizei count, const GLuint * value));
+typedef void (APIENTRY PFNGLUNIFORM2UIV_PROC (GLint location, GLsizei count, const GLuint * value));
+typedef void (APIENTRY PFNGLUNIFORM3UIV_PROC (GLint location, GLsizei count, const GLuint * value));
+typedef void (APIENTRY PFNGLUNIFORM4UIV_PROC (GLint location, GLsizei count, const GLuint * value));
+typedef void (APIENTRY PFNGLTEXPARAMETERIIV_PROC (GLenum target, GLenum pname, const GLint * params));
+typedef void (APIENTRY PFNGLTEXPARAMETERIUIV_PROC (GLenum target, GLenum pname, const GLuint * params));
+typedef void (APIENTRY PFNGLGETTEXPARAMETERIIV_PROC (GLenum target, GLenum pname, GLint * params));
+typedef void (APIENTRY PFNGLGETTEXPARAMETERIUIV_PROC (GLenum target, GLenum pname, GLuint * params));
+typedef void (APIENTRY PFNGLCLEARBUFFERIV_PROC (GLenum buffer, GLint drawbuffer, const GLint * value));
+typedef void (APIENTRY PFNGLCLEARBUFFERUIV_PROC (GLenum buffer, GLint drawbuffer, const GLuint * value));
+typedef void (APIENTRY PFNGLCLEARBUFFERFV_PROC (GLenum buffer, GLint drawbuffer, const GLfloat * value));
+typedef void (APIENTRY PFNGLCLEARBUFFERFI_PROC (GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil));
+typedef const GLubyte * (APIENTRY PFNGLGETSTRINGI_PROC (GLenum name, GLuint index));
+typedef GLboolean (APIENTRY PFNGLISRENDERBUFFER_PROC (GLuint renderbuffer));
+typedef void (APIENTRY PFNGLBINDRENDERBUFFER_PROC (GLenum target, GLuint renderbuffer));
+typedef void (APIENTRY PFNGLDELETERENDERBUFFERS_PROC (GLsizei n, const GLuint * renderbuffers));
+typedef void (APIENTRY PFNGLGENRENDERBUFFERS_PROC (GLsizei n, GLuint * renderbuffers));
+typedef void (APIENTRY PFNGLRENDERBUFFERSTORAGE_PROC (GLenum target, GLenum internalformat, GLsizei width, GLsizei height));
+typedef void (APIENTRY PFNGLGETRENDERBUFFERPARAMETERIV_PROC (GLenum target, GLenum pname, GLint * params));
+typedef GLboolean (APIENTRY PFNGLISFRAMEBUFFER_PROC (GLuint framebuffer));
+typedef void (APIENTRY PFNGLBINDFRAMEBUFFER_PROC (GLenum target, GLuint framebuffer));
+typedef void (APIENTRY PFNGLDELETEFRAMEBUFFERS_PROC (GLsizei n, const GLuint * framebuffers));
+typedef void (APIENTRY PFNGLGENFRAMEBUFFERS_PROC (GLsizei n, GLuint * framebuffers));
+typedef GLenum (APIENTRY PFNGLCHECKFRAMEBUFFERSTATUS_PROC (GLenum target));
+typedef void (APIENTRY PFNGLFRAMEBUFFERTEXTURE1D_PROC (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level));
+typedef void (APIENTRY PFNGLFRAMEBUFFERTEXTURE2D_PROC (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level));
+typedef void (APIENTRY PFNGLFRAMEBUFFERTEXTURE3D_PROC (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset));
+typedef void (APIENTRY PFNGLFRAMEBUFFERRENDERBUFFER_PROC (GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer));
+typedef void (APIENTRY PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIV_PROC (GLenum target, GLenum attachment, GLenum pname, GLint * params));
+typedef void (APIENTRY PFNGLGENERATEMIPMAP_PROC (GLenum target));
+typedef void (APIENTRY PFNGLBLITFRAMEBUFFER_PROC (GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter));
+typedef void (APIENTRY PFNGLRENDERBUFFERSTORAGEMULTISAMPLE_PROC (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height));
+typedef void (APIENTRY PFNGLFRAMEBUFFERTEXTURELAYER_PROC (GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer));
+typedef void * (APIENTRY PFNGLMAPBUFFERRANGE_PROC (GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access));
+typedef void (APIENTRY PFNGLFLUSHMAPPEDBUFFERRANGE_PROC (GLenum target, GLintptr offset, GLsizeiptr length));
+typedef void (APIENTRY PFNGLBINDVERTEXARRAY_PROC (GLuint array));
+typedef void (APIENTRY PFNGLDELETEVERTEXARRAYS_PROC (GLsizei n, const GLuint * arrays));
+typedef void (APIENTRY PFNGLGENVERTEXARRAYS_PROC (GLsizei n, GLuint * arrays));
+typedef GLboolean (APIENTRY PFNGLISVERTEXARRAY_PROC (GLuint array));
+    
+/* GL_VERSION_3_1 */
+  
+typedef void (APIENTRY PFNGLDRAWARRAYSINSTANCED_PROC (GLenum mode, GLint first, GLsizei count, GLsizei instancecount));
+typedef void (APIENTRY PFNGLDRAWELEMENTSINSTANCED_PROC (GLenum mode, GLsizei count, GLenum type, const void * indices, GLsizei instancecount));
+typedef void (APIENTRY PFNGLTEXBUFFER_PROC (GLenum target, GLenum internalformat, GLuint buffer));
+typedef void (APIENTRY PFNGLPRIMITIVERESTARTINDEX_PROC (GLuint index));
+typedef void (APIENTRY PFNGLCOPYBUFFERSUBDATA_PROC (GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size));
+typedef void (APIENTRY PFNGLGETUNIFORMINDICES_PROC (GLuint program, GLsizei uniformCount, const GLchar *const* uniformNames, GLuint * uniformIndices));
+typedef void (APIENTRY PFNGLGETACTIVEUNIFORMSIV_PROC (GLuint program, GLsizei uniformCount, const GLuint * uniformIndices, GLenum pname, GLint * params));
+typedef void (APIENTRY PFNGLGETACTIVEUNIFORMNAME_PROC (GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei * length, GLchar * uniformName));
+typedef GLuint (APIENTRY PFNGLGETUNIFORMBLOCKINDEX_PROC (GLuint program, const GLchar * uniformBlockName));
+typedef void (APIENTRY PFNGLGETACTIVEUNIFORMBLOCKIV_PROC (GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint * params));
+typedef void (APIENTRY PFNGLGETACTIVEUNIFORMBLOCKNAME_PROC (GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei * length, GLchar * uniformBlockName));
+typedef void (APIENTRY PFNGLUNIFORMBLOCKBINDING_PROC (GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding));
+    
+/* GL_VERSION_3_2 */
+  
+typedef void (APIENTRY PFNGLDRAWELEMENTSBASEVERTEX_PROC (GLenum mode, GLsizei count, GLenum type, const void * indices, GLint basevertex));
+typedef void (APIENTRY PFNGLDRAWRANGEELEMENTSBASEVERTEX_PROC (GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void * indices, GLint basevertex));
+typedef void (APIENTRY PFNGLDRAWELEMENTSINSTANCEDBASEVERTEX_PROC (GLenum mode, GLsizei count, GLenum type, const void * indices, GLsizei instancecount, GLint basevertex));
+typedef void (APIENTRY PFNGLMULTIDRAWELEMENTSBASEVERTEX_PROC (GLenum mode, const GLsizei * count, GLenum type, const void *const* indices, GLsizei drawcount, const GLint * basevertex));
+typedef void (APIENTRY PFNGLPROVOKINGVERTEX_PROC (GLenum mode));
+typedef GLsync (APIENTRY PFNGLFENCESYNC_PROC (GLenum condition, GLbitfield flags));
+typedef GLboolean (APIENTRY PFNGLISSYNC_PROC (GLsync sync));
+typedef void (APIENTRY PFNGLDELETESYNC_PROC (GLsync sync));
+typedef GLenum (APIENTRY PFNGLCLIENTWAITSYNC_PROC (GLsync sync, GLbitfield flags, GLuint64 timeout));
+typedef void (APIENTRY PFNGLWAITSYNC_PROC (GLsync sync, GLbitfield flags, GLuint64 timeout));
+typedef void (APIENTRY PFNGLGETINTEGER64V_PROC (GLenum pname, GLint64 * data));
+typedef void (APIENTRY PFNGLGETSYNCIV_PROC (GLsync sync, GLenum pname, GLsizei bufSize, GLsizei * length, GLint * values));
+typedef void (APIENTRY PFNGLGETINTEGER64I_V_PROC (GLenum target, GLuint index, GLint64 * data));
+typedef void (APIENTRY PFNGLGETBUFFERPARAMETERI64V_PROC (GLenum target, GLenum pname, GLint64 * params));
+typedef void (APIENTRY PFNGLFRAMEBUFFERTEXTURE_PROC (GLenum target, GLenum attachment, GLuint texture, GLint level));
+typedef void (APIENTRY PFNGLTEXIMAGE2DMULTISAMPLE_PROC (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations));
+typedef void (APIENTRY PFNGLTEXIMAGE3DMULTISAMPLE_PROC (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations));
+typedef void (APIENTRY PFNGLGETMULTISAMPLEFV_PROC (GLenum pname, GLuint index, GLfloat * val));
+typedef void (APIENTRY PFNGLSAMPLEMASKI_PROC (GLuint maskNumber, GLbitfield mask));
+    
+/* GL_VERSION_3_3 */
+  
+typedef void (APIENTRY PFNGLBINDFRAGDATALOCATIONINDEXED_PROC (GLuint program, GLuint colorNumber, GLuint index, const GLchar * name));
+typedef GLint (APIENTRY PFNGLGETFRAGDATAINDEX_PROC (GLuint program, const GLchar * name));
+typedef void (APIENTRY PFNGLGENSAMPLERS_PROC (GLsizei count, GLuint * samplers));
+typedef void (APIENTRY PFNGLDELETESAMPLERS_PROC (GLsizei count, const GLuint * samplers));
+typedef GLboolean (APIENTRY PFNGLISSAMPLER_PROC (GLuint sampler));
+typedef void (APIENTRY PFNGLBINDSAMPLER_PROC (GLuint unit, GLuint sampler));
+typedef void (APIENTRY PFNGLSAMPLERPARAMETERI_PROC (GLuint sampler, GLenum pname, GLint param));
+typedef void (APIENTRY PFNGLSAMPLERPARAMETERIV_PROC (GLuint sampler, GLenum pname, const GLint * param));
+typedef void (APIENTRY PFNGLSAMPLERPARAMETERF_PROC (GLuint sampler, GLenum pname, GLfloat param));
+typedef void (APIENTRY PFNGLSAMPLERPARAMETERFV_PROC (GLuint sampler, GLenum pname, const GLfloat * param));
+typedef void (APIENTRY PFNGLSAMPLERPARAMETERIIV_PROC (GLuint sampler, GLenum pname, const GLint * param));
+typedef void (APIENTRY PFNGLSAMPLERPARAMETERIUIV_PROC (GLuint sampler, GLenum pname, const GLuint * param));
+typedef void (APIENTRY PFNGLGETSAMPLERPARAMETERIV_PROC (GLuint sampler, GLenum pname, GLint * params));
+typedef void (APIENTRY PFNGLGETSAMPLERPARAMETERIIV_PROC (GLuint sampler, GLenum pname, GLint * params));
+typedef void (APIENTRY PFNGLGETSAMPLERPARAMETERFV_PROC (GLuint sampler, GLenum pname, GLfloat * params));
+typedef void (APIENTRY PFNGLGETSAMPLERPARAMETERIUIV_PROC (GLuint sampler, GLenum pname, GLuint * params));
+typedef void (APIENTRY PFNGLQUERYCOUNTER_PROC (GLuint id, GLenum target));
+typedef void (APIENTRY PFNGLGETQUERYOBJECTI64V_PROC (GLuint id, GLenum pname, GLint64 * params));
+typedef void (APIENTRY PFNGLGETQUERYOBJECTUI64V_PROC (GLuint id, GLenum pname, GLuint64 * params));
+typedef void (APIENTRY PFNGLVERTEXATTRIBDIVISOR_PROC (GLuint index, GLuint divisor));
+typedef void (APIENTRY PFNGLVERTEXATTRIBP1UI_PROC (GLuint index, GLenum type, GLboolean normalized, GLuint value));
+typedef void (APIENTRY PFNGLVERTEXATTRIBP1UIV_PROC (GLuint index, GLenum type, GLboolean normalized, const GLuint * value));
+typedef void (APIENTRY PFNGLVERTEXATTRIBP2UI_PROC (GLuint index, GLenum type, GLboolean normalized, GLuint value));
+typedef void (APIENTRY PFNGLVERTEXATTRIBP2UIV_PROC (GLuint index, GLenum type, GLboolean normalized, const GLuint * value));
+typedef void (APIENTRY PFNGLVERTEXATTRIBP3UI_PROC (GLuint index, GLenum type, GLboolean normalized, GLuint value));
+typedef void (APIENTRY PFNGLVERTEXATTRIBP3UIV_PROC (GLuint index, GLenum type, GLboolean normalized, const GLuint * value));
+typedef void (APIENTRY PFNGLVERTEXATTRIBP4UI_PROC (GLuint index, GLenum type, GLboolean normalized, GLuint value));
+typedef void (APIENTRY PFNGLVERTEXATTRIBP4UIV_PROC (GLuint index, GLenum type, GLboolean normalized, const GLuint * value));
+        
+struct OpenGLBindings
+{
+    
+  /* GL_VERSION_1_2 */
+
+  PFNGLDRAWRANGEELEMENTS_PROC* glDrawRangeElements;
+  PFNGLTEXIMAGE3D_PROC* glTexImage3D;
+  PFNGLTEXSUBIMAGE3D_PROC* glTexSubImage3D;
+  PFNGLCOPYTEXSUBIMAGE3D_PROC* glCopyTexSubImage3D;
+    
+  /* GL_VERSION_1_3 */
+
+  PFNGLACTIVETEXTURE_PROC* glActiveTexture;
+  PFNGLSAMPLECOVERAGE_PROC* glSampleCoverage;
+  PFNGLCOMPRESSEDTEXIMAGE3D_PROC* glCompressedTexImage3D;
+  PFNGLCOMPRESSEDTEXIMAGE2D_PROC* glCompressedTexImage2D;
+  PFNGLCOMPRESSEDTEXIMAGE1D_PROC* glCompressedTexImage1D;
+  PFNGLCOMPRESSEDTEXSUBIMAGE3D_PROC* glCompressedTexSubImage3D;
+  PFNGLCOMPRESSEDTEXSUBIMAGE2D_PROC* glCompressedTexSubImage2D;
+  PFNGLCOMPRESSEDTEXSUBIMAGE1D_PROC* glCompressedTexSubImage1D;
+  PFNGLGETCOMPRESSEDTEXIMAGE_PROC* glGetCompressedTexImage;
+    
+  /* GL_VERSION_1_4 */
+
+  PFNGLBLENDFUNCSEPARATE_PROC* glBlendFuncSeparate;
+  PFNGLMULTIDRAWARRAYS_PROC* glMultiDrawArrays;
+  PFNGLMULTIDRAWELEMENTS_PROC* glMultiDrawElements;
+  PFNGLPOINTPARAMETERF_PROC* glPointParameterf;
+  PFNGLPOINTPARAMETERFV_PROC* glPointParameterfv;
+  PFNGLPOINTPARAMETERI_PROC* glPointParameteri;
+  PFNGLPOINTPARAMETERIV_PROC* glPointParameteriv;
+  PFNGLBLENDCOLOR_PROC* glBlendColor;
+  PFNGLBLENDEQUATION_PROC* glBlendEquation;
+    
+  /* GL_VERSION_1_5 */
+
+  PFNGLGENQUERIES_PROC* glGenQueries;
+  PFNGLDELETEQUERIES_PROC* glDeleteQueries;
+  PFNGLISQUERY_PROC* glIsQuery;
+  PFNGLBEGINQUERY_PROC* glBeginQuery;
+  PFNGLENDQUERY_PROC* glEndQuery;
+  PFNGLGETQUERYIV_PROC* glGetQueryiv;
+  PFNGLGETQUERYOBJECTIV_PROC* glGetQueryObjectiv;
+  PFNGLGETQUERYOBJECTUIV_PROC* glGetQueryObjectuiv;
+  PFNGLBINDBUFFER_PROC* glBindBuffer;
+  PFNGLDELETEBUFFERS_PROC* glDeleteBuffers;
+  PFNGLGENBUFFERS_PROC* glGenBuffers;
+  PFNGLISBUFFER_PROC* glIsBuffer;
+  PFNGLBUFFERDATA_PROC* glBufferData;
+  PFNGLBUFFERSUBDATA_PROC* glBufferSubData;
+  PFNGLGETBUFFERSUBDATA_PROC* glGetBufferSubData;
+  PFNGLMAPBUFFER_PROC* glMapBuffer;
+  PFNGLUNMAPBUFFER_PROC* glUnmapBuffer;
+  PFNGLGETBUFFERPARAMETERIV_PROC* glGetBufferParameteriv;
+  PFNGLGETBUFFERPOINTERV_PROC* glGetBufferPointerv;
+    
+  /* GL_VERSION_2_0 */
+
+  PFNGLBLENDEQUATIONSEPARATE_PROC* glBlendEquationSeparate;
+  PFNGLDRAWBUFFERS_PROC* glDrawBuffers;
+  PFNGLSTENCILOPSEPARATE_PROC* glStencilOpSeparate;
+  PFNGLSTENCILFUNCSEPARATE_PROC* glStencilFuncSeparate;
+  PFNGLSTENCILMASKSEPARATE_PROC* glStencilMaskSeparate;
+  PFNGLATTACHSHADER_PROC* glAttachShader;
+  PFNGLBINDATTRIBLOCATION_PROC* glBindAttribLocation;
+  PFNGLCOMPILESHADER_PROC* glCompileShader;
+  PFNGLCREATEPROGRAM_PROC* glCreateProgram;
+  PFNGLCREATESHADER_PROC* glCreateShader;
+  PFNGLDELETEPROGRAM_PROC* glDeleteProgram;
+  PFNGLDELETESHADER_PROC* glDeleteShader;
+  PFNGLDETACHSHADER_PROC* glDetachShader;
+  PFNGLDISABLEVERTEXATTRIBARRAY_PROC* glDisableVertexAttribArray;
+  PFNGLENABLEVERTEXATTRIBARRAY_PROC* glEnableVertexAttribArray;
+  PFNGLGETACTIVEATTRIB_PROC* glGetActiveAttrib;
+  PFNGLGETACTIVEUNIFORM_PROC* glGetActiveUniform;
+  PFNGLGETATTACHEDSHADERS_PROC* glGetAttachedShaders;
+  PFNGLGETATTRIBLOCATION_PROC* glGetAttribLocation;
+  PFNGLGETPROGRAMIV_PROC* glGetProgramiv;
+  PFNGLGETPROGRAMINFOLOG_PROC* glGetProgramInfoLog;
+  PFNGLGETSHADERIV_PROC* glGetShaderiv;
+  PFNGLGETSHADERINFOLOG_PROC* glGetShaderInfoLog;
+  PFNGLGETSHADERSOURCE_PROC* glGetShaderSource;
+  PFNGLGETUNIFORMLOCATION_PROC* glGetUniformLocation;
+  PFNGLGETUNIFORMFV_PROC* glGetUniformfv;
+  PFNGLGETUNIFORMIV_PROC* glGetUniformiv;
+  PFNGLGETVERTEXATTRIBDV_PROC* glGetVertexAttribdv;
+  PFNGLGETVERTEXATTRIBFV_PROC* glGetVertexAttribfv;
+  PFNGLGETVERTEXATTRIBIV_PROC* glGetVertexAttribiv;
+  PFNGLGETVERTEXATTRIBPOINTERV_PROC* glGetVertexAttribPointerv;
+  PFNGLISPROGRAM_PROC* glIsProgram;
+  PFNGLISSHADER_PROC* glIsShader;
+  PFNGLLINKPROGRAM_PROC* glLinkProgram;
+  PFNGLSHADERSOURCE_PROC* glShaderSource;
+  PFNGLUSEPROGRAM_PROC* glUseProgram;
+  PFNGLUNIFORM1F_PROC* glUniform1f;
+  PFNGLUNIFORM2F_PROC* glUniform2f;
+  PFNGLUNIFORM3F_PROC* glUniform3f;
+  PFNGLUNIFORM4F_PROC* glUniform4f;
+  PFNGLUNIFORM1I_PROC* glUniform1i;
+  PFNGLUNIFORM2I_PROC* glUniform2i;
+  PFNGLUNIFORM3I_PROC* glUniform3i;
+  PFNGLUNIFORM4I_PROC* glUniform4i;
+  PFNGLUNIFORM1FV_PROC* glUniform1fv;
+  PFNGLUNIFORM2FV_PROC* glUniform2fv;
+  PFNGLUNIFORM3FV_PROC* glUniform3fv;
+  PFNGLUNIFORM4FV_PROC* glUniform4fv;
+  PFNGLUNIFORM1IV_PROC* glUniform1iv;
+  PFNGLUNIFORM2IV_PROC* glUniform2iv;
+  PFNGLUNIFORM3IV_PROC* glUniform3iv;
+  PFNGLUNIFORM4IV_PROC* glUniform4iv;
+  PFNGLUNIFORMMATRIX2FV_PROC* glUniformMatrix2fv;
+  PFNGLUNIFORMMATRIX3FV_PROC* glUniformMatrix3fv;
+  PFNGLUNIFORMMATRIX4FV_PROC* glUniformMatrix4fv;
+  PFNGLVALIDATEPROGRAM_PROC* glValidateProgram;
+  PFNGLVERTEXATTRIB1D_PROC* glVertexAttrib1d;
+  PFNGLVERTEXATTRIB1DV_PROC* glVertexAttrib1dv;
+  PFNGLVERTEXATTRIB1F_PROC* glVertexAttrib1f;
+  PFNGLVERTEXATTRIB1FV_PROC* glVertexAttrib1fv;
+  PFNGLVERTEXATTRIB1S_PROC* glVertexAttrib1s;
+  PFNGLVERTEXATTRIB1SV_PROC* glVertexAttrib1sv;
+  PFNGLVERTEXATTRIB2D_PROC* glVertexAttrib2d;
+  PFNGLVERTEXATTRIB2DV_PROC* glVertexAttrib2dv;
+  PFNGLVERTEXATTRIB2F_PROC* glVertexAttrib2f;
+  PFNGLVERTEXATTRIB2FV_PROC* glVertexAttrib2fv;
+  PFNGLVERTEXATTRIB2S_PROC* glVertexAttrib2s;
+  PFNGLVERTEXATTRIB2SV_PROC* glVertexAttrib2sv;
+  PFNGLVERTEXATTRIB3D_PROC* glVertexAttrib3d;
+  PFNGLVERTEXATTRIB3DV_PROC* glVertexAttrib3dv;
+  PFNGLVERTEXATTRIB3F_PROC* glVertexAttrib3f;
+  PFNGLVERTEXATTRIB3FV_PROC* glVertexAttrib3fv;
+  PFNGLVERTEXATTRIB3S_PROC* glVertexAttrib3s;
+  PFNGLVERTEXATTRIB3SV_PROC* glVertexAttrib3sv;
+  PFNGLVERTEXATTRIB4NBV_PROC* glVertexAttrib4Nbv;
+  PFNGLVERTEXATTRIB4NIV_PROC* glVertexAttrib4Niv;
+  PFNGLVERTEXATTRIB4NSV_PROC* glVertexAttrib4Nsv;
+  PFNGLVERTEXATTRIB4NUB_PROC* glVertexAttrib4Nub;
+  PFNGLVERTEXATTRIB4NUBV_PROC* glVertexAttrib4Nubv;
+  PFNGLVERTEXATTRIB4NUIV_PROC* glVertexAttrib4Nuiv;
+  PFNGLVERTEXATTRIB4NUSV_PROC* glVertexAttrib4Nusv;
+  PFNGLVERTEXATTRIB4BV_PROC* glVertexAttrib4bv;
+  PFNGLVERTEXATTRIB4D_PROC* glVertexAttrib4d;
+  PFNGLVERTEXATTRIB4DV_PROC* glVertexAttrib4dv;
+  PFNGLVERTEXATTRIB4F_PROC* glVertexAttrib4f;
+  PFNGLVERTEXATTRIB4FV_PROC* glVertexAttrib4fv;
+  PFNGLVERTEXATTRIB4IV_PROC* glVertexAttrib4iv;
+  PFNGLVERTEXATTRIB4S_PROC* glVertexAttrib4s;
+  PFNGLVERTEXATTRIB4SV_PROC* glVertexAttrib4sv;
+  PFNGLVERTEXATTRIB4UBV_PROC* glVertexAttrib4ubv;
+  PFNGLVERTEXATTRIB4UIV_PROC* glVertexAttrib4uiv;
+  PFNGLVERTEXATTRIB4USV_PROC* glVertexAttrib4usv;
+  PFNGLVERTEXATTRIBPOINTER_PROC* glVertexAttribPointer;
+    
+  /* GL_VERSION_2_1 */
+
+  PFNGLUNIFORMMATRIX2X3FV_PROC* glUniformMatrix2x3fv;
+  PFNGLUNIFORMMATRIX3X2FV_PROC* glUniformMatrix3x2fv;
+  PFNGLUNIFORMMATRIX2X4FV_PROC* glUniformMatrix2x4fv;
+  PFNGLUNIFORMMATRIX4X2FV_PROC* glUniformMatrix4x2fv;
+  PFNGLUNIFORMMATRIX3X4FV_PROC* glUniformMatrix3x4fv;
+  PFNGLUNIFORMMATRIX4X3FV_PROC* glUniformMatrix4x3fv;
+    
+  /* GL_VERSION_3_0 */
+
+  PFNGLCOLORMASKI_PROC* glColorMaski;
+  PFNGLGETBOOLEANI_V_PROC* glGetBooleani_v;
+  PFNGLGETINTEGERI_V_PROC* glGetIntegeri_v;
+  PFNGLENABLEI_PROC* glEnablei;
+  PFNGLDISABLEI_PROC* glDisablei;
+  PFNGLISENABLEDI_PROC* glIsEnabledi;
+  PFNGLBEGINTRANSFORMFEEDBACK_PROC* glBeginTransformFeedback;
+  PFNGLENDTRANSFORMFEEDBACK_PROC* glEndTransformFeedback;
+  PFNGLBINDBUFFERRANGE_PROC* glBindBufferRange;
+  PFNGLBINDBUFFERBASE_PROC* glBindBufferBase;
+  PFNGLTRANSFORMFEEDBACKVARYINGS_PROC* glTransformFeedbackVaryings;
+  PFNGLGETTRANSFORMFEEDBACKVARYING_PROC* glGetTransformFeedbackVarying;
+  PFNGLCLAMPCOLOR_PROC* glClampColor;
+  PFNGLBEGINCONDITIONALRENDER_PROC* glBeginConditionalRender;
+  PFNGLENDCONDITIONALRENDER_PROC* glEndConditionalRender;
+  PFNGLVERTEXATTRIBIPOINTER_PROC* glVertexAttribIPointer;
+  PFNGLGETVERTEXATTRIBIIV_PROC* glGetVertexAttribIiv;
+  PFNGLGETVERTEXATTRIBIUIV_PROC* glGetVertexAttribIuiv;
+  PFNGLVERTEXATTRIBI1I_PROC* glVertexAttribI1i;
+  PFNGLVERTEXATTRIBI2I_PROC* glVertexAttribI2i;
+  PFNGLVERTEXATTRIBI3I_PROC* glVertexAttribI3i;
+  PFNGLVERTEXATTRIBI4I_PROC* glVertexAttribI4i;
+  PFNGLVERTEXATTRIBI1UI_PROC* glVertexAttribI1ui;
+  PFNGLVERTEXATTRIBI2UI_PROC* glVertexAttribI2ui;
+  PFNGLVERTEXATTRIBI3UI_PROC* glVertexAttribI3ui;
+  PFNGLVERTEXATTRIBI4UI_PROC* glVertexAttribI4ui;
+  PFNGLVERTEXATTRIBI1IV_PROC* glVertexAttribI1iv;
+  PFNGLVERTEXATTRIBI2IV_PROC* glVertexAttribI2iv;
+  PFNGLVERTEXATTRIBI3IV_PROC* glVertexAttribI3iv;
+  PFNGLVERTEXATTRIBI4IV_PROC* glVertexAttribI4iv;
+  PFNGLVERTEXATTRIBI1UIV_PROC* glVertexAttribI1uiv;
+  PFNGLVERTEXATTRIBI2UIV_PROC* glVertexAttribI2uiv;
+  PFNGLVERTEXATTRIBI3UIV_PROC* glVertexAttribI3uiv;
+  PFNGLVERTEXATTRIBI4UIV_PROC* glVertexAttribI4uiv;
+  PFNGLVERTEXATTRIBI4BV_PROC* glVertexAttribI4bv;
+  PFNGLVERTEXATTRIBI4SV_PROC* glVertexAttribI4sv;
+  PFNGLVERTEXATTRIBI4UBV_PROC* glVertexAttribI4ubv;
+  PFNGLVERTEXATTRIBI4USV_PROC* glVertexAttribI4usv;
+  PFNGLGETUNIFORMUIV_PROC* glGetUniformuiv;
+  PFNGLBINDFRAGDATALOCATION_PROC* glBindFragDataLocation;
+  PFNGLGETFRAGDATALOCATION_PROC* glGetFragDataLocation;
+  PFNGLUNIFORM1UI_PROC* glUniform1ui;
+  PFNGLUNIFORM2UI_PROC* glUniform2ui;
+  PFNGLUNIFORM3UI_PROC* glUniform3ui;
+  PFNGLUNIFORM4UI_PROC* glUniform4ui;
+  PFNGLUNIFORM1UIV_PROC* glUniform1uiv;
+  PFNGLUNIFORM2UIV_PROC* glUniform2uiv;
+  PFNGLUNIFORM3UIV_PROC* glUniform3uiv;
+  PFNGLUNIFORM4UIV_PROC* glUniform4uiv;
+  PFNGLTEXPARAMETERIIV_PROC* glTexParameterIiv;
+  PFNGLTEXPARAMETERIUIV_PROC* glTexParameterIuiv;
+  PFNGLGETTEXPARAMETERIIV_PROC* glGetTexParameterIiv;
+  PFNGLGETTEXPARAMETERIUIV_PROC* glGetTexParameterIuiv;
+  PFNGLCLEARBUFFERIV_PROC* glClearBufferiv;
+  PFNGLCLEARBUFFERUIV_PROC* glClearBufferuiv;
+  PFNGLCLEARBUFFERFV_PROC* glClearBufferfv;
+  PFNGLCLEARBUFFERFI_PROC* glClearBufferfi;
+  PFNGLGETSTRINGI_PROC* glGetStringi;
+  PFNGLISRENDERBUFFER_PROC* glIsRenderbuffer;
+  PFNGLBINDRENDERBUFFER_PROC* glBindRenderbuffer;
+  PFNGLDELETERENDERBUFFERS_PROC* glDeleteRenderbuffers;
+  PFNGLGENRENDERBUFFERS_PROC* glGenRenderbuffers;
+  PFNGLRENDERBUFFERSTORAGE_PROC* glRenderbufferStorage;
+  PFNGLGETRENDERBUFFERPARAMETERIV_PROC* glGetRenderbufferParameteriv;
+  PFNGLISFRAMEBUFFER_PROC* glIsFramebuffer;
+  PFNGLBINDFRAMEBUFFER_PROC* glBindFramebuffer;
+  PFNGLDELETEFRAMEBUFFERS_PROC* glDeleteFramebuffers;
+  PFNGLGENFRAMEBUFFERS_PROC* glGenFramebuffers;
+  PFNGLCHECKFRAMEBUFFERSTATUS_PROC* glCheckFramebufferStatus;
+  PFNGLFRAMEBUFFERTEXTURE1D_PROC* glFramebufferTexture1D;
+  PFNGLFRAMEBUFFERTEXTURE2D_PROC* glFramebufferTexture2D;
+  PFNGLFRAMEBUFFERTEXTURE3D_PROC* glFramebufferTexture3D;
+  PFNGLFRAMEBUFFERRENDERBUFFER_PROC* glFramebufferRenderbuffer;
+  PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIV_PROC* glGetFramebufferAttachmentParameteriv;
+  PFNGLGENERATEMIPMAP_PROC* glGenerateMipmap;
+  PFNGLBLITFRAMEBUFFER_PROC* glBlitFramebuffer;
+  PFNGLRENDERBUFFERSTORAGEMULTISAMPLE_PROC* glRenderbufferStorageMultisample;
+  PFNGLFRAMEBUFFERTEXTURELAYER_PROC* glFramebufferTextureLayer;
+  PFNGLMAPBUFFERRANGE_PROC* glMapBufferRange;
+  PFNGLFLUSHMAPPEDBUFFERRANGE_PROC* glFlushMappedBufferRange;
+  PFNGLBINDVERTEXARRAY_PROC* glBindVertexArray;
+  PFNGLDELETEVERTEXARRAYS_PROC* glDeleteVertexArrays;
+  PFNGLGENVERTEXARRAYS_PROC* glGenVertexArrays;
+  PFNGLISVERTEXARRAY_PROC* glIsVertexArray;
+    
+  /* GL_VERSION_3_1 */
+
+  PFNGLDRAWARRAYSINSTANCED_PROC* glDrawArraysInstanced;
+  PFNGLDRAWELEMENTSINSTANCED_PROC* glDrawElementsInstanced;
+  PFNGLTEXBUFFER_PROC* glTexBuffer;
+  PFNGLPRIMITIVERESTARTINDEX_PROC* glPrimitiveRestartIndex;
+  PFNGLCOPYBUFFERSUBDATA_PROC* glCopyBufferSubData;
+  PFNGLGETUNIFORMINDICES_PROC* glGetUniformIndices;
+  PFNGLGETACTIVEUNIFORMSIV_PROC* glGetActiveUniformsiv;
+  PFNGLGETACTIVEUNIFORMNAME_PROC* glGetActiveUniformName;
+  PFNGLGETUNIFORMBLOCKINDEX_PROC* glGetUniformBlockIndex;
+  PFNGLGETACTIVEUNIFORMBLOCKIV_PROC* glGetActiveUniformBlockiv;
+  PFNGLGETACTIVEUNIFORMBLOCKNAME_PROC* glGetActiveUniformBlockName;
+  PFNGLUNIFORMBLOCKBINDING_PROC* glUniformBlockBinding;
+    
+  /* GL_VERSION_3_2 */
+
+  PFNGLDRAWELEMENTSBASEVERTEX_PROC* glDrawElementsBaseVertex;
+  PFNGLDRAWRANGEELEMENTSBASEVERTEX_PROC* glDrawRangeElementsBaseVertex;
+  PFNGLDRAWELEMENTSINSTANCEDBASEVERTEX_PROC* glDrawElementsInstancedBaseVertex;
+  PFNGLMULTIDRAWELEMENTSBASEVERTEX_PROC* glMultiDrawElementsBaseVertex;
+  PFNGLPROVOKINGVERTEX_PROC* glProvokingVertex;
+  PFNGLFENCESYNC_PROC* glFenceSync;
+  PFNGLISSYNC_PROC* glIsSync;
+  PFNGLDELETESYNC_PROC* glDeleteSync;
+  PFNGLCLIENTWAITSYNC_PROC* glClientWaitSync;
+  PFNGLWAITSYNC_PROC* glWaitSync;
+  PFNGLGETINTEGER64V_PROC* glGetInteger64v;
+  PFNGLGETSYNCIV_PROC* glGetSynciv;
+  PFNGLGETINTEGER64I_V_PROC* glGetInteger64i_v;
+  PFNGLGETBUFFERPARAMETERI64V_PROC* glGetBufferParameteri64v;
+  PFNGLFRAMEBUFFERTEXTURE_PROC* glFramebufferTexture;
+  PFNGLTEXIMAGE2DMULTISAMPLE_PROC* glTexImage2DMultisample;
+  PFNGLTEXIMAGE3DMULTISAMPLE_PROC* glTexImage3DMultisample;
+  PFNGLGETMULTISAMPLEFV_PROC* glGetMultisamplefv;
+  PFNGLSAMPLEMASKI_PROC* glSampleMaski;
+    
+  /* GL_VERSION_3_3 */
+
+  PFNGLBINDFRAGDATALOCATIONINDEXED_PROC* glBindFragDataLocationIndexed;
+  PFNGLGETFRAGDATAINDEX_PROC* glGetFragDataIndex;
+  PFNGLGENSAMPLERS_PROC* glGenSamplers;
+  PFNGLDELETESAMPLERS_PROC* glDeleteSamplers;
+  PFNGLISSAMPLER_PROC* glIsSampler;
+  PFNGLBINDSAMPLER_PROC* glBindSampler;
+  PFNGLSAMPLERPARAMETERI_PROC* glSamplerParameteri;
+  PFNGLSAMPLERPARAMETERIV_PROC* glSamplerParameteriv;
+  PFNGLSAMPLERPARAMETERF_PROC* glSamplerParameterf;
+  PFNGLSAMPLERPARAMETERFV_PROC* glSamplerParameterfv;
+  PFNGLSAMPLERPARAMETERIIV_PROC* glSamplerParameterIiv;
+  PFNGLSAMPLERPARAMETERIUIV_PROC* glSamplerParameterIuiv;
+  PFNGLGETSAMPLERPARAMETERIV_PROC* glGetSamplerParameteriv;
+  PFNGLGETSAMPLERPARAMETERIIV_PROC* glGetSamplerParameterIiv;
+  PFNGLGETSAMPLERPARAMETERFV_PROC* glGetSamplerParameterfv;
+  PFNGLGETSAMPLERPARAMETERIUIV_PROC* glGetSamplerParameterIuiv;
+  PFNGLQUERYCOUNTER_PROC* glQueryCounter;
+  PFNGLGETQUERYOBJECTI64V_PROC* glGetQueryObjecti64v;
+  PFNGLGETQUERYOBJECTUI64V_PROC* glGetQueryObjectui64v;
+  PFNGLVERTEXATTRIBDIVISOR_PROC* glVertexAttribDivisor;
+  PFNGLVERTEXATTRIBP1UI_PROC* glVertexAttribP1ui;
+  PFNGLVERTEXATTRIBP1UIV_PROC* glVertexAttribP1uiv;
+  PFNGLVERTEXATTRIBP2UI_PROC* glVertexAttribP2ui;
+  PFNGLVERTEXATTRIBP2UIV_PROC* glVertexAttribP2uiv;
+  PFNGLVERTEXATTRIBP3UI_PROC* glVertexAttribP3ui;
+  PFNGLVERTEXATTRIBP3UIV_PROC* glVertexAttribP3uiv;
+  PFNGLVERTEXATTRIBP4UI_PROC* glVertexAttribP4ui;
+  PFNGLVERTEXATTRIBP4UIV_PROC* glVertexAttribP4uiv;
+};
+
+typedef struct OpenGLBindings OpenGLBindings;
+
+/* --------------------------- CATEGORY DEFINES ------------------------------ */
+
+#define GL_VERSION_1_0
+#define GL_VERSION_1_1
+#define GL_VERSION_1_2
+#define GL_VERSION_1_3
+#define GL_VERSION_1_4
+#define GL_VERSION_1_5
+#define GL_VERSION_2_0
+#define GL_VERSION_2_1
+#define GL_VERSION_3_0
+#define GL_VERSION_3_1
+#define GL_VERSION_3_2
+#define GL_VERSION_3_3
+
+/* ---------------------- Flags for optional extensions ---------------------- */
+
+
+
+struct GLFWwindow;
+typedef struct GLFWwindow GLFWwindow;
+
+int flextInit(GLFWwindow* window, OpenGLBindings *bindings);
+
+#define FLEXT_MAJOR_VERSION 3
+#define FLEXT_MINOR_VERSION 3
+#define FLEXT_CORE_PROFILE 1
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _gl_h_ */
diff --git a/examples/protonect/src/shader/grayrender.fs b/examples/protonect/src/shader/grayrender.fs
new file mode 100644
index 000000000..416eadf46
--- /dev/null
+++ b/examples/protonect/src/shader/grayrender.fs
@@ -0,0 +1,20 @@
+#version 330
+
+uniform sampler2DRect Data;
+
+vec4 tempColor;
+
+in VertexData {
+    vec2 TexCoord;
+} FragmentIn;
+
+layout(location = 0) out vec4 Color;
+
+void main(void)
+{
+  ivec2 uv = ivec2(FragmentIn.TexCoord.x, FragmentIn.TexCoord.y);
+  
+  tempColor = texelFetch(Data, uv);
+
+  Color = vec4(tempColor.x,tempColor.x,tempColor.x,1);
+}
\ No newline at end of file
diff --git a/examples/protonect/src/shader/render.fs b/examples/protonect/src/shader/render.fs
new file mode 100644
index 000000000..34dac1298
--- /dev/null
+++ b/examples/protonect/src/shader/render.fs
@@ -0,0 +1,16 @@
+#version 330
+
+uniform sampler2DRect Data;
+
+in VertexData {
+    vec2 TexCoord;
+} FragmentIn;
+
+layout(location = 0) out vec4 Color;
+
+void main(void)
+{
+  ivec2 uv = ivec2(FragmentIn.TexCoord.x, FragmentIn.TexCoord.y);
+  
+  Color = texelFetch(Data, uv);
+}
\ No newline at end of file
diff --git a/examples/protonect/src/shader/render.vs b/examples/protonect/src/shader/render.vs
new file mode 100644
index 000000000..b351e266a
--- /dev/null
+++ b/examples/protonect/src/shader/render.vs
@@ -0,0 +1,14 @@
+#version 330
+
+in vec2 Position;
+in vec2 TexCoord;
+
+out VertexData {
+  vec2 TexCoord;
+} VertexOut;
+
+void main(void) 
+{
+  gl_Position = vec4(Position, 0.0, 1.0);
+  VertexOut.TexCoord = TexCoord;
+}
\ No newline at end of file
diff --git a/examples/protonect/viewer.cpp b/examples/protonect/viewer.cpp
new file mode 100644
index 000000000..7a031f5e0
--- /dev/null
+++ b/examples/protonect/viewer.cpp
@@ -0,0 +1,196 @@
+#include "viewer.h"
+
+Viewer::Viewer() : shader_folder("src/shader/")
+{
+    // init glfw - if already initialized nothing happens
+    int init = glfwInit();
+
+    // setup context
+    glfwDefaultWindowHints();
+    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
+    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
+#ifdef __APPLE__
+    glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
+#endif
+    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
+    //glfwWindowHint(GLFW_VISIBLE, debug ? GL_TRUE : GL_FALSE);
+
+    window = glfwCreateWindow(1280, 800, "Viewer", 0, NULL);
+
+    triangle_vbo = NULL;
+    triangle_vao = NULL;
+}
+
+void Viewer::initialize()
+{
+    glfwMakeContextCurrent(window);
+    OpenGLBindings *b = new OpenGLBindings();
+    flextInit(window, b);
+    gl(b);
+
+    std::string vertexshadersrc = ""
+        "#version 330\n"
+                                                \
+        "in vec2 Position;"
+        "in vec2 TexCoord;"
+                    
+        "out VertexData{"
+        "vec2 TexCoord;" 
+        "} VertexOut;"  
+                    
+        "void main(void)"
+        "{"
+        "    gl_Position = vec4(Position, 0.0, 1.0);"
+        "    VertexOut.TexCoord = TexCoord;"
+        "}";
+    std::string grayfragmentshader = ""
+        "#version 330\n"
+        
+        "uniform sampler2DRect Data;"
+        
+        "vec4 tempColor;"
+        "in VertexData{"
+        "    vec2 TexCoord;"
+        "} FragmentIn;"
+        
+        "layout(location = 0) out vec4 Color;"
+        
+        "void main(void)"
+        "{"
+            "ivec2 uv = ivec2(FragmentIn.TexCoord.x, FragmentIn.TexCoord.y);"
+            "tempColor = texelFetch(Data, uv);"
+            "Color = vec4(tempColor.x, tempColor.x, tempColor.x, 1);"
+        "}";
+    std::string fragmentshader = ""
+        "#version 330\n"
+        
+        "uniform sampler2DRect Data;"
+        
+        "in VertexData{"
+        "    vec2 TexCoord;"
+        "} FragmentIn;"
+       
+        "layout(location = 0) out vec4 Color;"
+        
+        "void main(void)"
+        "{"
+        "    ivec2 uv = ivec2(FragmentIn.TexCoord.x, FragmentIn.TexCoord.y);"
+
+        "    Color = texelFetch(Data, uv);"
+        "}";
+
+    renderShader.setVertexShader(vertexshadersrc);
+    renderShader.setFragmentShader(fragmentshader);
+    renderShader.build();
+
+    renderGrayShader.setVertexShader(vertexshadersrc);
+    renderGrayShader.setFragmentShader(grayfragmentshader);
+    renderGrayShader.build();
+
+
+    glfwSetWindowUserPointer(window, this);
+    glfwSetKeyCallback(window, Viewer::key_callbackstatic);
+
+    shouldStop = false;
+}
+
+void Viewer::key_callbackstatic(GLFWwindow* window, int key, int scancode, int action, int mods)
+{
+    Viewer* viewer = reinterpret_cast<Viewer*>(glfwGetWindowUserPointer(window));
+    viewer->key_callback(window, key, scancode, action, mods);
+}
+
+void Viewer::key_callback(GLFWwindow* window, int key, int scancode, int action, int mods)
+{
+    if (key == GLFW_KEY_ESCAPE && action == GLFW_PRESS)
+        shouldStop = true;
+}
+
+void Viewer::onOpenGLBindingsChanged(OpenGLBindings *b)
+{
+    renderShader.gl(b);
+    renderGrayShader.gl(b);
+    rgb.gl(b);
+    ir.gl(b);
+}
+
+bool Viewer::render()
+{
+    // wipe the drawing surface clear
+    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
+    GLint x = 0, y = 0, width = 600, height = 400;
+
+    std::map<std::string, libfreenect2::Frame*>::iterator iter;
+
+    for (iter = frames.begin(); iter != frames.end(); ++iter)
+    {
+        libfreenect2::Frame* frame = iter->second;
+
+        glViewport(x, y, width, height);
+        x += width;
+        if (x >= 1024)
+        {
+            x = 0;
+            y += height;
+        }
+
+        Vertex bl = { -1.0f, -1.0f, 0.0f, 0.0f }, br = { 1.0f, -1.0f, frame->width, 0.0f }, tl = { -1.0f, 1.0f, 0.0f, frame->height }, tr = { 1.0f, 1.0f, frame->width, frame->height };
+        Vertex vertices[] = {
+            bl, tl, tr, tr, br, bl
+        };
+
+        gl()->glGenBuffers(1, &triangle_vbo);
+        gl()->glGenVertexArrays(1, &triangle_vao);
+
+        gl()->glBindVertexArray(triangle_vao);
+        gl()->glBindBuffer(GL_ARRAY_BUFFER, triangle_vbo);
+        gl()->glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
+
+        GLint position_attr = renderShader.getAttributeLocation("Position");
+        gl()->glVertexAttribPointer(position_attr, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), (GLvoid*)0);
+        gl()->glEnableVertexAttribArray(position_attr);
+
+        GLint texcoord_attr = renderShader.getAttributeLocation("TexCoord");
+        gl()->glVertexAttribPointer(texcoord_attr, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), (GLvoid*)(2 * sizeof(float)));
+        gl()->glEnableVertexAttribArray(texcoord_attr);
+
+
+        if (iter->first == "RGB" || iter->first == "registered")
+        {
+            renderShader.use();
+
+            rgb.allocate(frame->width, frame->height);
+            std::copy(frame->data, frame->data + frame->width * frame->height * frame->bytes_per_pixel, rgb.data);
+            rgb.flipY();
+            rgb.upload();
+            glDrawArrays(GL_TRIANGLES, 0, 6);
+
+            rgb.deallocate();
+
+        }
+        else
+        {
+            renderGrayShader.use();
+
+            ir.allocate(frame->width, frame->height);
+            std::copy(frame->data, frame->data + frame->width * frame->height * frame->bytes_per_pixel, ir.data);
+            ir.flipY();
+            ir.upload();
+            glDrawArrays(GL_TRIANGLES, 0, 6);
+            ir.deallocate();
+        }
+    }
+
+    // put the stuff we've been drawing onto the display
+    glfwSwapBuffers(window);
+    // update other events like input handling 
+    glfwPollEvents();
+
+    return shouldStop || glfwWindowShouldClose(window);
+}
+
+void Viewer::AddFrame(std::string id, libfreenect2::Frame* frame)
+{
+    frames[id] = frame;
+}
\ No newline at end of file
diff --git a/examples/protonect/viewer.h b/examples/protonect/viewer.h
new file mode 100644
index 000000000..5dcc22897
--- /dev/null
+++ b/examples/protonect/viewer.h
@@ -0,0 +1,289 @@
+#ifndef VIEWER_H
+#define VIEWER_H
+
+#include <iostream>
+
+#include <libfreenect2/config.h>
+#include <libfreenect2/frame_listener.hpp>
+#include <string>
+#include <map>
+
+#include "flextGL.h"
+#include <GLFW/glfw3.h>
+
+struct Vertex
+{
+    float x, y;
+    float u, v;
+};
+
+class WithOpenGLBindings
+{
+private:
+    OpenGLBindings *bindings;
+protected:
+    WithOpenGLBindings() : bindings(0) {}
+    virtual ~WithOpenGLBindings() {}
+
+    virtual void onOpenGLBindingsChanged(OpenGLBindings *b) { }
+public:
+    void gl(OpenGLBindings *bindings)
+    {
+        this->bindings = bindings;
+        onOpenGLBindingsChanged(this->bindings);
+    }
+
+    OpenGLBindings *gl()
+    {
+        return bindings;
+    }
+};
+
+template<size_t TBytesPerPixel, GLenum TInternalFormat, GLenum TFormat, GLenum TType>
+struct ImageFormat
+{
+    static const size_t BytesPerPixel = TBytesPerPixel;
+    static const GLenum InternalFormat = TInternalFormat;
+    static const GLenum Format = TFormat;
+    static const GLenum Type = TType;
+};
+
+typedef ImageFormat<1, GL_R8UI, GL_RED_INTEGER, GL_UNSIGNED_BYTE> U8C1;
+typedef ImageFormat<2, GL_R16I, GL_RED_INTEGER, GL_SHORT> S16C1;
+typedef ImageFormat<2, GL_R16UI, GL_RED_INTEGER, GL_UNSIGNED_SHORT> U16C1;
+typedef ImageFormat<4, GL_R32F, GL_RED, GL_FLOAT> F32C1;
+typedef ImageFormat<8, GL_RG32F, GL_RG, GL_FLOAT> F32C2;
+typedef ImageFormat<12, GL_RGB32F, GL_RGB, GL_FLOAT> F32C3;
+typedef ImageFormat<4, GL_RGBA, GL_BGRA, GL_UNSIGNED_BYTE> F8C4;
+typedef ImageFormat<16, GL_RGBA32F, GL_RGBA, GL_FLOAT> F32C4;
+
+template<typename FormatT>
+struct Texture : public WithOpenGLBindings
+{
+protected:
+    size_t bytes_per_pixel, height, width;
+
+public:
+    GLuint texture;
+    unsigned char *data;
+    size_t size;
+
+    Texture() : texture(0), data(0), size(0), bytes_per_pixel(FormatT::BytesPerPixel), height(0), width(0)
+    {
+    }
+
+    void bindToUnit(GLenum unit)
+    {
+        gl()->glActiveTexture(unit);
+        glBindTexture(GL_TEXTURE_RECTANGLE, texture);
+    }
+
+    void allocate(size_t new_width, size_t new_height)
+    {
+        width = new_width;
+        height = new_height;
+        size = height * width * bytes_per_pixel;
+        data = new unsigned char[size];
+
+        glGenTextures(1, &texture);
+        bindToUnit(GL_TEXTURE0);
+        glTexParameteri(GL_TEXTURE_RECTANGLE, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
+        glTexParameteri(GL_TEXTURE_RECTANGLE, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
+        glTexParameteri(GL_TEXTURE_RECTANGLE, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+        glTexParameteri(GL_TEXTURE_RECTANGLE, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+        glTexImage2D(GL_TEXTURE_RECTANGLE, 0, FormatT::InternalFormat, width, height, 0, FormatT::Format, FormatT::Type, 0);
+    }
+
+    void deallocate()
+    {
+        glDeleteTextures(1, &texture);
+        delete[] data;
+    }
+
+    void upload()
+    {
+        bindToUnit(GL_TEXTURE0);
+        glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+        glTexSubImage2D(GL_TEXTURE_RECTANGLE, /*level*/0, /*xoffset*/0, /*yoffset*/0, width, height, FormatT::Format, FormatT::Type, data);
+    }
+
+    void download()
+    {
+        downloadToBuffer(data);
+    }
+
+    void downloadToBuffer(unsigned char *data)
+    {
+        glReadPixels(0, 0, width, height, FormatT::Format, FormatT::Type, data);
+    }
+
+    void flipY()
+    {
+        flipYBuffer(data);
+    }
+
+    void flipYBuffer(unsigned char *data)
+    {
+        typedef unsigned char type;
+
+        int linestep = width * bytes_per_pixel / sizeof(type);
+
+        type *first_line = reinterpret_cast<type *>(data), *last_line = reinterpret_cast<type *>(data) + (height - 1) * linestep;
+
+        for (int y = 0; y < height / 2; ++y)
+        {
+            for (int x = 0; x < linestep; ++x, ++first_line, ++last_line)
+            {
+                std::swap(*first_line, *last_line);
+            }
+            last_line -= 2 * linestep;
+        }
+    }
+
+    libfreenect2::Frame *downloadToNewFrame()
+    {
+        libfreenect2::Frame *f = new libfreenect2::Frame(width, height, bytes_per_pixel);
+        downloadToBuffer(f->data);
+        flipYBuffer(f->data);
+
+        return f;
+    }
+};
+
+struct ShaderProgram : public WithOpenGLBindings
+{
+    GLuint program, vertex_shader, fragment_shader;
+
+    char error_buffer[2048];
+
+    ShaderProgram() :
+        program(0),
+        vertex_shader(0),
+        fragment_shader(0)
+    {
+    }
+
+    void setVertexShader(const std::string& src)
+    {
+        const char* src_ = src.c_str();
+        int length_ = src.length();
+        vertex_shader = gl()->glCreateShader(GL_VERTEX_SHADER);
+        gl()->glShaderSource(vertex_shader, 1, &src_, &length_);
+    }
+
+    void setFragmentShader(const std::string& src)
+    {
+        const char* src_ = src.c_str();
+        int length_ = src.length();
+        fragment_shader = gl()->glCreateShader(GL_FRAGMENT_SHADER);
+        gl()->glShaderSource(fragment_shader, 1, &src_, &length_);
+    }
+
+    void build()
+    {
+        GLint status;
+
+        gl()->glCompileShader(vertex_shader);
+        gl()->glGetShaderiv(vertex_shader, GL_COMPILE_STATUS, &status);
+
+        if (status != GL_TRUE)
+        {
+            gl()->glGetShaderInfoLog(vertex_shader, sizeof(error_buffer), NULL, error_buffer);
+
+            std::cerr << "[ShaderProgram::build] failed to compile vertex shader!" << std::endl;
+            std::cerr << error_buffer << std::endl;
+        }
+
+        gl()->glCompileShader(fragment_shader);
+
+        gl()->glGetShaderiv(fragment_shader, GL_COMPILE_STATUS, &status);
+        if (status != GL_TRUE)
+        {
+            gl()->glGetShaderInfoLog(fragment_shader, sizeof(error_buffer), NULL, error_buffer);
+
+            std::cerr << "[ShaderProgram::build] failed to compile fragment shader!" << std::endl;
+            std::cerr << error_buffer << std::endl;
+        }
+
+        program = gl()->glCreateProgram();
+        gl()->glAttachShader(program, vertex_shader);
+        gl()->glAttachShader(program, fragment_shader);
+
+        gl()->glLinkProgram(program);
+
+        gl()->glGetProgramiv(program, GL_LINK_STATUS, &status);
+
+        if (status != GL_TRUE)
+        {
+            gl()->glGetProgramInfoLog(program, sizeof(error_buffer), NULL, error_buffer);
+            std::cerr << "[ShaderProgram::build] failed to link shader program!" << std::endl;
+            std::cerr << error_buffer << std::endl;
+        }
+    }
+
+    GLint getAttributeLocation(const std::string& name)
+    {
+        return gl()->glGetAttribLocation(program, name.c_str());
+    }
+
+    void setUniform(const std::string& name, GLint value)
+    {
+        GLint idx = gl()->glGetUniformLocation(program, name.c_str());
+        if (idx == -1) return;
+
+        gl()->glUniform1i(idx, value);
+    }
+
+    void setUniform(const std::string& name, GLfloat value)
+    {
+        GLint idx = gl()->glGetUniformLocation(program, name.c_str());
+        if (idx == -1) return;
+
+        gl()->glUniform1f(idx, value);
+    }
+
+    void setUniformVector3(const std::string& name, GLfloat value[3])
+    {
+        GLint idx = gl()->glGetUniformLocation(program, name.c_str());
+        if (idx == -1) return;
+
+        gl()->glUniform3fv(idx, 1, value);
+    }
+
+    void setUniformMatrix3(const std::string& name, GLfloat value[9])
+    {
+        GLint idx = gl()->glGetUniformLocation(program, name.c_str());
+        if (idx == -1) return;
+
+        gl()->glUniformMatrix3fv(idx, 1, false, value);
+    }
+
+    void use()
+    {
+        gl()->glUseProgram(program);
+    }
+};
+
+class Viewer : WithOpenGLBindings {
+private:
+    bool shouldStop;
+    GLFWwindow* window;
+    GLuint triangle_vbo, triangle_vao;
+    ShaderProgram renderShader;
+    ShaderProgram renderGrayShader;
+	std::string shader_folder;
+    std::map<std::string,libfreenect2::Frame*> frames;
+    Texture<F8C4> rgb;
+    Texture<F32C1> ir;
+public:
+    Viewer();
+    void initialize();
+    virtual void onOpenGLBindingsChanged(OpenGLBindings *b);
+    bool render();
+    void AddFrame(std::string id,libfreenect2::Frame* frame);
+    void testMethod(libfreenect2::Frame* frame);
+    void key_callback(GLFWwindow* window, int key, int scancode, int action, int mods);
+    static void key_callbackstatic(GLFWwindow* window, int key, int scancode, int action, int mods);
+};
+
+#endif
\ No newline at end of file

From bc9c70676bfd5fb5e8f98409b774982ebfaab2c2 Mon Sep 17 00:00:00 2001
From: larshg <larshg@gmail.com>
Date: Tue, 16 Jun 2015 22:38:43 +0200
Subject: [PATCH 5/8] started to make opencv optional

---
 examples/protonect/CMakeLists.txt             |  9 +++++----
 examples/protonect/Protonect.cpp              | 19 +++++++++++++-----
 .../include/libfreenect2/config.h.in          |  2 ++
 .../src/cpu_depth_packet_processor.cpp        |  2 ++
 examples/protonect/src/shader/grayrender.fs   | 20 -------------------
 examples/protonect/src/shader/render.fs       | 16 ---------------
 examples/protonect/src/shader/render.vs       | 14 -------------
 .../src/turbo_jpeg_rgb_packet_processor.cpp   |  8 +++++++-
 8 files changed, 30 insertions(+), 60 deletions(-)
 delete mode 100644 examples/protonect/src/shader/grayrender.fs
 delete mode 100644 examples/protonect/src/shader/render.fs
 delete mode 100644 examples/protonect/src/shader/render.vs

diff --git a/examples/protonect/CMakeLists.txt b/examples/protonect/CMakeLists.txt
index cc8a1ae1a..7c96f9d74 100644
--- a/examples/protonect/CMakeLists.txt
+++ b/examples/protonect/CMakeLists.txt
@@ -40,9 +40,13 @@ SET(LIBRARY_OUTPUT_PATH ${MY_DIR}/lib)
 # dependencies
 FIND_PACKAGE(PkgConfig)    # try find PKGConfig as it will be used if found
 FIND_PACKAGE(LibUSB REQUIRED)
-FIND_PACKAGE(OpenCV REQUIRED)
+FIND_PACKAGE(OpenCV)
 FIND_PACKAGE(TurboJPEG REQUIRED) #does not provide a package-config file
 
+IF(OPENCV_FOUND)
+    SET(LIBFREENECT2_OPENCV_FOUND 1)
+ENDIF()
+
 # Add includes
 INCLUDE_DIRECTORIES(
   "${MY_DIR}/include"
@@ -140,9 +144,6 @@ IF(ENABLE_OPENGL)
     src/shader/filter2.fs
     src/shader/stage1.fs
     src/shader/stage2.fs
-    src/shader/render.fs
-    src/shader/grayrender.fs
-    src/shader/render.vs
   )
   ENDIF()
 ENDIF(ENABLE_OPENGL)
diff --git a/examples/protonect/Protonect.cpp b/examples/protonect/Protonect.cpp
index 5d2a66312..1341b77b2 100644
--- a/examples/protonect/Protonect.cpp
+++ b/examples/protonect/Protonect.cpp
@@ -28,8 +28,6 @@
 #include <iostream>
 #include <signal.h>
 
-#include <opencv2/opencv.hpp>
-
 #include <libfreenect2/libfreenect2.hpp>
 #include <libfreenect2/frame_listener_impl.h>
 #include <libfreenect2/threading.h>
@@ -37,6 +35,11 @@
 #include <libfreenect2/packet_pipeline.h>
 #include "viewer.h"
 
+#ifdef LIBFREENECT2_OPENCV_FOUND
+#include <opencv2/opencv.hpp>
+#endif
+
+
 bool protonect_shutdown = false;
 
 void sigint_handler(int s)
@@ -148,16 +151,22 @@ int main(int argc, char *argv[])
 
     registration->apply(rgb, depth, &undistorted, &registered);
 
+#if defined(LIBFREENECT2_WITH_OPENGL_SUPPORT) && !defined(LIBFREENECT2_OPENCV_FOUND)
     viewer.AddFrame("RGB", rgb);
     viewer.AddFrame("ir", ir);
     viewer.AddFrame("depth", depth);
     viewer.AddFrame("registered", &registered);
 
-    if (viewer.render())
-        break;
-
+    protonect_shutdown = viewer.render();
+#else
+    cv::imshow("rgb", cv::Mat(rgb->height, rgb->width, CV_8UC4, rgb->data));
+    cv::imshow("ir", cv::Mat(ir->height, ir->width, CV_32FC1, ir->data) / 20000.0f);
+    cv::imshow("depth", cv::Mat(depth->height, depth->width, CV_32FC1, depth->data) / 4500.0f);
+    cv::imshow("undistorted", cv::Mat(undistorted.height, undistorted.width, CV_32FC1, undistorted.data) / 4500.0f);
+    cv::imshow("registered", cv::Mat(registered.height, registered.width, CV_8UC4, registered.data));
     int key = cv::waitKey(1);
     protonect_shutdown = protonect_shutdown || (key > 0 && ((key & 0xFF) == 27)); // shutdown on escape
+#endif
 
     listener.release(frames);
     //libfreenect2::this_thread::sleep_for(libfreenect2::chrono::milliseconds(100));
diff --git a/examples/protonect/include/libfreenect2/config.h.in b/examples/protonect/include/libfreenect2/config.h.in
index f3abf7d43..3ee715bd2 100644
--- a/examples/protonect/include/libfreenect2/config.h.in
+++ b/examples/protonect/include/libfreenect2/config.h.in
@@ -47,4 +47,6 @@
 
 #cmakedefine LIBFREENECT2_THREADING_TINYTHREAD
 
+#cmakedefine LIBFREENECT2_OPENCV_FOUND
+
 #endif // LIBFREENECT2_CONFIG_H
diff --git a/examples/protonect/src/cpu_depth_packet_processor.cpp b/examples/protonect/src/cpu_depth_packet_processor.cpp
index 2638f0607..52f2a3fbc 100644
--- a/examples/protonect/src/cpu_depth_packet_processor.cpp
+++ b/examples/protonect/src/cpu_depth_packet_processor.cpp
@@ -28,7 +28,9 @@
 #include <libfreenect2/resource.h>
 #include <libfreenect2/protocol/response.h>
 
+#ifdef LIBFREENECT2_OPENCV_FOUND
 #include <opencv2/opencv.hpp>
+#endif
 #include <iostream>
 #include <fstream>
 
diff --git a/examples/protonect/src/shader/grayrender.fs b/examples/protonect/src/shader/grayrender.fs
deleted file mode 100644
index 416eadf46..000000000
--- a/examples/protonect/src/shader/grayrender.fs
+++ /dev/null
@@ -1,20 +0,0 @@
-#version 330
-
-uniform sampler2DRect Data;
-
-vec4 tempColor;
-
-in VertexData {
-    vec2 TexCoord;
-} FragmentIn;
-
-layout(location = 0) out vec4 Color;
-
-void main(void)
-{
-  ivec2 uv = ivec2(FragmentIn.TexCoord.x, FragmentIn.TexCoord.y);
-  
-  tempColor = texelFetch(Data, uv);
-
-  Color = vec4(tempColor.x,tempColor.x,tempColor.x,1);
-}
\ No newline at end of file
diff --git a/examples/protonect/src/shader/render.fs b/examples/protonect/src/shader/render.fs
deleted file mode 100644
index 34dac1298..000000000
--- a/examples/protonect/src/shader/render.fs
+++ /dev/null
@@ -1,16 +0,0 @@
-#version 330
-
-uniform sampler2DRect Data;
-
-in VertexData {
-    vec2 TexCoord;
-} FragmentIn;
-
-layout(location = 0) out vec4 Color;
-
-void main(void)
-{
-  ivec2 uv = ivec2(FragmentIn.TexCoord.x, FragmentIn.TexCoord.y);
-  
-  Color = texelFetch(Data, uv);
-}
\ No newline at end of file
diff --git a/examples/protonect/src/shader/render.vs b/examples/protonect/src/shader/render.vs
deleted file mode 100644
index b351e266a..000000000
--- a/examples/protonect/src/shader/render.vs
+++ /dev/null
@@ -1,14 +0,0 @@
-#version 330
-
-in vec2 Position;
-in vec2 TexCoord;
-
-out VertexData {
-  vec2 TexCoord;
-} VertexOut;
-
-void main(void) 
-{
-  gl_Position = vec4(Position, 0.0, 1.0);
-  VertexOut.TexCoord = TexCoord;
-}
\ No newline at end of file
diff --git a/examples/protonect/src/turbo_jpeg_rgb_packet_processor.cpp b/examples/protonect/src/turbo_jpeg_rgb_packet_processor.cpp
index c93bec9c7..6c35e6e25 100644
--- a/examples/protonect/src/turbo_jpeg_rgb_packet_processor.cpp
+++ b/examples/protonect/src/turbo_jpeg_rgb_packet_processor.cpp
@@ -25,9 +25,11 @@
  */
 
 #include <libfreenect2/rgb_packet_processor.h>
-
+#ifdef LIBFREENECT2_OPENCV_FOUND
 #include <opencv2/opencv.hpp>
+#endif
 #include <turbojpeg.h>
+#include <iostream>
 
 namespace libfreenect2
 {
@@ -78,11 +80,14 @@ class TurboJpegRgbPacketProcessorImpl
 
   void startTiming()
   {
+#ifdef LIBFREENECT2_OPENCV_FOUND
     timing_current_start = cv::getTickCount();
+#endif
   }
 
   void stopTiming()
   {
+#ifdef LIBFREENECT2_OPENCV_FOUND
     timing_acc += (cv::getTickCount() - timing_current_start) / cv::getTickFrequency();
     timing_acc_n += 1.0;
 
@@ -93,6 +98,7 @@ class TurboJpegRgbPacketProcessorImpl
       timing_acc = 0.0;
       timing_acc_n = 0.0;
     }
+#endif
   }
 };
 

From 74da6c6c1d145d473ac436509d660939122897db Mon Sep 17 00:00:00 2001
From: larshg <larshg@gmail.com>
Date: Wed, 17 Jun 2015 08:21:20 +0200
Subject: [PATCH 6/8] temp

---
 examples/protonect/Protonect.cpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/examples/protonect/Protonect.cpp b/examples/protonect/Protonect.cpp
index 6c4941af5..710405566 100644
--- a/examples/protonect/Protonect.cpp
+++ b/examples/protonect/Protonect.cpp
@@ -142,15 +142,15 @@ int main(int argc, char *argv[])
     libfreenect2::Frame *ir = frames[libfreenect2::Frame::Ir];
     libfreenect2::Frame *depth = frames[libfreenect2::Frame::Depth];
 
-    cv::imshow("rgb", cv::Mat(rgb->height, rgb->width, CV_8UC4, rgb->data));
+    //cv::imshow("rgb", cv::Mat(rgb->height, rgb->width, CV_8UC4, rgb->data));
     //cv::imshow("ir", cv::Mat(ir->height, ir->width, CV_32FC1, ir->data) / 20000.0f);
     //cv::imshow("depth", cv::Mat(depth->height, depth->width, CV_32FC1, depth->data) / 4500.0f);
 
     registration->apply(rgb,depth,&undistorted,&registered);
 
-    cv::imshow("undistorted", cv::Mat(undistorted.height, undistorted.width, CV_32FC1, undistorted.data) / 4500.0f);
-    cv::imshow("registered", cv::Mat(registered.height, registered.width, CV_8UC4, registered.data));
-
+    //cv::imshow("undistorted", cv::Mat(undistorted.height, undistorted.width, CV_32FC1, undistorted.data) / 4500.0f);
+    //cv::imshow("registered", cv::Mat(registered.height, registered.width, CV_8UC4, registered.data));
+    int key = 1;
     protonect_shutdown = protonect_shutdown || (key > 0 && ((key & 0xFF) == 27)); // shutdown on escape
 
     listener.release(frames);

From e4116edea5dca2e70f828403fc5ca5343247e097 Mon Sep 17 00:00:00 2001
From: larshg <larshg@gmail.com>
Date: Wed, 17 Jun 2015 17:50:56 +0200
Subject: [PATCH 7/8] Removed dublicate of flextGL .c/.h

Renamed AddFrame to addFrame.
Added define for opencv to be able to use either opencv or opengl.
---
 examples/protonect/CMakeLists.txt             |    2 +-
 examples/protonect/Protonect.cpp              |   17 +-
 examples/protonect/flextGL.c                  |  367 ----
 examples/protonect/flextGL.h                  | 1664 -----------------
 .../src/cpu_depth_packet_processor.cpp        |    2 -
 .../src/turbo_jpeg_rgb_packet_processor.cpp   |    2 +-
 examples/protonect/viewer.cpp                 |    4 +-
 examples/protonect/viewer.h                   |    5 +-
 8 files changed, 17 insertions(+), 2046 deletions(-)
 delete mode 100644 examples/protonect/flextGL.c
 delete mode 100644 examples/protonect/flextGL.h

diff --git a/examples/protonect/CMakeLists.txt b/examples/protonect/CMakeLists.txt
index 56300f887..e8485a336 100644
--- a/examples/protonect/CMakeLists.txt
+++ b/examples/protonect/CMakeLists.txt
@@ -193,7 +193,7 @@ IF (ENABLE_OPENGL AND OPENGL_FOUND)
     LIST(APPEND Protonect_src
         viewer.h
         viewer.cpp
-        flextGL.c
+        src/flextGL.c
         )
 ENDIF()
   
diff --git a/examples/protonect/Protonect.cpp b/examples/protonect/Protonect.cpp
index cf44ea788..943fd2309 100644
--- a/examples/protonect/Protonect.cpp
+++ b/examples/protonect/Protonect.cpp
@@ -33,7 +33,9 @@
 #include <libfreenect2/threading.h>
 #include <libfreenect2/registration.h>
 #include <libfreenect2/packet_pipeline.h>
+#ifdef LIBFREENECT2_WITH_OPENGL_SUPPORT
 #include "viewer.h"
+#endif
 
 #ifdef LIBFREENECT2_OPENCV_FOUND
 #include <opencv2/opencv.hpp>
@@ -152,15 +154,18 @@ int main(int argc, char *argv[])
     registration->apply(rgb, depth, &undistorted, &registered);
 
 #if defined(LIBFREENECT2_WITH_OPENGL_SUPPORT) && !defined(LIBFREENECT2_OPENCV_FOUND)
-    viewer.AddFrame("RGB", rgb);
-    viewer.AddFrame("ir", ir);
-    viewer.AddFrame("depth", depth);
-    viewer.AddFrame("registered", &registered);
+    viewer.addFrame("RGB", rgb);
+    viewer.addFrame("ir", ir);
+    viewer.addFrame("depth", depth);
+    viewer.addFrame("registered", &registered);
 
     protonect_shutdown = viewer.render();
 #else
-    //cv::imshow("undistorted", cv::Mat(undistorted.height, undistorted.width, CV_32FC1, undistorted.data) / 4500.0f);
-    //cv::imshow("registered", cv::Mat(registered.height, registered.width, CV_8UC4, registered.data));
+    cv::imshow("rgb", cv::Mat(rgb->height, rgb->width, CV_8UC4, rgb->data));
+    cv::imshow("ir", cv::Mat(ir->height, ir->width, CV_32FC1, ir->data) / 20000.0f);
+    cv::imshow("depth", cv::Mat(depth->height, depth->width, CV_32FC1, depth->data) / 4500.0f);
+    cv::imshow("undistorted", cv::Mat(undistorted.height, undistorted.width, CV_32FC1, undistorted.data) / 4500.0f);
+    cv::imshow("registered", cv::Mat(registered.height, registered.width, CV_8UC4, registered.data));
     int key = cv::waitKey(1);
     protonect_shutdown = protonect_shutdown || (key > 0 && ((key & 0xFF) == 27)); // shutdown on escape
 #endif
diff --git a/examples/protonect/flextGL.c b/examples/protonect/flextGL.c
deleted file mode 100644
index a462628b3..000000000
--- a/examples/protonect/flextGL.c
+++ /dev/null
@@ -1,367 +0,0 @@
-/* WARNING: This file was automatically generated */
-/* Do not edit. */
-
-#include "flextGL.h"
-#include "GLFW/glfw3.h"
-
-#include <stdio.h>
-
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-
-void flextLoadOpenGLFunctions(OpenGLBindings *bindings);
-
-int flextInit(GLFWwindow* window, OpenGLBindings *bindings)
-{
-  
-    int major = glfwGetWindowAttrib(window, GLFW_CONTEXT_VERSION_MAJOR);
-    int minor = glfwGetWindowAttrib(window, GLFW_CONTEXT_VERSION_MINOR);
-
-    flextLoadOpenGLFunctions(bindings);
-    
-    /* --- Check for minimal version and profile --- */
-
-    if (major * 10 + minor < 33) {
-        fprintf(stderr, "Error: OpenGL version 3.3 not supported.\n");
-        fprintf(stderr, "       Your version is %d.%d.\n", major, minor);
-        fprintf(stderr, "       Try updating your graphics driver.\n");
-        return GL_FALSE;
-    }
-
-
-    /* --- Check for extensions --- */
-
-
-    return GL_TRUE;
-}
-
-
-
-void flextLoadOpenGLFunctions(OpenGLBindings *bindings)
-{
-    /* --- Function pointer loading --- */
-
-
-    /* GL_VERSION_1_2 */
-
-    bindings->glDrawRangeElements = (PFNGLDRAWRANGEELEMENTS_PROC*)glfwGetProcAddress("glDrawRangeElements");
-    bindings->glTexImage3D = (PFNGLTEXIMAGE3D_PROC*)glfwGetProcAddress("glTexImage3D");
-    bindings->glTexSubImage3D = (PFNGLTEXSUBIMAGE3D_PROC*)glfwGetProcAddress("glTexSubImage3D");
-    bindings->glCopyTexSubImage3D = (PFNGLCOPYTEXSUBIMAGE3D_PROC*)glfwGetProcAddress("glCopyTexSubImage3D");
-
-    /* GL_VERSION_1_3 */
-
-    bindings->glActiveTexture = (PFNGLACTIVETEXTURE_PROC*)glfwGetProcAddress("glActiveTexture");
-    bindings->glSampleCoverage = (PFNGLSAMPLECOVERAGE_PROC*)glfwGetProcAddress("glSampleCoverage");
-    bindings->glCompressedTexImage3D = (PFNGLCOMPRESSEDTEXIMAGE3D_PROC*)glfwGetProcAddress("glCompressedTexImage3D");
-    bindings->glCompressedTexImage2D = (PFNGLCOMPRESSEDTEXIMAGE2D_PROC*)glfwGetProcAddress("glCompressedTexImage2D");
-    bindings->glCompressedTexImage1D = (PFNGLCOMPRESSEDTEXIMAGE1D_PROC*)glfwGetProcAddress("glCompressedTexImage1D");
-    bindings->glCompressedTexSubImage3D = (PFNGLCOMPRESSEDTEXSUBIMAGE3D_PROC*)glfwGetProcAddress("glCompressedTexSubImage3D");
-    bindings->glCompressedTexSubImage2D = (PFNGLCOMPRESSEDTEXSUBIMAGE2D_PROC*)glfwGetProcAddress("glCompressedTexSubImage2D");
-    bindings->glCompressedTexSubImage1D = (PFNGLCOMPRESSEDTEXSUBIMAGE1D_PROC*)glfwGetProcAddress("glCompressedTexSubImage1D");
-    bindings->glGetCompressedTexImage = (PFNGLGETCOMPRESSEDTEXIMAGE_PROC*)glfwGetProcAddress("glGetCompressedTexImage");
-
-    /* GL_VERSION_1_4 */
-
-    bindings->glBlendFuncSeparate = (PFNGLBLENDFUNCSEPARATE_PROC*)glfwGetProcAddress("glBlendFuncSeparate");
-    bindings->glMultiDrawArrays = (PFNGLMULTIDRAWARRAYS_PROC*)glfwGetProcAddress("glMultiDrawArrays");
-    bindings->glMultiDrawElements = (PFNGLMULTIDRAWELEMENTS_PROC*)glfwGetProcAddress("glMultiDrawElements");
-    bindings->glPointParameterf = (PFNGLPOINTPARAMETERF_PROC*)glfwGetProcAddress("glPointParameterf");
-    bindings->glPointParameterfv = (PFNGLPOINTPARAMETERFV_PROC*)glfwGetProcAddress("glPointParameterfv");
-    bindings->glPointParameteri = (PFNGLPOINTPARAMETERI_PROC*)glfwGetProcAddress("glPointParameteri");
-    bindings->glPointParameteriv = (PFNGLPOINTPARAMETERIV_PROC*)glfwGetProcAddress("glPointParameteriv");
-    bindings->glBlendColor = (PFNGLBLENDCOLOR_PROC*)glfwGetProcAddress("glBlendColor");
-    bindings->glBlendEquation = (PFNGLBLENDEQUATION_PROC*)glfwGetProcAddress("glBlendEquation");
-
-    /* GL_VERSION_1_5 */
-
-    bindings->glGenQueries = (PFNGLGENQUERIES_PROC*)glfwGetProcAddress("glGenQueries");
-    bindings->glDeleteQueries = (PFNGLDELETEQUERIES_PROC*)glfwGetProcAddress("glDeleteQueries");
-    bindings->glIsQuery = (PFNGLISQUERY_PROC*)glfwGetProcAddress("glIsQuery");
-    bindings->glBeginQuery = (PFNGLBEGINQUERY_PROC*)glfwGetProcAddress("glBeginQuery");
-    bindings->glEndQuery = (PFNGLENDQUERY_PROC*)glfwGetProcAddress("glEndQuery");
-    bindings->glGetQueryiv = (PFNGLGETQUERYIV_PROC*)glfwGetProcAddress("glGetQueryiv");
-    bindings->glGetQueryObjectiv = (PFNGLGETQUERYOBJECTIV_PROC*)glfwGetProcAddress("glGetQueryObjectiv");
-    bindings->glGetQueryObjectuiv = (PFNGLGETQUERYOBJECTUIV_PROC*)glfwGetProcAddress("glGetQueryObjectuiv");
-    bindings->glBindBuffer = (PFNGLBINDBUFFER_PROC*)glfwGetProcAddress("glBindBuffer");
-    bindings->glDeleteBuffers = (PFNGLDELETEBUFFERS_PROC*)glfwGetProcAddress("glDeleteBuffers");
-    bindings->glGenBuffers = (PFNGLGENBUFFERS_PROC*)glfwGetProcAddress("glGenBuffers");
-    bindings->glIsBuffer = (PFNGLISBUFFER_PROC*)glfwGetProcAddress("glIsBuffer");
-    bindings->glBufferData = (PFNGLBUFFERDATA_PROC*)glfwGetProcAddress("glBufferData");
-    bindings->glBufferSubData = (PFNGLBUFFERSUBDATA_PROC*)glfwGetProcAddress("glBufferSubData");
-    bindings->glGetBufferSubData = (PFNGLGETBUFFERSUBDATA_PROC*)glfwGetProcAddress("glGetBufferSubData");
-    bindings->glMapBuffer = (PFNGLMAPBUFFER_PROC*)glfwGetProcAddress("glMapBuffer");
-    bindings->glUnmapBuffer = (PFNGLUNMAPBUFFER_PROC*)glfwGetProcAddress("glUnmapBuffer");
-    bindings->glGetBufferParameteriv = (PFNGLGETBUFFERPARAMETERIV_PROC*)glfwGetProcAddress("glGetBufferParameteriv");
-    bindings->glGetBufferPointerv = (PFNGLGETBUFFERPOINTERV_PROC*)glfwGetProcAddress("glGetBufferPointerv");
-
-    /* GL_VERSION_2_0 */
-
-    bindings->glBlendEquationSeparate = (PFNGLBLENDEQUATIONSEPARATE_PROC*)glfwGetProcAddress("glBlendEquationSeparate");
-    bindings->glDrawBuffers = (PFNGLDRAWBUFFERS_PROC*)glfwGetProcAddress("glDrawBuffers");
-    bindings->glStencilOpSeparate = (PFNGLSTENCILOPSEPARATE_PROC*)glfwGetProcAddress("glStencilOpSeparate");
-    bindings->glStencilFuncSeparate = (PFNGLSTENCILFUNCSEPARATE_PROC*)glfwGetProcAddress("glStencilFuncSeparate");
-    bindings->glStencilMaskSeparate = (PFNGLSTENCILMASKSEPARATE_PROC*)glfwGetProcAddress("glStencilMaskSeparate");
-    bindings->glAttachShader = (PFNGLATTACHSHADER_PROC*)glfwGetProcAddress("glAttachShader");
-    bindings->glBindAttribLocation = (PFNGLBINDATTRIBLOCATION_PROC*)glfwGetProcAddress("glBindAttribLocation");
-    bindings->glCompileShader = (PFNGLCOMPILESHADER_PROC*)glfwGetProcAddress("glCompileShader");
-    bindings->glCreateProgram = (PFNGLCREATEPROGRAM_PROC*)glfwGetProcAddress("glCreateProgram");
-    bindings->glCreateShader = (PFNGLCREATESHADER_PROC*)glfwGetProcAddress("glCreateShader");
-    bindings->glDeleteProgram = (PFNGLDELETEPROGRAM_PROC*)glfwGetProcAddress("glDeleteProgram");
-    bindings->glDeleteShader = (PFNGLDELETESHADER_PROC*)glfwGetProcAddress("glDeleteShader");
-    bindings->glDetachShader = (PFNGLDETACHSHADER_PROC*)glfwGetProcAddress("glDetachShader");
-    bindings->glDisableVertexAttribArray = (PFNGLDISABLEVERTEXATTRIBARRAY_PROC*)glfwGetProcAddress("glDisableVertexAttribArray");
-    bindings->glEnableVertexAttribArray = (PFNGLENABLEVERTEXATTRIBARRAY_PROC*)glfwGetProcAddress("glEnableVertexAttribArray");
-    bindings->glGetActiveAttrib = (PFNGLGETACTIVEATTRIB_PROC*)glfwGetProcAddress("glGetActiveAttrib");
-    bindings->glGetActiveUniform = (PFNGLGETACTIVEUNIFORM_PROC*)glfwGetProcAddress("glGetActiveUniform");
-    bindings->glGetAttachedShaders = (PFNGLGETATTACHEDSHADERS_PROC*)glfwGetProcAddress("glGetAttachedShaders");
-    bindings->glGetAttribLocation = (PFNGLGETATTRIBLOCATION_PROC*)glfwGetProcAddress("glGetAttribLocation");
-    bindings->glGetProgramiv = (PFNGLGETPROGRAMIV_PROC*)glfwGetProcAddress("glGetProgramiv");
-    bindings->glGetProgramInfoLog = (PFNGLGETPROGRAMINFOLOG_PROC*)glfwGetProcAddress("glGetProgramInfoLog");
-    bindings->glGetShaderiv = (PFNGLGETSHADERIV_PROC*)glfwGetProcAddress("glGetShaderiv");
-    bindings->glGetShaderInfoLog = (PFNGLGETSHADERINFOLOG_PROC*)glfwGetProcAddress("glGetShaderInfoLog");
-    bindings->glGetShaderSource = (PFNGLGETSHADERSOURCE_PROC*)glfwGetProcAddress("glGetShaderSource");
-    bindings->glGetUniformLocation = (PFNGLGETUNIFORMLOCATION_PROC*)glfwGetProcAddress("glGetUniformLocation");
-    bindings->glGetUniformfv = (PFNGLGETUNIFORMFV_PROC*)glfwGetProcAddress("glGetUniformfv");
-    bindings->glGetUniformiv = (PFNGLGETUNIFORMIV_PROC*)glfwGetProcAddress("glGetUniformiv");
-    bindings->glGetVertexAttribdv = (PFNGLGETVERTEXATTRIBDV_PROC*)glfwGetProcAddress("glGetVertexAttribdv");
-    bindings->glGetVertexAttribfv = (PFNGLGETVERTEXATTRIBFV_PROC*)glfwGetProcAddress("glGetVertexAttribfv");
-    bindings->glGetVertexAttribiv = (PFNGLGETVERTEXATTRIBIV_PROC*)glfwGetProcAddress("glGetVertexAttribiv");
-    bindings->glGetVertexAttribPointerv = (PFNGLGETVERTEXATTRIBPOINTERV_PROC*)glfwGetProcAddress("glGetVertexAttribPointerv");
-    bindings->glIsProgram = (PFNGLISPROGRAM_PROC*)glfwGetProcAddress("glIsProgram");
-    bindings->glIsShader = (PFNGLISSHADER_PROC*)glfwGetProcAddress("glIsShader");
-    bindings->glLinkProgram = (PFNGLLINKPROGRAM_PROC*)glfwGetProcAddress("glLinkProgram");
-    bindings->glShaderSource = (PFNGLSHADERSOURCE_PROC*)glfwGetProcAddress("glShaderSource");
-    bindings->glUseProgram = (PFNGLUSEPROGRAM_PROC*)glfwGetProcAddress("glUseProgram");
-    bindings->glUniform1f = (PFNGLUNIFORM1F_PROC*)glfwGetProcAddress("glUniform1f");
-    bindings->glUniform2f = (PFNGLUNIFORM2F_PROC*)glfwGetProcAddress("glUniform2f");
-    bindings->glUniform3f = (PFNGLUNIFORM3F_PROC*)glfwGetProcAddress("glUniform3f");
-    bindings->glUniform4f = (PFNGLUNIFORM4F_PROC*)glfwGetProcAddress("glUniform4f");
-    bindings->glUniform1i = (PFNGLUNIFORM1I_PROC*)glfwGetProcAddress("glUniform1i");
-    bindings->glUniform2i = (PFNGLUNIFORM2I_PROC*)glfwGetProcAddress("glUniform2i");
-    bindings->glUniform3i = (PFNGLUNIFORM3I_PROC*)glfwGetProcAddress("glUniform3i");
-    bindings->glUniform4i = (PFNGLUNIFORM4I_PROC*)glfwGetProcAddress("glUniform4i");
-    bindings->glUniform1fv = (PFNGLUNIFORM1FV_PROC*)glfwGetProcAddress("glUniform1fv");
-    bindings->glUniform2fv = (PFNGLUNIFORM2FV_PROC*)glfwGetProcAddress("glUniform2fv");
-    bindings->glUniform3fv = (PFNGLUNIFORM3FV_PROC*)glfwGetProcAddress("glUniform3fv");
-    bindings->glUniform4fv = (PFNGLUNIFORM4FV_PROC*)glfwGetProcAddress("glUniform4fv");
-    bindings->glUniform1iv = (PFNGLUNIFORM1IV_PROC*)glfwGetProcAddress("glUniform1iv");
-    bindings->glUniform2iv = (PFNGLUNIFORM2IV_PROC*)glfwGetProcAddress("glUniform2iv");
-    bindings->glUniform3iv = (PFNGLUNIFORM3IV_PROC*)glfwGetProcAddress("glUniform3iv");
-    bindings->glUniform4iv = (PFNGLUNIFORM4IV_PROC*)glfwGetProcAddress("glUniform4iv");
-    bindings->glUniformMatrix2fv = (PFNGLUNIFORMMATRIX2FV_PROC*)glfwGetProcAddress("glUniformMatrix2fv");
-    bindings->glUniformMatrix3fv = (PFNGLUNIFORMMATRIX3FV_PROC*)glfwGetProcAddress("glUniformMatrix3fv");
-    bindings->glUniformMatrix4fv = (PFNGLUNIFORMMATRIX4FV_PROC*)glfwGetProcAddress("glUniformMatrix4fv");
-    bindings->glValidateProgram = (PFNGLVALIDATEPROGRAM_PROC*)glfwGetProcAddress("glValidateProgram");
-    bindings->glVertexAttrib1d = (PFNGLVERTEXATTRIB1D_PROC*)glfwGetProcAddress("glVertexAttrib1d");
-    bindings->glVertexAttrib1dv = (PFNGLVERTEXATTRIB1DV_PROC*)glfwGetProcAddress("glVertexAttrib1dv");
-    bindings->glVertexAttrib1f = (PFNGLVERTEXATTRIB1F_PROC*)glfwGetProcAddress("glVertexAttrib1f");
-    bindings->glVertexAttrib1fv = (PFNGLVERTEXATTRIB1FV_PROC*)glfwGetProcAddress("glVertexAttrib1fv");
-    bindings->glVertexAttrib1s = (PFNGLVERTEXATTRIB1S_PROC*)glfwGetProcAddress("glVertexAttrib1s");
-    bindings->glVertexAttrib1sv = (PFNGLVERTEXATTRIB1SV_PROC*)glfwGetProcAddress("glVertexAttrib1sv");
-    bindings->glVertexAttrib2d = (PFNGLVERTEXATTRIB2D_PROC*)glfwGetProcAddress("glVertexAttrib2d");
-    bindings->glVertexAttrib2dv = (PFNGLVERTEXATTRIB2DV_PROC*)glfwGetProcAddress("glVertexAttrib2dv");
-    bindings->glVertexAttrib2f = (PFNGLVERTEXATTRIB2F_PROC*)glfwGetProcAddress("glVertexAttrib2f");
-    bindings->glVertexAttrib2fv = (PFNGLVERTEXATTRIB2FV_PROC*)glfwGetProcAddress("glVertexAttrib2fv");
-    bindings->glVertexAttrib2s = (PFNGLVERTEXATTRIB2S_PROC*)glfwGetProcAddress("glVertexAttrib2s");
-    bindings->glVertexAttrib2sv = (PFNGLVERTEXATTRIB2SV_PROC*)glfwGetProcAddress("glVertexAttrib2sv");
-    bindings->glVertexAttrib3d = (PFNGLVERTEXATTRIB3D_PROC*)glfwGetProcAddress("glVertexAttrib3d");
-    bindings->glVertexAttrib3dv = (PFNGLVERTEXATTRIB3DV_PROC*)glfwGetProcAddress("glVertexAttrib3dv");
-    bindings->glVertexAttrib3f = (PFNGLVERTEXATTRIB3F_PROC*)glfwGetProcAddress("glVertexAttrib3f");
-    bindings->glVertexAttrib3fv = (PFNGLVERTEXATTRIB3FV_PROC*)glfwGetProcAddress("glVertexAttrib3fv");
-    bindings->glVertexAttrib3s = (PFNGLVERTEXATTRIB3S_PROC*)glfwGetProcAddress("glVertexAttrib3s");
-    bindings->glVertexAttrib3sv = (PFNGLVERTEXATTRIB3SV_PROC*)glfwGetProcAddress("glVertexAttrib3sv");
-    bindings->glVertexAttrib4Nbv = (PFNGLVERTEXATTRIB4NBV_PROC*)glfwGetProcAddress("glVertexAttrib4Nbv");
-    bindings->glVertexAttrib4Niv = (PFNGLVERTEXATTRIB4NIV_PROC*)glfwGetProcAddress("glVertexAttrib4Niv");
-    bindings->glVertexAttrib4Nsv = (PFNGLVERTEXATTRIB4NSV_PROC*)glfwGetProcAddress("glVertexAttrib4Nsv");
-    bindings->glVertexAttrib4Nub = (PFNGLVERTEXATTRIB4NUB_PROC*)glfwGetProcAddress("glVertexAttrib4Nub");
-    bindings->glVertexAttrib4Nubv = (PFNGLVERTEXATTRIB4NUBV_PROC*)glfwGetProcAddress("glVertexAttrib4Nubv");
-    bindings->glVertexAttrib4Nuiv = (PFNGLVERTEXATTRIB4NUIV_PROC*)glfwGetProcAddress("glVertexAttrib4Nuiv");
-    bindings->glVertexAttrib4Nusv = (PFNGLVERTEXATTRIB4NUSV_PROC*)glfwGetProcAddress("glVertexAttrib4Nusv");
-    bindings->glVertexAttrib4bv = (PFNGLVERTEXATTRIB4BV_PROC*)glfwGetProcAddress("glVertexAttrib4bv");
-    bindings->glVertexAttrib4d = (PFNGLVERTEXATTRIB4D_PROC*)glfwGetProcAddress("glVertexAttrib4d");
-    bindings->glVertexAttrib4dv = (PFNGLVERTEXATTRIB4DV_PROC*)glfwGetProcAddress("glVertexAttrib4dv");
-    bindings->glVertexAttrib4f = (PFNGLVERTEXATTRIB4F_PROC*)glfwGetProcAddress("glVertexAttrib4f");
-    bindings->glVertexAttrib4fv = (PFNGLVERTEXATTRIB4FV_PROC*)glfwGetProcAddress("glVertexAttrib4fv");
-    bindings->glVertexAttrib4iv = (PFNGLVERTEXATTRIB4IV_PROC*)glfwGetProcAddress("glVertexAttrib4iv");
-    bindings->glVertexAttrib4s = (PFNGLVERTEXATTRIB4S_PROC*)glfwGetProcAddress("glVertexAttrib4s");
-    bindings->glVertexAttrib4sv = (PFNGLVERTEXATTRIB4SV_PROC*)glfwGetProcAddress("glVertexAttrib4sv");
-    bindings->glVertexAttrib4ubv = (PFNGLVERTEXATTRIB4UBV_PROC*)glfwGetProcAddress("glVertexAttrib4ubv");
-    bindings->glVertexAttrib4uiv = (PFNGLVERTEXATTRIB4UIV_PROC*)glfwGetProcAddress("glVertexAttrib4uiv");
-    bindings->glVertexAttrib4usv = (PFNGLVERTEXATTRIB4USV_PROC*)glfwGetProcAddress("glVertexAttrib4usv");
-    bindings->glVertexAttribPointer = (PFNGLVERTEXATTRIBPOINTER_PROC*)glfwGetProcAddress("glVertexAttribPointer");
-
-    /* GL_VERSION_2_1 */
-
-    bindings->glUniformMatrix2x3fv = (PFNGLUNIFORMMATRIX2X3FV_PROC*)glfwGetProcAddress("glUniformMatrix2x3fv");
-    bindings->glUniformMatrix3x2fv = (PFNGLUNIFORMMATRIX3X2FV_PROC*)glfwGetProcAddress("glUniformMatrix3x2fv");
-    bindings->glUniformMatrix2x4fv = (PFNGLUNIFORMMATRIX2X4FV_PROC*)glfwGetProcAddress("glUniformMatrix2x4fv");
-    bindings->glUniformMatrix4x2fv = (PFNGLUNIFORMMATRIX4X2FV_PROC*)glfwGetProcAddress("glUniformMatrix4x2fv");
-    bindings->glUniformMatrix3x4fv = (PFNGLUNIFORMMATRIX3X4FV_PROC*)glfwGetProcAddress("glUniformMatrix3x4fv");
-    bindings->glUniformMatrix4x3fv = (PFNGLUNIFORMMATRIX4X3FV_PROC*)glfwGetProcAddress("glUniformMatrix4x3fv");
-
-    /* GL_VERSION_3_0 */
-
-    bindings->glColorMaski = (PFNGLCOLORMASKI_PROC*)glfwGetProcAddress("glColorMaski");
-    bindings->glGetBooleani_v = (PFNGLGETBOOLEANI_V_PROC*)glfwGetProcAddress("glGetBooleani_v");
-    bindings->glGetIntegeri_v = (PFNGLGETINTEGERI_V_PROC*)glfwGetProcAddress("glGetIntegeri_v");
-    bindings->glEnablei = (PFNGLENABLEI_PROC*)glfwGetProcAddress("glEnablei");
-    bindings->glDisablei = (PFNGLDISABLEI_PROC*)glfwGetProcAddress("glDisablei");
-    bindings->glIsEnabledi = (PFNGLISENABLEDI_PROC*)glfwGetProcAddress("glIsEnabledi");
-    bindings->glBeginTransformFeedback = (PFNGLBEGINTRANSFORMFEEDBACK_PROC*)glfwGetProcAddress("glBeginTransformFeedback");
-    bindings->glEndTransformFeedback = (PFNGLENDTRANSFORMFEEDBACK_PROC*)glfwGetProcAddress("glEndTransformFeedback");
-    bindings->glBindBufferRange = (PFNGLBINDBUFFERRANGE_PROC*)glfwGetProcAddress("glBindBufferRange");
-    bindings->glBindBufferBase = (PFNGLBINDBUFFERBASE_PROC*)glfwGetProcAddress("glBindBufferBase");
-    bindings->glTransformFeedbackVaryings = (PFNGLTRANSFORMFEEDBACKVARYINGS_PROC*)glfwGetProcAddress("glTransformFeedbackVaryings");
-    bindings->glGetTransformFeedbackVarying = (PFNGLGETTRANSFORMFEEDBACKVARYING_PROC*)glfwGetProcAddress("glGetTransformFeedbackVarying");
-    bindings->glClampColor = (PFNGLCLAMPCOLOR_PROC*)glfwGetProcAddress("glClampColor");
-    bindings->glBeginConditionalRender = (PFNGLBEGINCONDITIONALRENDER_PROC*)glfwGetProcAddress("glBeginConditionalRender");
-    bindings->glEndConditionalRender = (PFNGLENDCONDITIONALRENDER_PROC*)glfwGetProcAddress("glEndConditionalRender");
-    bindings->glVertexAttribIPointer = (PFNGLVERTEXATTRIBIPOINTER_PROC*)glfwGetProcAddress("glVertexAttribIPointer");
-    bindings->glGetVertexAttribIiv = (PFNGLGETVERTEXATTRIBIIV_PROC*)glfwGetProcAddress("glGetVertexAttribIiv");
-    bindings->glGetVertexAttribIuiv = (PFNGLGETVERTEXATTRIBIUIV_PROC*)glfwGetProcAddress("glGetVertexAttribIuiv");
-    bindings->glVertexAttribI1i = (PFNGLVERTEXATTRIBI1I_PROC*)glfwGetProcAddress("glVertexAttribI1i");
-    bindings->glVertexAttribI2i = (PFNGLVERTEXATTRIBI2I_PROC*)glfwGetProcAddress("glVertexAttribI2i");
-    bindings->glVertexAttribI3i = (PFNGLVERTEXATTRIBI3I_PROC*)glfwGetProcAddress("glVertexAttribI3i");
-    bindings->glVertexAttribI4i = (PFNGLVERTEXATTRIBI4I_PROC*)glfwGetProcAddress("glVertexAttribI4i");
-    bindings->glVertexAttribI1ui = (PFNGLVERTEXATTRIBI1UI_PROC*)glfwGetProcAddress("glVertexAttribI1ui");
-    bindings->glVertexAttribI2ui = (PFNGLVERTEXATTRIBI2UI_PROC*)glfwGetProcAddress("glVertexAttribI2ui");
-    bindings->glVertexAttribI3ui = (PFNGLVERTEXATTRIBI3UI_PROC*)glfwGetProcAddress("glVertexAttribI3ui");
-    bindings->glVertexAttribI4ui = (PFNGLVERTEXATTRIBI4UI_PROC*)glfwGetProcAddress("glVertexAttribI4ui");
-    bindings->glVertexAttribI1iv = (PFNGLVERTEXATTRIBI1IV_PROC*)glfwGetProcAddress("glVertexAttribI1iv");
-    bindings->glVertexAttribI2iv = (PFNGLVERTEXATTRIBI2IV_PROC*)glfwGetProcAddress("glVertexAttribI2iv");
-    bindings->glVertexAttribI3iv = (PFNGLVERTEXATTRIBI3IV_PROC*)glfwGetProcAddress("glVertexAttribI3iv");
-    bindings->glVertexAttribI4iv = (PFNGLVERTEXATTRIBI4IV_PROC*)glfwGetProcAddress("glVertexAttribI4iv");
-    bindings->glVertexAttribI1uiv = (PFNGLVERTEXATTRIBI1UIV_PROC*)glfwGetProcAddress("glVertexAttribI1uiv");
-    bindings->glVertexAttribI2uiv = (PFNGLVERTEXATTRIBI2UIV_PROC*)glfwGetProcAddress("glVertexAttribI2uiv");
-    bindings->glVertexAttribI3uiv = (PFNGLVERTEXATTRIBI3UIV_PROC*)glfwGetProcAddress("glVertexAttribI3uiv");
-    bindings->glVertexAttribI4uiv = (PFNGLVERTEXATTRIBI4UIV_PROC*)glfwGetProcAddress("glVertexAttribI4uiv");
-    bindings->glVertexAttribI4bv = (PFNGLVERTEXATTRIBI4BV_PROC*)glfwGetProcAddress("glVertexAttribI4bv");
-    bindings->glVertexAttribI4sv = (PFNGLVERTEXATTRIBI4SV_PROC*)glfwGetProcAddress("glVertexAttribI4sv");
-    bindings->glVertexAttribI4ubv = (PFNGLVERTEXATTRIBI4UBV_PROC*)glfwGetProcAddress("glVertexAttribI4ubv");
-    bindings->glVertexAttribI4usv = (PFNGLVERTEXATTRIBI4USV_PROC*)glfwGetProcAddress("glVertexAttribI4usv");
-    bindings->glGetUniformuiv = (PFNGLGETUNIFORMUIV_PROC*)glfwGetProcAddress("glGetUniformuiv");
-    bindings->glBindFragDataLocation = (PFNGLBINDFRAGDATALOCATION_PROC*)glfwGetProcAddress("glBindFragDataLocation");
-    bindings->glGetFragDataLocation = (PFNGLGETFRAGDATALOCATION_PROC*)glfwGetProcAddress("glGetFragDataLocation");
-    bindings->glUniform1ui = (PFNGLUNIFORM1UI_PROC*)glfwGetProcAddress("glUniform1ui");
-    bindings->glUniform2ui = (PFNGLUNIFORM2UI_PROC*)glfwGetProcAddress("glUniform2ui");
-    bindings->glUniform3ui = (PFNGLUNIFORM3UI_PROC*)glfwGetProcAddress("glUniform3ui");
-    bindings->glUniform4ui = (PFNGLUNIFORM4UI_PROC*)glfwGetProcAddress("glUniform4ui");
-    bindings->glUniform1uiv = (PFNGLUNIFORM1UIV_PROC*)glfwGetProcAddress("glUniform1uiv");
-    bindings->glUniform2uiv = (PFNGLUNIFORM2UIV_PROC*)glfwGetProcAddress("glUniform2uiv");
-    bindings->glUniform3uiv = (PFNGLUNIFORM3UIV_PROC*)glfwGetProcAddress("glUniform3uiv");
-    bindings->glUniform4uiv = (PFNGLUNIFORM4UIV_PROC*)glfwGetProcAddress("glUniform4uiv");
-    bindings->glTexParameterIiv = (PFNGLTEXPARAMETERIIV_PROC*)glfwGetProcAddress("glTexParameterIiv");
-    bindings->glTexParameterIuiv = (PFNGLTEXPARAMETERIUIV_PROC*)glfwGetProcAddress("glTexParameterIuiv");
-    bindings->glGetTexParameterIiv = (PFNGLGETTEXPARAMETERIIV_PROC*)glfwGetProcAddress("glGetTexParameterIiv");
-    bindings->glGetTexParameterIuiv = (PFNGLGETTEXPARAMETERIUIV_PROC*)glfwGetProcAddress("glGetTexParameterIuiv");
-    bindings->glClearBufferiv = (PFNGLCLEARBUFFERIV_PROC*)glfwGetProcAddress("glClearBufferiv");
-    bindings->glClearBufferuiv = (PFNGLCLEARBUFFERUIV_PROC*)glfwGetProcAddress("glClearBufferuiv");
-    bindings->glClearBufferfv = (PFNGLCLEARBUFFERFV_PROC*)glfwGetProcAddress("glClearBufferfv");
-    bindings->glClearBufferfi = (PFNGLCLEARBUFFERFI_PROC*)glfwGetProcAddress("glClearBufferfi");
-    bindings->glGetStringi = (PFNGLGETSTRINGI_PROC*)glfwGetProcAddress("glGetStringi");
-    bindings->glIsRenderbuffer = (PFNGLISRENDERBUFFER_PROC*)glfwGetProcAddress("glIsRenderbuffer");
-    bindings->glBindRenderbuffer = (PFNGLBINDRENDERBUFFER_PROC*)glfwGetProcAddress("glBindRenderbuffer");
-    bindings->glDeleteRenderbuffers = (PFNGLDELETERENDERBUFFERS_PROC*)glfwGetProcAddress("glDeleteRenderbuffers");
-    bindings->glGenRenderbuffers = (PFNGLGENRENDERBUFFERS_PROC*)glfwGetProcAddress("glGenRenderbuffers");
-    bindings->glRenderbufferStorage = (PFNGLRENDERBUFFERSTORAGE_PROC*)glfwGetProcAddress("glRenderbufferStorage");
-    bindings->glGetRenderbufferParameteriv = (PFNGLGETRENDERBUFFERPARAMETERIV_PROC*)glfwGetProcAddress("glGetRenderbufferParameteriv");
-    bindings->glIsFramebuffer = (PFNGLISFRAMEBUFFER_PROC*)glfwGetProcAddress("glIsFramebuffer");
-    bindings->glBindFramebuffer = (PFNGLBINDFRAMEBUFFER_PROC*)glfwGetProcAddress("glBindFramebuffer");
-    bindings->glDeleteFramebuffers = (PFNGLDELETEFRAMEBUFFERS_PROC*)glfwGetProcAddress("glDeleteFramebuffers");
-    bindings->glGenFramebuffers = (PFNGLGENFRAMEBUFFERS_PROC*)glfwGetProcAddress("glGenFramebuffers");
-    bindings->glCheckFramebufferStatus = (PFNGLCHECKFRAMEBUFFERSTATUS_PROC*)glfwGetProcAddress("glCheckFramebufferStatus");
-    bindings->glFramebufferTexture1D = (PFNGLFRAMEBUFFERTEXTURE1D_PROC*)glfwGetProcAddress("glFramebufferTexture1D");
-    bindings->glFramebufferTexture2D = (PFNGLFRAMEBUFFERTEXTURE2D_PROC*)glfwGetProcAddress("glFramebufferTexture2D");
-    bindings->glFramebufferTexture3D = (PFNGLFRAMEBUFFERTEXTURE3D_PROC*)glfwGetProcAddress("glFramebufferTexture3D");
-    bindings->glFramebufferRenderbuffer = (PFNGLFRAMEBUFFERRENDERBUFFER_PROC*)glfwGetProcAddress("glFramebufferRenderbuffer");
-    bindings->glGetFramebufferAttachmentParameteriv = (PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIV_PROC*)glfwGetProcAddress("glGetFramebufferAttachmentParameteriv");
-    bindings->glGenerateMipmap = (PFNGLGENERATEMIPMAP_PROC*)glfwGetProcAddress("glGenerateMipmap");
-    bindings->glBlitFramebuffer = (PFNGLBLITFRAMEBUFFER_PROC*)glfwGetProcAddress("glBlitFramebuffer");
-    bindings->glRenderbufferStorageMultisample = (PFNGLRENDERBUFFERSTORAGEMULTISAMPLE_PROC*)glfwGetProcAddress("glRenderbufferStorageMultisample");
-    bindings->glFramebufferTextureLayer = (PFNGLFRAMEBUFFERTEXTURELAYER_PROC*)glfwGetProcAddress("glFramebufferTextureLayer");
-    bindings->glMapBufferRange = (PFNGLMAPBUFFERRANGE_PROC*)glfwGetProcAddress("glMapBufferRange");
-    bindings->glFlushMappedBufferRange = (PFNGLFLUSHMAPPEDBUFFERRANGE_PROC*)glfwGetProcAddress("glFlushMappedBufferRange");
-    bindings->glBindVertexArray = (PFNGLBINDVERTEXARRAY_PROC*)glfwGetProcAddress("glBindVertexArray");
-    bindings->glDeleteVertexArrays = (PFNGLDELETEVERTEXARRAYS_PROC*)glfwGetProcAddress("glDeleteVertexArrays");
-    bindings->glGenVertexArrays = (PFNGLGENVERTEXARRAYS_PROC*)glfwGetProcAddress("glGenVertexArrays");
-    bindings->glIsVertexArray = (PFNGLISVERTEXARRAY_PROC*)glfwGetProcAddress("glIsVertexArray");
-
-    /* GL_VERSION_3_1 */
-
-    bindings->glDrawArraysInstanced = (PFNGLDRAWARRAYSINSTANCED_PROC*)glfwGetProcAddress("glDrawArraysInstanced");
-    bindings->glDrawElementsInstanced = (PFNGLDRAWELEMENTSINSTANCED_PROC*)glfwGetProcAddress("glDrawElementsInstanced");
-    bindings->glTexBuffer = (PFNGLTEXBUFFER_PROC*)glfwGetProcAddress("glTexBuffer");
-    bindings->glPrimitiveRestartIndex = (PFNGLPRIMITIVERESTARTINDEX_PROC*)glfwGetProcAddress("glPrimitiveRestartIndex");
-    bindings->glCopyBufferSubData = (PFNGLCOPYBUFFERSUBDATA_PROC*)glfwGetProcAddress("glCopyBufferSubData");
-    bindings->glGetUniformIndices = (PFNGLGETUNIFORMINDICES_PROC*)glfwGetProcAddress("glGetUniformIndices");
-    bindings->glGetActiveUniformsiv = (PFNGLGETACTIVEUNIFORMSIV_PROC*)glfwGetProcAddress("glGetActiveUniformsiv");
-    bindings->glGetActiveUniformName = (PFNGLGETACTIVEUNIFORMNAME_PROC*)glfwGetProcAddress("glGetActiveUniformName");
-    bindings->glGetUniformBlockIndex = (PFNGLGETUNIFORMBLOCKINDEX_PROC*)glfwGetProcAddress("glGetUniformBlockIndex");
-    bindings->glGetActiveUniformBlockiv = (PFNGLGETACTIVEUNIFORMBLOCKIV_PROC*)glfwGetProcAddress("glGetActiveUniformBlockiv");
-    bindings->glGetActiveUniformBlockName = (PFNGLGETACTIVEUNIFORMBLOCKNAME_PROC*)glfwGetProcAddress("glGetActiveUniformBlockName");
-    bindings->glUniformBlockBinding = (PFNGLUNIFORMBLOCKBINDING_PROC*)glfwGetProcAddress("glUniformBlockBinding");
-
-    /* GL_VERSION_3_2 */
-
-    bindings->glDrawElementsBaseVertex = (PFNGLDRAWELEMENTSBASEVERTEX_PROC*)glfwGetProcAddress("glDrawElementsBaseVertex");
-    bindings->glDrawRangeElementsBaseVertex = (PFNGLDRAWRANGEELEMENTSBASEVERTEX_PROC*)glfwGetProcAddress("glDrawRangeElementsBaseVertex");
-    bindings->glDrawElementsInstancedBaseVertex = (PFNGLDRAWELEMENTSINSTANCEDBASEVERTEX_PROC*)glfwGetProcAddress("glDrawElementsInstancedBaseVertex");
-    bindings->glMultiDrawElementsBaseVertex = (PFNGLMULTIDRAWELEMENTSBASEVERTEX_PROC*)glfwGetProcAddress("glMultiDrawElementsBaseVertex");
-    bindings->glProvokingVertex = (PFNGLPROVOKINGVERTEX_PROC*)glfwGetProcAddress("glProvokingVertex");
-    bindings->glFenceSync = (PFNGLFENCESYNC_PROC*)glfwGetProcAddress("glFenceSync");
-    bindings->glIsSync = (PFNGLISSYNC_PROC*)glfwGetProcAddress("glIsSync");
-    bindings->glDeleteSync = (PFNGLDELETESYNC_PROC*)glfwGetProcAddress("glDeleteSync");
-    bindings->glClientWaitSync = (PFNGLCLIENTWAITSYNC_PROC*)glfwGetProcAddress("glClientWaitSync");
-    bindings->glWaitSync = (PFNGLWAITSYNC_PROC*)glfwGetProcAddress("glWaitSync");
-    bindings->glGetInteger64v = (PFNGLGETINTEGER64V_PROC*)glfwGetProcAddress("glGetInteger64v");
-    bindings->glGetSynciv = (PFNGLGETSYNCIV_PROC*)glfwGetProcAddress("glGetSynciv");
-    bindings->glGetInteger64i_v = (PFNGLGETINTEGER64I_V_PROC*)glfwGetProcAddress("glGetInteger64i_v");
-    bindings->glGetBufferParameteri64v = (PFNGLGETBUFFERPARAMETERI64V_PROC*)glfwGetProcAddress("glGetBufferParameteri64v");
-    bindings->glFramebufferTexture = (PFNGLFRAMEBUFFERTEXTURE_PROC*)glfwGetProcAddress("glFramebufferTexture");
-    bindings->glTexImage2DMultisample = (PFNGLTEXIMAGE2DMULTISAMPLE_PROC*)glfwGetProcAddress("glTexImage2DMultisample");
-    bindings->glTexImage3DMultisample = (PFNGLTEXIMAGE3DMULTISAMPLE_PROC*)glfwGetProcAddress("glTexImage3DMultisample");
-    bindings->glGetMultisamplefv = (PFNGLGETMULTISAMPLEFV_PROC*)glfwGetProcAddress("glGetMultisamplefv");
-    bindings->glSampleMaski = (PFNGLSAMPLEMASKI_PROC*)glfwGetProcAddress("glSampleMaski");
-
-    /* GL_VERSION_3_3 */
-
-    bindings->glBindFragDataLocationIndexed = (PFNGLBINDFRAGDATALOCATIONINDEXED_PROC*)glfwGetProcAddress("glBindFragDataLocationIndexed");
-    bindings->glGetFragDataIndex = (PFNGLGETFRAGDATAINDEX_PROC*)glfwGetProcAddress("glGetFragDataIndex");
-    bindings->glGenSamplers = (PFNGLGENSAMPLERS_PROC*)glfwGetProcAddress("glGenSamplers");
-    bindings->glDeleteSamplers = (PFNGLDELETESAMPLERS_PROC*)glfwGetProcAddress("glDeleteSamplers");
-    bindings->glIsSampler = (PFNGLISSAMPLER_PROC*)glfwGetProcAddress("glIsSampler");
-    bindings->glBindSampler = (PFNGLBINDSAMPLER_PROC*)glfwGetProcAddress("glBindSampler");
-    bindings->glSamplerParameteri = (PFNGLSAMPLERPARAMETERI_PROC*)glfwGetProcAddress("glSamplerParameteri");
-    bindings->glSamplerParameteriv = (PFNGLSAMPLERPARAMETERIV_PROC*)glfwGetProcAddress("glSamplerParameteriv");
-    bindings->glSamplerParameterf = (PFNGLSAMPLERPARAMETERF_PROC*)glfwGetProcAddress("glSamplerParameterf");
-    bindings->glSamplerParameterfv = (PFNGLSAMPLERPARAMETERFV_PROC*)glfwGetProcAddress("glSamplerParameterfv");
-    bindings->glSamplerParameterIiv = (PFNGLSAMPLERPARAMETERIIV_PROC*)glfwGetProcAddress("glSamplerParameterIiv");
-    bindings->glSamplerParameterIuiv = (PFNGLSAMPLERPARAMETERIUIV_PROC*)glfwGetProcAddress("glSamplerParameterIuiv");
-    bindings->glGetSamplerParameteriv = (PFNGLGETSAMPLERPARAMETERIV_PROC*)glfwGetProcAddress("glGetSamplerParameteriv");
-    bindings->glGetSamplerParameterIiv = (PFNGLGETSAMPLERPARAMETERIIV_PROC*)glfwGetProcAddress("glGetSamplerParameterIiv");
-    bindings->glGetSamplerParameterfv = (PFNGLGETSAMPLERPARAMETERFV_PROC*)glfwGetProcAddress("glGetSamplerParameterfv");
-    bindings->glGetSamplerParameterIuiv = (PFNGLGETSAMPLERPARAMETERIUIV_PROC*)glfwGetProcAddress("glGetSamplerParameterIuiv");
-    bindings->glQueryCounter = (PFNGLQUERYCOUNTER_PROC*)glfwGetProcAddress("glQueryCounter");
-    bindings->glGetQueryObjecti64v = (PFNGLGETQUERYOBJECTI64V_PROC*)glfwGetProcAddress("glGetQueryObjecti64v");
-    bindings->glGetQueryObjectui64v = (PFNGLGETQUERYOBJECTUI64V_PROC*)glfwGetProcAddress("glGetQueryObjectui64v");
-    bindings->glVertexAttribDivisor = (PFNGLVERTEXATTRIBDIVISOR_PROC*)glfwGetProcAddress("glVertexAttribDivisor");
-    bindings->glVertexAttribP1ui = (PFNGLVERTEXATTRIBP1UI_PROC*)glfwGetProcAddress("glVertexAttribP1ui");
-    bindings->glVertexAttribP1uiv = (PFNGLVERTEXATTRIBP1UIV_PROC*)glfwGetProcAddress("glVertexAttribP1uiv");
-    bindings->glVertexAttribP2ui = (PFNGLVERTEXATTRIBP2UI_PROC*)glfwGetProcAddress("glVertexAttribP2ui");
-    bindings->glVertexAttribP2uiv = (PFNGLVERTEXATTRIBP2UIV_PROC*)glfwGetProcAddress("glVertexAttribP2uiv");
-    bindings->glVertexAttribP3ui = (PFNGLVERTEXATTRIBP3UI_PROC*)glfwGetProcAddress("glVertexAttribP3ui");
-    bindings->glVertexAttribP3uiv = (PFNGLVERTEXATTRIBP3UIV_PROC*)glfwGetProcAddress("glVertexAttribP3uiv");
-    bindings->glVertexAttribP4ui = (PFNGLVERTEXATTRIBP4UI_PROC*)glfwGetProcAddress("glVertexAttribP4ui");
-    bindings->glVertexAttribP4uiv = (PFNGLVERTEXATTRIBP4UIV_PROC*)glfwGetProcAddress("glVertexAttribP4uiv");
-
-}
-
-/* ----------------------- Extension flag definitions ---------------------- */
-
-#ifdef __cplusplus
-}
-#endif
diff --git a/examples/protonect/flextGL.h b/examples/protonect/flextGL.h
deleted file mode 100644
index 3da3d1c9c..000000000
--- a/examples/protonect/flextGL.h
+++ /dev/null
@@ -1,1664 +0,0 @@
-/* WARNING: This file was automatically generated */
-/* Do not edit. */
-
-#ifndef __gl_h_
-#define __gl_h_
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* Function declaration macros - to move into glplatform.h */
-
-#if defined(_WIN32) && !defined(APIENTRY) && !defined(__CYGWIN__) && !defined(__SCITECH_SNAP__)
-#define WIN32_LEAN_AND_MEAN 1
-#ifndef WINAPI
-#define WINAPI __stdcall
-#endif
-#define APIENTRY WINAPI
-#endif
-
-#ifndef APIENTRY
-#define APIENTRY
-#endif
-#ifndef APIENTRYP
-#define APIENTRYP APIENTRY *
-#endif
-#ifndef GLAPI
-#define GLAPI extern
-#endif
-
-/* -------------------------------- DATA TYPES ------------------------------- */
-
-#include <stddef.h>
-#ifndef GLEXT_64_TYPES_DEFINED
-/* This code block is duplicated in glxext.h, so must be protected */
-#define GLEXT_64_TYPES_DEFINED
-/* Define int32_t, int64_t, and uint64_t types for UST/MSC */
-/* (as used in the GL_EXT_timer_query extension). */
-#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
-#include <inttypes.h>
-#elif defined(__sun__) || defined(__digital__)
-#include <inttypes.h>
-#if defined(__STDC__)
-#if defined(__arch64__) || defined(_LP64)
-typedef long int int64_t;
-typedef unsigned long int uint64_t;
-#else
-typedef long long int int64_t;
-typedef unsigned long long int uint64_t;
-#endif /* __arch64__ */
-#endif /* __STDC__ */
-#elif defined( __VMS ) || defined(__sgi)
-#include <inttypes.h>
-#elif defined(__SCO__) || defined(__USLC__)
-#include <stdint.h>
-#elif defined(__UNIXOS2__) || defined(__SOL64__)
-typedef long int int32_t;
-typedef long long int int64_t;
-typedef unsigned long long int uint64_t;
-#elif defined(_WIN32) && defined(__GNUC__)
-#include <stdint.h>
-#elif defined(_WIN32)
-typedef __int32 int32_t;
-typedef __int64 int64_t;
-typedef unsigned __int64 uint64_t;
-#else
-/* Fallback if nothing above works */
-#include <inttypes.h>
-#endif
-#endif
-typedef unsigned int GLenum;
-typedef unsigned char GLboolean;
-typedef unsigned int GLbitfield;
-typedef void GLvoid;
-typedef signed char GLbyte;
-typedef short GLshort;
-typedef int GLint;
-typedef unsigned char GLubyte;
-typedef unsigned short GLushort;
-typedef unsigned int GLuint;
-typedef int GLsizei;
-typedef float GLfloat;
-typedef float GLclampf;
-typedef double GLdouble;
-typedef double GLclampd;
-typedef char GLchar;
-typedef unsigned short GLhalf;
-typedef ptrdiff_t GLintptr;
-typedef ptrdiff_t GLsizeiptr;
-typedef int64_t GLint64;
-typedef uint64_t GLuint64;
-typedef struct __GLsync *GLsync;
-
-/* ----------------------------------- ENUMS --------------------------------- */
-
-/* GL_VERSION_1_1 */
-
-#define GL_DEPTH_BUFFER_BIT 0x00000100
-#define GL_STENCIL_BUFFER_BIT 0x00000400
-#define GL_COLOR_BUFFER_BIT 0x00004000
-#define GL_FALSE 0
-#define GL_TRUE 1
-#define GL_POINTS 0x0000
-#define GL_LINES 0x0001
-#define GL_LINE_LOOP 0x0002
-#define GL_LINE_STRIP 0x0003
-#define GL_TRIANGLES 0x0004
-#define GL_TRIANGLE_STRIP 0x0005
-#define GL_TRIANGLE_FAN 0x0006
-#define GL_NEVER 0x0200
-#define GL_LESS 0x0201
-#define GL_EQUAL 0x0202
-#define GL_LEQUAL 0x0203
-#define GL_GREATER 0x0204
-#define GL_NOTEQUAL 0x0205
-#define GL_GEQUAL 0x0206
-#define GL_ALWAYS 0x0207
-#define GL_ZERO 0
-#define GL_ONE 1
-#define GL_SRC_COLOR 0x0300
-#define GL_ONE_MINUS_SRC_COLOR 0x0301
-#define GL_SRC_ALPHA 0x0302
-#define GL_ONE_MINUS_SRC_ALPHA 0x0303
-#define GL_DST_ALPHA 0x0304
-#define GL_ONE_MINUS_DST_ALPHA 0x0305
-#define GL_DST_COLOR 0x0306
-#define GL_ONE_MINUS_DST_COLOR 0x0307
-#define GL_SRC_ALPHA_SATURATE 0x0308
-#define GL_NONE 0
-#define GL_FRONT_LEFT 0x0400
-#define GL_FRONT_RIGHT 0x0401
-#define GL_BACK_LEFT 0x0402
-#define GL_BACK_RIGHT 0x0403
-#define GL_FRONT 0x0404
-#define GL_BACK 0x0405
-#define GL_LEFT 0x0406
-#define GL_RIGHT 0x0407
-#define GL_FRONT_AND_BACK 0x0408
-#define GL_NO_ERROR 0
-#define GL_INVALID_ENUM 0x0500
-#define GL_INVALID_VALUE 0x0501
-#define GL_INVALID_OPERATION 0x0502
-#define GL_OUT_OF_MEMORY 0x0505
-#define GL_CW 0x0900
-#define GL_CCW 0x0901
-#define GL_POINT_SIZE 0x0B11
-#define GL_POINT_SIZE_RANGE 0x0B12
-#define GL_POINT_SIZE_GRANULARITY 0x0B13
-#define GL_LINE_SMOOTH 0x0B20
-#define GL_LINE_WIDTH 0x0B21
-#define GL_LINE_WIDTH_RANGE 0x0B22
-#define GL_LINE_WIDTH_GRANULARITY 0x0B23
-#define GL_POLYGON_MODE 0x0B40
-#define GL_POLYGON_SMOOTH 0x0B41
-#define GL_CULL_FACE 0x0B44
-#define GL_CULL_FACE_MODE 0x0B45
-#define GL_FRONT_FACE 0x0B46
-#define GL_DEPTH_RANGE 0x0B70
-#define GL_DEPTH_TEST 0x0B71
-#define GL_DEPTH_WRITEMASK 0x0B72
-#define GL_DEPTH_CLEAR_VALUE 0x0B73
-#define GL_DEPTH_FUNC 0x0B74
-#define GL_STENCIL_TEST 0x0B90
-#define GL_STENCIL_CLEAR_VALUE 0x0B91
-#define GL_STENCIL_FUNC 0x0B92
-#define GL_STENCIL_VALUE_MASK 0x0B93
-#define GL_STENCIL_FAIL 0x0B94
-#define GL_STENCIL_PASS_DEPTH_FAIL 0x0B95
-#define GL_STENCIL_PASS_DEPTH_PASS 0x0B96
-#define GL_STENCIL_REF 0x0B97
-#define GL_STENCIL_WRITEMASK 0x0B98
-#define GL_VIEWPORT 0x0BA2
-#define GL_DITHER 0x0BD0
-#define GL_BLEND_DST 0x0BE0
-#define GL_BLEND_SRC 0x0BE1
-#define GL_BLEND 0x0BE2
-#define GL_LOGIC_OP_MODE 0x0BF0
-#define GL_COLOR_LOGIC_OP 0x0BF2
-#define GL_DRAW_BUFFER 0x0C01
-#define GL_READ_BUFFER 0x0C02
-#define GL_SCISSOR_BOX 0x0C10
-#define GL_SCISSOR_TEST 0x0C11
-#define GL_COLOR_CLEAR_VALUE 0x0C22
-#define GL_COLOR_WRITEMASK 0x0C23
-#define GL_DOUBLEBUFFER 0x0C32
-#define GL_STEREO 0x0C33
-#define GL_LINE_SMOOTH_HINT 0x0C52
-#define GL_POLYGON_SMOOTH_HINT 0x0C53
-#define GL_UNPACK_SWAP_BYTES 0x0CF0
-#define GL_UNPACK_LSB_FIRST 0x0CF1
-#define GL_UNPACK_ROW_LENGTH 0x0CF2
-#define GL_UNPACK_SKIP_ROWS 0x0CF3
-#define GL_UNPACK_SKIP_PIXELS 0x0CF4
-#define GL_UNPACK_ALIGNMENT 0x0CF5
-#define GL_PACK_SWAP_BYTES 0x0D00
-#define GL_PACK_LSB_FIRST 0x0D01
-#define GL_PACK_ROW_LENGTH 0x0D02
-#define GL_PACK_SKIP_ROWS 0x0D03
-#define GL_PACK_SKIP_PIXELS 0x0D04
-#define GL_PACK_ALIGNMENT 0x0D05
-#define GL_MAX_TEXTURE_SIZE 0x0D33
-#define GL_MAX_VIEWPORT_DIMS 0x0D3A
-#define GL_SUBPIXEL_BITS 0x0D50
-#define GL_TEXTURE_1D 0x0DE0
-#define GL_TEXTURE_2D 0x0DE1
-#define GL_POLYGON_OFFSET_UNITS 0x2A00
-#define GL_POLYGON_OFFSET_POINT 0x2A01
-#define GL_POLYGON_OFFSET_LINE 0x2A02
-#define GL_POLYGON_OFFSET_FILL 0x8037
-#define GL_POLYGON_OFFSET_FACTOR 0x8038
-#define GL_TEXTURE_BINDING_1D 0x8068
-#define GL_TEXTURE_BINDING_2D 0x8069
-#define GL_TEXTURE_WIDTH 0x1000
-#define GL_TEXTURE_HEIGHT 0x1001
-#define GL_TEXTURE_INTERNAL_FORMAT 0x1003
-#define GL_TEXTURE_BORDER_COLOR 0x1004
-#define GL_TEXTURE_RED_SIZE 0x805C
-#define GL_TEXTURE_GREEN_SIZE 0x805D
-#define GL_TEXTURE_BLUE_SIZE 0x805E
-#define GL_TEXTURE_ALPHA_SIZE 0x805F
-#define GL_DONT_CARE 0x1100
-#define GL_FASTEST 0x1101
-#define GL_NICEST 0x1102
-#define GL_BYTE 0x1400
-#define GL_UNSIGNED_BYTE 0x1401
-#define GL_SHORT 0x1402
-#define GL_UNSIGNED_SHORT 0x1403
-#define GL_INT 0x1404
-#define GL_UNSIGNED_INT 0x1405
-#define GL_FLOAT 0x1406
-#define GL_DOUBLE 0x140A
-#define GL_CLEAR 0x1500
-#define GL_AND 0x1501
-#define GL_AND_REVERSE 0x1502
-#define GL_COPY 0x1503
-#define GL_AND_INVERTED 0x1504
-#define GL_NOOP 0x1505
-#define GL_XOR 0x1506
-#define GL_OR 0x1507
-#define GL_NOR 0x1508
-#define GL_EQUIV 0x1509
-#define GL_INVERT 0x150A
-#define GL_OR_REVERSE 0x150B
-#define GL_COPY_INVERTED 0x150C
-#define GL_OR_INVERTED 0x150D
-#define GL_NAND 0x150E
-#define GL_SET 0x150F
-#define GL_TEXTURE 0x1702
-#define GL_COLOR 0x1800
-#define GL_DEPTH 0x1801
-#define GL_STENCIL 0x1802
-#define GL_STENCIL_INDEX 0x1901
-#define GL_DEPTH_COMPONENT 0x1902
-#define GL_RED 0x1903
-#define GL_GREEN 0x1904
-#define GL_BLUE 0x1905
-#define GL_ALPHA 0x1906
-#define GL_RGB 0x1907
-#define GL_RGBA 0x1908
-#define GL_POINT 0x1B00
-#define GL_LINE 0x1B01
-#define GL_FILL 0x1B02
-#define GL_KEEP 0x1E00
-#define GL_REPLACE 0x1E01
-#define GL_INCR 0x1E02
-#define GL_DECR 0x1E03
-#define GL_VENDOR 0x1F00
-#define GL_RENDERER 0x1F01
-#define GL_VERSION 0x1F02
-#define GL_EXTENSIONS 0x1F03
-#define GL_NEAREST 0x2600
-#define GL_LINEAR 0x2601
-#define GL_NEAREST_MIPMAP_NEAREST 0x2700
-#define GL_LINEAR_MIPMAP_NEAREST 0x2701
-#define GL_NEAREST_MIPMAP_LINEAR 0x2702
-#define GL_LINEAR_MIPMAP_LINEAR 0x2703
-#define GL_TEXTURE_MAG_FILTER 0x2800
-#define GL_TEXTURE_MIN_FILTER 0x2801
-#define GL_TEXTURE_WRAP_S 0x2802
-#define GL_TEXTURE_WRAP_T 0x2803
-#define GL_PROXY_TEXTURE_1D 0x8063
-#define GL_PROXY_TEXTURE_2D 0x8064
-#define GL_REPEAT 0x2901
-#define GL_R3_G3_B2 0x2A10
-#define GL_RGB4 0x804F
-#define GL_RGB5 0x8050
-#define GL_RGB8 0x8051
-#define GL_RGB10 0x8052
-#define GL_RGB12 0x8053
-#define GL_RGB16 0x8054
-#define GL_RGBA2 0x8055
-#define GL_RGBA4 0x8056
-#define GL_RGB5_A1 0x8057
-#define GL_RGBA8 0x8058
-#define GL_RGB10_A2 0x8059
-#define GL_RGBA12 0x805A
-#define GL_RGBA16 0x805B
-
-/* GL_VERSION_1_2 */
-
-#define GL_UNSIGNED_BYTE_3_3_2 0x8032
-#define GL_UNSIGNED_SHORT_4_4_4_4 0x8033
-#define GL_UNSIGNED_SHORT_5_5_5_1 0x8034
-#define GL_UNSIGNED_INT_8_8_8_8 0x8035
-#define GL_UNSIGNED_INT_10_10_10_2 0x8036
-#define GL_TEXTURE_BINDING_3D 0x806A
-#define GL_PACK_SKIP_IMAGES 0x806B
-#define GL_PACK_IMAGE_HEIGHT 0x806C
-#define GL_UNPACK_SKIP_IMAGES 0x806D
-#define GL_UNPACK_IMAGE_HEIGHT 0x806E
-#define GL_TEXTURE_3D 0x806F
-#define GL_PROXY_TEXTURE_3D 0x8070
-#define GL_TEXTURE_DEPTH 0x8071
-#define GL_TEXTURE_WRAP_R 0x8072
-#define GL_MAX_3D_TEXTURE_SIZE 0x8073
-#define GL_UNSIGNED_BYTE_2_3_3_REV 0x8362
-#define GL_UNSIGNED_SHORT_5_6_5 0x8363
-#define GL_UNSIGNED_SHORT_5_6_5_REV 0x8364
-#define GL_UNSIGNED_SHORT_4_4_4_4_REV 0x8365
-#define GL_UNSIGNED_SHORT_1_5_5_5_REV 0x8366
-#define GL_UNSIGNED_INT_8_8_8_8_REV 0x8367
-#define GL_UNSIGNED_INT_2_10_10_10_REV 0x8368
-#define GL_BGR 0x80E0
-#define GL_BGRA 0x80E1
-#define GL_MAX_ELEMENTS_VERTICES 0x80E8
-#define GL_MAX_ELEMENTS_INDICES 0x80E9
-#define GL_CLAMP_TO_EDGE 0x812F
-#define GL_TEXTURE_MIN_LOD 0x813A
-#define GL_TEXTURE_MAX_LOD 0x813B
-#define GL_TEXTURE_BASE_LEVEL 0x813C
-#define GL_TEXTURE_MAX_LEVEL 0x813D
-#define GL_SMOOTH_POINT_SIZE_RANGE 0x0B12
-#define GL_SMOOTH_POINT_SIZE_GRANULARITY 0x0B13
-#define GL_SMOOTH_LINE_WIDTH_RANGE 0x0B22
-#define GL_SMOOTH_LINE_WIDTH_GRANULARITY 0x0B23
-#define GL_ALIASED_LINE_WIDTH_RANGE 0x846E
-
-/* GL_VERSION_1_3 */
-
-#define GL_TEXTURE0 0x84C0
-#define GL_TEXTURE1 0x84C1
-#define GL_TEXTURE2 0x84C2
-#define GL_TEXTURE3 0x84C3
-#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_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_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_TEXTURE30 0x84DE
-#define GL_TEXTURE31 0x84DF
-#define GL_ACTIVE_TEXTURE 0x84E0
-#define GL_MULTISAMPLE 0x809D
-#define GL_SAMPLE_ALPHA_TO_COVERAGE 0x809E
-#define GL_SAMPLE_ALPHA_TO_ONE 0x809F
-#define GL_SAMPLE_COVERAGE 0x80A0
-#define GL_SAMPLE_BUFFERS 0x80A8
-#define GL_SAMPLES 0x80A9
-#define GL_SAMPLE_COVERAGE_VALUE 0x80AA
-#define GL_SAMPLE_COVERAGE_INVERT 0x80AB
-#define GL_TEXTURE_CUBE_MAP 0x8513
-#define GL_TEXTURE_BINDING_CUBE_MAP 0x8514
-#define GL_TEXTURE_CUBE_MAP_POSITIVE_X 0x8515
-#define GL_TEXTURE_CUBE_MAP_NEGATIVE_X 0x8516
-#define GL_TEXTURE_CUBE_MAP_POSITIVE_Y 0x8517
-#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Y 0x8518
-#define GL_TEXTURE_CUBE_MAP_POSITIVE_Z 0x8519
-#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Z 0x851A
-#define GL_PROXY_TEXTURE_CUBE_MAP 0x851B
-#define GL_MAX_CUBE_MAP_TEXTURE_SIZE 0x851C
-#define GL_COMPRESSED_RGB 0x84ED
-#define GL_COMPRESSED_RGBA 0x84EE
-#define GL_TEXTURE_COMPRESSION_HINT 0x84EF
-#define GL_TEXTURE_COMPRESSED_IMAGE_SIZE 0x86A0
-#define GL_TEXTURE_COMPRESSED 0x86A1
-#define GL_NUM_COMPRESSED_TEXTURE_FORMATS 0x86A2
-#define GL_COMPRESSED_TEXTURE_FORMATS 0x86A3
-#define GL_CLAMP_TO_BORDER 0x812D
-
-/* GL_VERSION_1_4 */
-
-#define GL_BLEND_DST_RGB 0x80C8
-#define GL_BLEND_SRC_RGB 0x80C9
-#define GL_BLEND_DST_ALPHA 0x80CA
-#define GL_BLEND_SRC_ALPHA 0x80CB
-#define GL_POINT_FADE_THRESHOLD_SIZE 0x8128
-#define GL_DEPTH_COMPONENT16 0x81A5
-#define GL_DEPTH_COMPONENT24 0x81A6
-#define GL_DEPTH_COMPONENT32 0x81A7
-#define GL_MIRRORED_REPEAT 0x8370
-#define GL_MAX_TEXTURE_LOD_BIAS 0x84FD
-#define GL_TEXTURE_LOD_BIAS 0x8501
-#define GL_INCR_WRAP 0x8507
-#define GL_DECR_WRAP 0x8508
-#define GL_TEXTURE_DEPTH_SIZE 0x884A
-#define GL_TEXTURE_COMPARE_MODE 0x884C
-#define GL_TEXTURE_COMPARE_FUNC 0x884D
-#define GL_FUNC_ADD 0x8006
-#define GL_FUNC_SUBTRACT 0x800A
-#define GL_FUNC_REVERSE_SUBTRACT 0x800B
-#define GL_MIN 0x8007
-#define GL_MAX 0x8008
-#define GL_CONSTANT_COLOR 0x8001
-#define GL_ONE_MINUS_CONSTANT_COLOR 0x8002
-#define GL_CONSTANT_ALPHA 0x8003
-#define GL_ONE_MINUS_CONSTANT_ALPHA 0x8004
-
-/* GL_VERSION_1_5 */
-
-#define GL_BUFFER_SIZE 0x8764
-#define GL_BUFFER_USAGE 0x8765
-#define GL_QUERY_COUNTER_BITS 0x8864
-#define GL_CURRENT_QUERY 0x8865
-#define GL_QUERY_RESULT 0x8866
-#define GL_QUERY_RESULT_AVAILABLE 0x8867
-#define GL_ARRAY_BUFFER 0x8892
-#define GL_ELEMENT_ARRAY_BUFFER 0x8893
-#define GL_ARRAY_BUFFER_BINDING 0x8894
-#define GL_ELEMENT_ARRAY_BUFFER_BINDING 0x8895
-#define GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING 0x889F
-#define GL_READ_ONLY 0x88B8
-#define GL_WRITE_ONLY 0x88B9
-#define GL_READ_WRITE 0x88BA
-#define GL_BUFFER_ACCESS 0x88BB
-#define GL_BUFFER_MAPPED 0x88BC
-#define GL_BUFFER_MAP_POINTER 0x88BD
-#define GL_STREAM_DRAW 0x88E0
-#define GL_STREAM_READ 0x88E1
-#define GL_STREAM_COPY 0x88E2
-#define GL_STATIC_DRAW 0x88E4
-#define GL_STATIC_READ 0x88E5
-#define GL_STATIC_COPY 0x88E6
-#define GL_DYNAMIC_DRAW 0x88E8
-#define GL_DYNAMIC_READ 0x88E9
-#define GL_DYNAMIC_COPY 0x88EA
-#define GL_SAMPLES_PASSED 0x8914
-#define GL_SRC1_ALPHA 0x8589
-
-/* GL_VERSION_2_0 */
-
-#define GL_BLEND_EQUATION_RGB 0x8009
-#define GL_VERTEX_ATTRIB_ARRAY_ENABLED 0x8622
-#define GL_VERTEX_ATTRIB_ARRAY_SIZE 0x8623
-#define GL_VERTEX_ATTRIB_ARRAY_STRIDE 0x8624
-#define GL_VERTEX_ATTRIB_ARRAY_TYPE 0x8625
-#define GL_CURRENT_VERTEX_ATTRIB 0x8626
-#define GL_VERTEX_PROGRAM_POINT_SIZE 0x8642
-#define GL_VERTEX_ATTRIB_ARRAY_POINTER 0x8645
-#define GL_STENCIL_BACK_FUNC 0x8800
-#define GL_STENCIL_BACK_FAIL 0x8801
-#define GL_STENCIL_BACK_PASS_DEPTH_FAIL 0x8802
-#define GL_STENCIL_BACK_PASS_DEPTH_PASS 0x8803
-#define GL_MAX_DRAW_BUFFERS 0x8824
-#define GL_DRAW_BUFFER0 0x8825
-#define GL_DRAW_BUFFER1 0x8826
-#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_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_BLEND_EQUATION_ALPHA 0x883D
-#define GL_MAX_VERTEX_ATTRIBS 0x8869
-#define GL_VERTEX_ATTRIB_ARRAY_NORMALIZED 0x886A
-#define GL_MAX_TEXTURE_IMAGE_UNITS 0x8872
-#define GL_FRAGMENT_SHADER 0x8B30
-#define GL_VERTEX_SHADER 0x8B31
-#define GL_MAX_FRAGMENT_UNIFORM_COMPONENTS 0x8B49
-#define GL_MAX_VERTEX_UNIFORM_COMPONENTS 0x8B4A
-#define GL_MAX_VARYING_FLOATS 0x8B4B
-#define GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS 0x8B4C
-#define GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS 0x8B4D
-#define GL_SHADER_TYPE 0x8B4F
-#define GL_FLOAT_VEC2 0x8B50
-#define GL_FLOAT_VEC3 0x8B51
-#define GL_FLOAT_VEC4 0x8B52
-#define GL_INT_VEC2 0x8B53
-#define GL_INT_VEC3 0x8B54
-#define GL_INT_VEC4 0x8B55
-#define GL_BOOL 0x8B56
-#define GL_BOOL_VEC2 0x8B57
-#define GL_BOOL_VEC3 0x8B58
-#define GL_BOOL_VEC4 0x8B59
-#define GL_FLOAT_MAT2 0x8B5A
-#define GL_FLOAT_MAT3 0x8B5B
-#define GL_FLOAT_MAT4 0x8B5C
-#define GL_SAMPLER_1D 0x8B5D
-#define GL_SAMPLER_2D 0x8B5E
-#define GL_SAMPLER_3D 0x8B5F
-#define GL_SAMPLER_CUBE 0x8B60
-#define GL_SAMPLER_1D_SHADOW 0x8B61
-#define GL_SAMPLER_2D_SHADOW 0x8B62
-#define GL_DELETE_STATUS 0x8B80
-#define GL_COMPILE_STATUS 0x8B81
-#define GL_LINK_STATUS 0x8B82
-#define GL_VALIDATE_STATUS 0x8B83
-#define GL_INFO_LOG_LENGTH 0x8B84
-#define GL_ATTACHED_SHADERS 0x8B85
-#define GL_ACTIVE_UNIFORMS 0x8B86
-#define GL_ACTIVE_UNIFORM_MAX_LENGTH 0x8B87
-#define GL_SHADER_SOURCE_LENGTH 0x8B88
-#define GL_ACTIVE_ATTRIBUTES 0x8B89
-#define GL_ACTIVE_ATTRIBUTE_MAX_LENGTH 0x8B8A
-#define GL_FRAGMENT_SHADER_DERIVATIVE_HINT 0x8B8B
-#define GL_SHADING_LANGUAGE_VERSION 0x8B8C
-#define GL_CURRENT_PROGRAM 0x8B8D
-#define GL_POINT_SPRITE_COORD_ORIGIN 0x8CA0
-#define GL_LOWER_LEFT 0x8CA1
-#define GL_UPPER_LEFT 0x8CA2
-#define GL_STENCIL_BACK_REF 0x8CA3
-#define GL_STENCIL_BACK_VALUE_MASK 0x8CA4
-#define GL_STENCIL_BACK_WRITEMASK 0x8CA5
-
-/* GL_VERSION_2_1 */
-
-#define GL_PIXEL_PACK_BUFFER 0x88EB
-#define GL_PIXEL_UNPACK_BUFFER 0x88EC
-#define GL_PIXEL_PACK_BUFFER_BINDING 0x88ED
-#define GL_PIXEL_UNPACK_BUFFER_BINDING 0x88EF
-#define GL_FLOAT_MAT2x3 0x8B65
-#define GL_FLOAT_MAT2x4 0x8B66
-#define GL_FLOAT_MAT3x2 0x8B67
-#define GL_FLOAT_MAT3x4 0x8B68
-#define GL_FLOAT_MAT4x2 0x8B69
-#define GL_FLOAT_MAT4x3 0x8B6A
-#define GL_SRGB 0x8C40
-#define GL_SRGB8 0x8C41
-#define GL_SRGB_ALPHA 0x8C42
-#define GL_SRGB8_ALPHA8 0x8C43
-#define GL_COMPRESSED_SRGB 0x8C48
-#define GL_COMPRESSED_SRGB_ALPHA 0x8C49
-
-/* GL_VERSION_3_0 */
-
-#define GL_COMPARE_REF_TO_TEXTURE 0x884E
-#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_MAX_CLIP_DISTANCES 0x0D32
-#define GL_MAJOR_VERSION 0x821B
-#define GL_MINOR_VERSION 0x821C
-#define GL_NUM_EXTENSIONS 0x821D
-#define GL_CONTEXT_FLAGS 0x821E
-#define GL_COMPRESSED_RED 0x8225
-#define GL_COMPRESSED_RG 0x8226
-#define GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT 0x00000001
-#define GL_RGBA32F 0x8814
-#define GL_RGB32F 0x8815
-#define GL_RGBA16F 0x881A
-#define GL_RGB16F 0x881B
-#define GL_VERTEX_ATTRIB_ARRAY_INTEGER 0x88FD
-#define GL_MAX_ARRAY_TEXTURE_LAYERS 0x88FF
-#define GL_MIN_PROGRAM_TEXEL_OFFSET 0x8904
-#define GL_MAX_PROGRAM_TEXEL_OFFSET 0x8905
-#define GL_CLAMP_READ_COLOR 0x891C
-#define GL_FIXED_ONLY 0x891D
-#define GL_MAX_VARYING_COMPONENTS 0x8B4B
-#define GL_TEXTURE_1D_ARRAY 0x8C18
-#define GL_PROXY_TEXTURE_1D_ARRAY 0x8C19
-#define GL_TEXTURE_2D_ARRAY 0x8C1A
-#define GL_PROXY_TEXTURE_2D_ARRAY 0x8C1B
-#define GL_TEXTURE_BINDING_1D_ARRAY 0x8C1C
-#define GL_TEXTURE_BINDING_2D_ARRAY 0x8C1D
-#define GL_R11F_G11F_B10F 0x8C3A
-#define GL_UNSIGNED_INT_10F_11F_11F_REV 0x8C3B
-#define GL_RGB9_E5 0x8C3D
-#define GL_UNSIGNED_INT_5_9_9_9_REV 0x8C3E
-#define GL_TEXTURE_SHARED_SIZE 0x8C3F
-#define GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH 0x8C76
-#define GL_TRANSFORM_FEEDBACK_BUFFER_MODE 0x8C7F
-#define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS 0x8C80
-#define GL_TRANSFORM_FEEDBACK_VARYINGS 0x8C83
-#define GL_TRANSFORM_FEEDBACK_BUFFER_START 0x8C84
-#define GL_TRANSFORM_FEEDBACK_BUFFER_SIZE 0x8C85
-#define GL_PRIMITIVES_GENERATED 0x8C87
-#define GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN 0x8C88
-#define GL_RASTERIZER_DISCARD 0x8C89
-#define GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS 0x8C8A
-#define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS 0x8C8B
-#define GL_INTERLEAVED_ATTRIBS 0x8C8C
-#define GL_SEPARATE_ATTRIBS 0x8C8D
-#define GL_TRANSFORM_FEEDBACK_BUFFER 0x8C8E
-#define GL_TRANSFORM_FEEDBACK_BUFFER_BINDING 0x8C8F
-#define GL_RGBA32UI 0x8D70
-#define GL_RGB32UI 0x8D71
-#define GL_RGBA16UI 0x8D76
-#define GL_RGB16UI 0x8D77
-#define GL_RGBA8UI 0x8D7C
-#define GL_RGB8UI 0x8D7D
-#define GL_RGBA32I 0x8D82
-#define GL_RGB32I 0x8D83
-#define GL_RGBA16I 0x8D88
-#define GL_RGB16I 0x8D89
-#define GL_RGBA8I 0x8D8E
-#define GL_RGB8I 0x8D8F
-#define GL_RED_INTEGER 0x8D94
-#define GL_GREEN_INTEGER 0x8D95
-#define GL_BLUE_INTEGER 0x8D96
-#define GL_RGB_INTEGER 0x8D98
-#define GL_RGBA_INTEGER 0x8D99
-#define GL_BGR_INTEGER 0x8D9A
-#define GL_BGRA_INTEGER 0x8D9B
-#define GL_SAMPLER_1D_ARRAY 0x8DC0
-#define GL_SAMPLER_2D_ARRAY 0x8DC1
-#define GL_SAMPLER_1D_ARRAY_SHADOW 0x8DC3
-#define GL_SAMPLER_2D_ARRAY_SHADOW 0x8DC4
-#define GL_SAMPLER_CUBE_SHADOW 0x8DC5
-#define GL_UNSIGNED_INT_VEC2 0x8DC6
-#define GL_UNSIGNED_INT_VEC3 0x8DC7
-#define GL_UNSIGNED_INT_VEC4 0x8DC8
-#define GL_INT_SAMPLER_1D 0x8DC9
-#define GL_INT_SAMPLER_2D 0x8DCA
-#define GL_INT_SAMPLER_3D 0x8DCB
-#define GL_INT_SAMPLER_CUBE 0x8DCC
-#define GL_INT_SAMPLER_1D_ARRAY 0x8DCE
-#define GL_INT_SAMPLER_2D_ARRAY 0x8DCF
-#define GL_UNSIGNED_INT_SAMPLER_1D 0x8DD1
-#define GL_UNSIGNED_INT_SAMPLER_2D 0x8DD2
-#define GL_UNSIGNED_INT_SAMPLER_3D 0x8DD3
-#define GL_UNSIGNED_INT_SAMPLER_CUBE 0x8DD4
-#define GL_UNSIGNED_INT_SAMPLER_1D_ARRAY 0x8DD6
-#define GL_UNSIGNED_INT_SAMPLER_2D_ARRAY 0x8DD7
-#define GL_QUERY_WAIT 0x8E13
-#define GL_QUERY_NO_WAIT 0x8E14
-#define GL_QUERY_BY_REGION_WAIT 0x8E15
-#define GL_QUERY_BY_REGION_NO_WAIT 0x8E16
-#define GL_BUFFER_ACCESS_FLAGS 0x911F
-#define GL_BUFFER_MAP_LENGTH 0x9120
-#define GL_BUFFER_MAP_OFFSET 0x9121
-#define GL_DEPTH_COMPONENT32F 0x8CAC
-#define GL_DEPTH32F_STENCIL8 0x8CAD
-#define GL_FLOAT_32_UNSIGNED_INT_24_8_REV 0x8DAD
-#define GL_INVALID_FRAMEBUFFER_OPERATION 0x0506
-#define GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING 0x8210
-#define GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE 0x8211
-#define GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE 0x8212
-#define GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE 0x8213
-#define GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE 0x8214
-#define GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE 0x8215
-#define GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE 0x8216
-#define GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE 0x8217
-#define GL_FRAMEBUFFER_DEFAULT 0x8218
-#define GL_FRAMEBUFFER_UNDEFINED 0x8219
-#define GL_DEPTH_STENCIL_ATTACHMENT 0x821A
-#define GL_MAX_RENDERBUFFER_SIZE 0x84E8
-#define GL_DEPTH_STENCIL 0x84F9
-#define GL_UNSIGNED_INT_24_8 0x84FA
-#define GL_DEPTH24_STENCIL8 0x88F0
-#define GL_TEXTURE_STENCIL_SIZE 0x88F1
-#define GL_TEXTURE_RED_TYPE 0x8C10
-#define GL_TEXTURE_GREEN_TYPE 0x8C11
-#define GL_TEXTURE_BLUE_TYPE 0x8C12
-#define GL_TEXTURE_ALPHA_TYPE 0x8C13
-#define GL_TEXTURE_DEPTH_TYPE 0x8C16
-#define GL_UNSIGNED_NORMALIZED 0x8C17
-#define GL_FRAMEBUFFER_BINDING 0x8CA6
-#define GL_DRAW_FRAMEBUFFER_BINDING 0x8CA6
-#define GL_RENDERBUFFER_BINDING 0x8CA7
-#define GL_READ_FRAMEBUFFER 0x8CA8
-#define GL_DRAW_FRAMEBUFFER 0x8CA9
-#define GL_READ_FRAMEBUFFER_BINDING 0x8CAA
-#define GL_RENDERBUFFER_SAMPLES 0x8CAB
-#define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE 0x8CD0
-#define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME 0x8CD1
-#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL 0x8CD2
-#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE 0x8CD3
-#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER 0x8CD4
-#define GL_FRAMEBUFFER_COMPLETE 0x8CD5
-#define GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT 0x8CD6
-#define GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT 0x8CD7
-#define GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER 0x8CDB
-#define GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER 0x8CDC
-#define GL_FRAMEBUFFER_UNSUPPORTED 0x8CDD
-#define GL_MAX_COLOR_ATTACHMENTS 0x8CDF
-#define GL_COLOR_ATTACHMENT0 0x8CE0
-#define GL_COLOR_ATTACHMENT1 0x8CE1
-#define GL_COLOR_ATTACHMENT2 0x8CE2
-#define GL_COLOR_ATTACHMENT3 0x8CE3
-#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_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_DEPTH_ATTACHMENT 0x8D00
-#define GL_STENCIL_ATTACHMENT 0x8D20
-#define GL_FRAMEBUFFER 0x8D40
-#define GL_RENDERBUFFER 0x8D41
-#define GL_RENDERBUFFER_WIDTH 0x8D42
-#define GL_RENDERBUFFER_HEIGHT 0x8D43
-#define GL_RENDERBUFFER_INTERNAL_FORMAT 0x8D44
-#define GL_STENCIL_INDEX1 0x8D46
-#define GL_STENCIL_INDEX4 0x8D47
-#define GL_STENCIL_INDEX8 0x8D48
-#define GL_STENCIL_INDEX16 0x8D49
-#define GL_RENDERBUFFER_RED_SIZE 0x8D50
-#define GL_RENDERBUFFER_GREEN_SIZE 0x8D51
-#define GL_RENDERBUFFER_BLUE_SIZE 0x8D52
-#define GL_RENDERBUFFER_ALPHA_SIZE 0x8D53
-#define GL_RENDERBUFFER_DEPTH_SIZE 0x8D54
-#define GL_RENDERBUFFER_STENCIL_SIZE 0x8D55
-#define GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE 0x8D56
-#define GL_MAX_SAMPLES 0x8D57
-#define GL_FRAMEBUFFER_SRGB 0x8DB9
-#define GL_HALF_FLOAT 0x140B
-#define GL_MAP_READ_BIT 0x0001
-#define GL_MAP_WRITE_BIT 0x0002
-#define GL_MAP_INVALIDATE_RANGE_BIT 0x0004
-#define GL_MAP_INVALIDATE_BUFFER_BIT 0x0008
-#define GL_MAP_FLUSH_EXPLICIT_BIT 0x0010
-#define GL_MAP_UNSYNCHRONIZED_BIT 0x0020
-#define GL_COMPRESSED_RED_RGTC1 0x8DBB
-#define GL_COMPRESSED_SIGNED_RED_RGTC1 0x8DBC
-#define GL_COMPRESSED_RG_RGTC2 0x8DBD
-#define GL_COMPRESSED_SIGNED_RG_RGTC2 0x8DBE
-#define GL_RG 0x8227
-#define GL_RG_INTEGER 0x8228
-#define GL_R8 0x8229
-#define GL_R16 0x822A
-#define GL_RG8 0x822B
-#define GL_RG16 0x822C
-#define GL_R16F 0x822D
-#define GL_R32F 0x822E
-#define GL_RG16F 0x822F
-#define GL_RG32F 0x8230
-#define GL_R8I 0x8231
-#define GL_R8UI 0x8232
-#define GL_R16I 0x8233
-#define GL_R16UI 0x8234
-#define GL_R32I 0x8235
-#define GL_R32UI 0x8236
-#define GL_RG8I 0x8237
-#define GL_RG8UI 0x8238
-#define GL_RG16I 0x8239
-#define GL_RG16UI 0x823A
-#define GL_RG32I 0x823B
-#define GL_RG32UI 0x823C
-#define GL_VERTEX_ARRAY_BINDING 0x85B5
-
-/* GL_VERSION_3_1 */
-
-#define GL_SAMPLER_2D_RECT 0x8B63
-#define GL_SAMPLER_2D_RECT_SHADOW 0x8B64
-#define GL_SAMPLER_BUFFER 0x8DC2
-#define GL_INT_SAMPLER_2D_RECT 0x8DCD
-#define GL_INT_SAMPLER_BUFFER 0x8DD0
-#define GL_UNSIGNED_INT_SAMPLER_2D_RECT 0x8DD5
-#define GL_UNSIGNED_INT_SAMPLER_BUFFER 0x8DD8
-#define GL_TEXTURE_BUFFER 0x8C2A
-#define GL_MAX_TEXTURE_BUFFER_SIZE 0x8C2B
-#define GL_TEXTURE_BINDING_BUFFER 0x8C2C
-#define GL_TEXTURE_BUFFER_DATA_STORE_BINDING 0x8C2D
-#define GL_TEXTURE_RECTANGLE 0x84F5
-#define GL_TEXTURE_BINDING_RECTANGLE 0x84F6
-#define GL_PROXY_TEXTURE_RECTANGLE 0x84F7
-#define GL_MAX_RECTANGLE_TEXTURE_SIZE 0x84F8
-#define GL_R8_SNORM 0x8F94
-#define GL_RG8_SNORM 0x8F95
-#define GL_RGB8_SNORM 0x8F96
-#define GL_RGBA8_SNORM 0x8F97
-#define GL_R16_SNORM 0x8F98
-#define GL_RG16_SNORM 0x8F99
-#define GL_RGB16_SNORM 0x8F9A
-#define GL_RGBA16_SNORM 0x8F9B
-#define GL_SIGNED_NORMALIZED 0x8F9C
-#define GL_PRIMITIVE_RESTART 0x8F9D
-#define GL_PRIMITIVE_RESTART_INDEX 0x8F9E
-#define GL_COPY_READ_BUFFER 0x8F36
-#define GL_COPY_WRITE_BUFFER 0x8F37
-#define GL_UNIFORM_BUFFER 0x8A11
-#define GL_UNIFORM_BUFFER_BINDING 0x8A28
-#define GL_UNIFORM_BUFFER_START 0x8A29
-#define GL_UNIFORM_BUFFER_SIZE 0x8A2A
-#define GL_MAX_VERTEX_UNIFORM_BLOCKS 0x8A2B
-#define GL_MAX_GEOMETRY_UNIFORM_BLOCKS 0x8A2C
-#define GL_MAX_FRAGMENT_UNIFORM_BLOCKS 0x8A2D
-#define GL_MAX_COMBINED_UNIFORM_BLOCKS 0x8A2E
-#define GL_MAX_UNIFORM_BUFFER_BINDINGS 0x8A2F
-#define GL_MAX_UNIFORM_BLOCK_SIZE 0x8A30
-#define GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS 0x8A31
-#define GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS 0x8A32
-#define GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS 0x8A33
-#define GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT 0x8A34
-#define GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH 0x8A35
-#define GL_ACTIVE_UNIFORM_BLOCKS 0x8A36
-#define GL_UNIFORM_TYPE 0x8A37
-#define GL_UNIFORM_SIZE 0x8A38
-#define GL_UNIFORM_NAME_LENGTH 0x8A39
-#define GL_UNIFORM_BLOCK_INDEX 0x8A3A
-#define GL_UNIFORM_OFFSET 0x8A3B
-#define GL_UNIFORM_ARRAY_STRIDE 0x8A3C
-#define GL_UNIFORM_MATRIX_STRIDE 0x8A3D
-#define GL_UNIFORM_IS_ROW_MAJOR 0x8A3E
-#define GL_UNIFORM_BLOCK_BINDING 0x8A3F
-#define GL_UNIFORM_BLOCK_DATA_SIZE 0x8A40
-#define GL_UNIFORM_BLOCK_NAME_LENGTH 0x8A41
-#define GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS 0x8A42
-#define GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES 0x8A43
-#define GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER 0x8A44
-#define GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER 0x8A45
-#define GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER 0x8A46
-#define GL_INVALID_INDEX 0xFFFFFFFFu
-
-/* GL_VERSION_3_2 */
-
-#define GL_CONTEXT_CORE_PROFILE_BIT 0x00000001
-#define GL_CONTEXT_COMPATIBILITY_PROFILE_BIT 0x00000002
-#define GL_LINES_ADJACENCY 0x000A
-#define GL_LINE_STRIP_ADJACENCY 0x000B
-#define GL_TRIANGLES_ADJACENCY 0x000C
-#define GL_TRIANGLE_STRIP_ADJACENCY 0x000D
-#define GL_PROGRAM_POINT_SIZE 0x8642
-#define GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS 0x8C29
-#define GL_FRAMEBUFFER_ATTACHMENT_LAYERED 0x8DA7
-#define GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS 0x8DA8
-#define GL_GEOMETRY_SHADER 0x8DD9
-#define GL_GEOMETRY_VERTICES_OUT 0x8916
-#define GL_GEOMETRY_INPUT_TYPE 0x8917
-#define GL_GEOMETRY_OUTPUT_TYPE 0x8918
-#define GL_MAX_GEOMETRY_UNIFORM_COMPONENTS 0x8DDF
-#define GL_MAX_GEOMETRY_OUTPUT_VERTICES 0x8DE0
-#define GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS 0x8DE1
-#define GL_MAX_VERTEX_OUTPUT_COMPONENTS 0x9122
-#define GL_MAX_GEOMETRY_INPUT_COMPONENTS 0x9123
-#define GL_MAX_GEOMETRY_OUTPUT_COMPONENTS 0x9124
-#define GL_MAX_FRAGMENT_INPUT_COMPONENTS 0x9125
-#define GL_CONTEXT_PROFILE_MASK 0x9126
-#define GL_DEPTH_CLAMP 0x864F
-#define GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION 0x8E4C
-#define GL_FIRST_VERTEX_CONVENTION 0x8E4D
-#define GL_LAST_VERTEX_CONVENTION 0x8E4E
-#define GL_PROVOKING_VERTEX 0x8E4F
-#define GL_TEXTURE_CUBE_MAP_SEAMLESS 0x884F
-#define GL_MAX_SERVER_WAIT_TIMEOUT 0x9111
-#define GL_OBJECT_TYPE 0x9112
-#define GL_SYNC_CONDITION 0x9113
-#define GL_SYNC_STATUS 0x9114
-#define GL_SYNC_FLAGS 0x9115
-#define GL_SYNC_FENCE 0x9116
-#define GL_SYNC_GPU_COMMANDS_COMPLETE 0x9117
-#define GL_UNSIGNALED 0x9118
-#define GL_SIGNALED 0x9119
-#define GL_ALREADY_SIGNALED 0x911A
-#define GL_TIMEOUT_EXPIRED 0x911B
-#define GL_CONDITION_SATISFIED 0x911C
-#define GL_WAIT_FAILED 0x911D
-#define GL_TIMEOUT_IGNORED 0xFFFFFFFFFFFFFFFFull
-#define GL_SYNC_FLUSH_COMMANDS_BIT 0x00000001
-#define GL_SAMPLE_POSITION 0x8E50
-#define GL_SAMPLE_MASK 0x8E51
-#define GL_SAMPLE_MASK_VALUE 0x8E52
-#define GL_MAX_SAMPLE_MASK_WORDS 0x8E59
-#define GL_TEXTURE_2D_MULTISAMPLE 0x9100
-#define GL_PROXY_TEXTURE_2D_MULTISAMPLE 0x9101
-#define GL_TEXTURE_2D_MULTISAMPLE_ARRAY 0x9102
-#define GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY 0x9103
-#define GL_TEXTURE_BINDING_2D_MULTISAMPLE 0x9104
-#define GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY 0x9105
-#define GL_TEXTURE_SAMPLES 0x9106
-#define GL_TEXTURE_FIXED_SAMPLE_LOCATIONS 0x9107
-#define GL_SAMPLER_2D_MULTISAMPLE 0x9108
-#define GL_INT_SAMPLER_2D_MULTISAMPLE 0x9109
-#define GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE 0x910A
-#define GL_SAMPLER_2D_MULTISAMPLE_ARRAY 0x910B
-#define GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY 0x910C
-#define GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY 0x910D
-#define GL_MAX_COLOR_TEXTURE_SAMPLES 0x910E
-#define GL_MAX_DEPTH_TEXTURE_SAMPLES 0x910F
-#define GL_MAX_INTEGER_SAMPLES 0x9110
-
-/* GL_VERSION_3_3 */
-
-#define GL_VERTEX_ATTRIB_ARRAY_DIVISOR 0x88FE
-#define GL_SRC1_COLOR 0x88F9
-#define GL_ONE_MINUS_SRC1_COLOR 0x88FA
-#define GL_ONE_MINUS_SRC1_ALPHA 0x88FB
-#define GL_MAX_DUAL_SOURCE_DRAW_BUFFERS 0x88FC
-#define GL_ANY_SAMPLES_PASSED 0x8C2F
-#define GL_SAMPLER_BINDING 0x8919
-#define GL_RGB10_A2UI 0x906F
-#define GL_TEXTURE_SWIZZLE_R 0x8E42
-#define GL_TEXTURE_SWIZZLE_G 0x8E43
-#define GL_TEXTURE_SWIZZLE_B 0x8E44
-#define GL_TEXTURE_SWIZZLE_A 0x8E45
-#define GL_TEXTURE_SWIZZLE_RGBA 0x8E46
-#define GL_TIME_ELAPSED 0x88BF
-#define GL_TIMESTAMP 0x8E28
-#define GL_INT_2_10_10_10_REV 0x8D9F
-
-/* --------------------------- FUNCTION PROTOTYPES --------------------------- */
-
-    
-/* GL_VERSION_1_0 */
-
-GLAPI void APIENTRY glCullFace (GLenum mode);
-GLAPI void APIENTRY glFrontFace (GLenum mode);
-GLAPI void APIENTRY glHint (GLenum target, GLenum mode);
-GLAPI void APIENTRY glLineWidth (GLfloat width);
-GLAPI void APIENTRY glPointSize (GLfloat size);
-GLAPI void APIENTRY glPolygonMode (GLenum face, GLenum mode);
-GLAPI void APIENTRY glScissor (GLint x, GLint y, GLsizei width, GLsizei height);
-GLAPI void APIENTRY glTexParameterf (GLenum target, GLenum pname, GLfloat param);
-GLAPI void APIENTRY glTexParameterfv (GLenum target, GLenum pname, const GLfloat * params);
-GLAPI void APIENTRY glTexParameteri (GLenum target, GLenum pname, GLint param);
-GLAPI void APIENTRY glTexParameteriv (GLenum target, GLenum pname, const GLint * params);
-GLAPI void APIENTRY glTexImage1D (GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void * pixels);
-GLAPI void APIENTRY glTexImage2D (GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void * pixels);
-GLAPI void APIENTRY glDrawBuffer (GLenum buf);
-GLAPI void APIENTRY glClear (GLbitfield mask);
-GLAPI void APIENTRY glClearColor (GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-GLAPI void APIENTRY glClearStencil (GLint s);
-GLAPI void APIENTRY glClearDepth (GLdouble depth);
-GLAPI void APIENTRY glStencilMask (GLuint mask);
-GLAPI void APIENTRY glColorMask (GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
-GLAPI void APIENTRY glDepthMask (GLboolean flag);
-GLAPI void APIENTRY glDisable (GLenum cap);
-GLAPI void APIENTRY glEnable (GLenum cap);
-GLAPI void APIENTRY glFinish (void);
-GLAPI void APIENTRY glFlush (void);
-GLAPI void APIENTRY glBlendFunc (GLenum sfactor, GLenum dfactor);
-GLAPI void APIENTRY glLogicOp (GLenum opcode);
-GLAPI void APIENTRY glStencilFunc (GLenum func, GLint ref, GLuint mask);
-GLAPI void APIENTRY glStencilOp (GLenum fail, GLenum zfail, GLenum zpass);
-GLAPI void APIENTRY glDepthFunc (GLenum func);
-GLAPI void APIENTRY glPixelStoref (GLenum pname, GLfloat param);
-GLAPI void APIENTRY glPixelStorei (GLenum pname, GLint param);
-GLAPI void APIENTRY glReadBuffer (GLenum src);
-GLAPI void APIENTRY glReadPixels (GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void * pixels);
-GLAPI void APIENTRY glGetBooleanv (GLenum pname, GLboolean * data);
-GLAPI void APIENTRY glGetDoublev (GLenum pname, GLdouble * data);
-GLAPI GLenum APIENTRY glGetError (void);
-GLAPI void APIENTRY glGetFloatv (GLenum pname, GLfloat * data);
-GLAPI void APIENTRY glGetIntegerv (GLenum pname, GLint * data);
-GLAPI const GLubyte * APIENTRY glGetString (GLenum name);
-GLAPI void APIENTRY glGetTexImage (GLenum target, GLint level, GLenum format, GLenum type, void * pixels);
-GLAPI void APIENTRY glGetTexParameterfv (GLenum target, GLenum pname, GLfloat * params);
-GLAPI void APIENTRY glGetTexParameteriv (GLenum target, GLenum pname, GLint * params);
-GLAPI void APIENTRY glGetTexLevelParameterfv (GLenum target, GLint level, GLenum pname, GLfloat * params);
-GLAPI void APIENTRY glGetTexLevelParameteriv (GLenum target, GLint level, GLenum pname, GLint * params);
-GLAPI GLboolean APIENTRY glIsEnabled (GLenum cap);
-GLAPI void APIENTRY glDepthRange (GLdouble near, GLdouble far);
-GLAPI void APIENTRY glViewport (GLint x, GLint y, GLsizei width, GLsizei height);
-    
-/* GL_VERSION_1_1 */
-
-GLAPI void APIENTRY glDrawArrays (GLenum mode, GLint first, GLsizei count);
-GLAPI void APIENTRY glDrawElements (GLenum mode, GLsizei count, GLenum type, const void * indices);
-GLAPI void APIENTRY glPolygonOffset (GLfloat factor, GLfloat units);
-GLAPI void APIENTRY glCopyTexImage1D (GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border);
-GLAPI void APIENTRY glCopyTexImage2D (GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
-GLAPI void APIENTRY glCopyTexSubImage1D (GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
-GLAPI void APIENTRY glCopyTexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
-GLAPI void APIENTRY glTexSubImage1D (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void * pixels);
-GLAPI void APIENTRY glTexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void * pixels);
-GLAPI void APIENTRY glBindTexture (GLenum target, GLuint texture);
-GLAPI void APIENTRY glDeleteTextures (GLsizei n, const GLuint * textures);
-GLAPI void APIENTRY glGenTextures (GLsizei n, GLuint * textures);
-GLAPI GLboolean APIENTRY glIsTexture (GLuint texture);
-
-    
-/* GL_VERSION_1_2 */
-  
-typedef void (APIENTRY PFNGLDRAWRANGEELEMENTS_PROC (GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void * indices));
-typedef void (APIENTRY PFNGLTEXIMAGE3D_PROC (GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void * pixels));
-typedef void (APIENTRY PFNGLTEXSUBIMAGE3D_PROC (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 (APIENTRY PFNGLCOPYTEXSUBIMAGE3D_PROC (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height));
-    
-/* GL_VERSION_1_3 */
-  
-typedef void (APIENTRY PFNGLACTIVETEXTURE_PROC (GLenum texture));
-typedef void (APIENTRY PFNGLSAMPLECOVERAGE_PROC (GLfloat value, GLboolean invert));
-typedef void (APIENTRY PFNGLCOMPRESSEDTEXIMAGE3D_PROC (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void * data));
-typedef void (APIENTRY PFNGLCOMPRESSEDTEXIMAGE2D_PROC (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void * data));
-typedef void (APIENTRY PFNGLCOMPRESSEDTEXIMAGE1D_PROC (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void * data));
-typedef void (APIENTRY PFNGLCOMPRESSEDTEXSUBIMAGE3D_PROC (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 (APIENTRY PFNGLCOMPRESSEDTEXSUBIMAGE2D_PROC (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void * data));
-typedef void (APIENTRY PFNGLCOMPRESSEDTEXSUBIMAGE1D_PROC (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void * data));
-typedef void (APIENTRY PFNGLGETCOMPRESSEDTEXIMAGE_PROC (GLenum target, GLint level, void * img));
-    
-/* GL_VERSION_1_4 */
-  
-typedef void (APIENTRY PFNGLBLENDFUNCSEPARATE_PROC (GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha));
-typedef void (APIENTRY PFNGLMULTIDRAWARRAYS_PROC (GLenum mode, const GLint * first, const GLsizei * count, GLsizei drawcount));
-typedef void (APIENTRY PFNGLMULTIDRAWELEMENTS_PROC (GLenum mode, const GLsizei * count, GLenum type, const void *const* indices, GLsizei drawcount));
-typedef void (APIENTRY PFNGLPOINTPARAMETERF_PROC (GLenum pname, GLfloat param));
-typedef void (APIENTRY PFNGLPOINTPARAMETERFV_PROC (GLenum pname, const GLfloat * params));
-typedef void (APIENTRY PFNGLPOINTPARAMETERI_PROC (GLenum pname, GLint param));
-typedef void (APIENTRY PFNGLPOINTPARAMETERIV_PROC (GLenum pname, const GLint * params));
-typedef void (APIENTRY PFNGLBLENDCOLOR_PROC (GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha));
-typedef void (APIENTRY PFNGLBLENDEQUATION_PROC (GLenum mode));
-    
-/* GL_VERSION_1_5 */
-  
-typedef void (APIENTRY PFNGLGENQUERIES_PROC (GLsizei n, GLuint * ids));
-typedef void (APIENTRY PFNGLDELETEQUERIES_PROC (GLsizei n, const GLuint * ids));
-typedef GLboolean (APIENTRY PFNGLISQUERY_PROC (GLuint id));
-typedef void (APIENTRY PFNGLBEGINQUERY_PROC (GLenum target, GLuint id));
-typedef void (APIENTRY PFNGLENDQUERY_PROC (GLenum target));
-typedef void (APIENTRY PFNGLGETQUERYIV_PROC (GLenum target, GLenum pname, GLint * params));
-typedef void (APIENTRY PFNGLGETQUERYOBJECTIV_PROC (GLuint id, GLenum pname, GLint * params));
-typedef void (APIENTRY PFNGLGETQUERYOBJECTUIV_PROC (GLuint id, GLenum pname, GLuint * params));
-typedef void (APIENTRY PFNGLBINDBUFFER_PROC (GLenum target, GLuint buffer));
-typedef void (APIENTRY PFNGLDELETEBUFFERS_PROC (GLsizei n, const GLuint * buffers));
-typedef void (APIENTRY PFNGLGENBUFFERS_PROC (GLsizei n, GLuint * buffers));
-typedef GLboolean (APIENTRY PFNGLISBUFFER_PROC (GLuint buffer));
-typedef void (APIENTRY PFNGLBUFFERDATA_PROC (GLenum target, GLsizeiptr size, const void * data, GLenum usage));
-typedef void (APIENTRY PFNGLBUFFERSUBDATA_PROC (GLenum target, GLintptr offset, GLsizeiptr size, const void * data));
-typedef void (APIENTRY PFNGLGETBUFFERSUBDATA_PROC (GLenum target, GLintptr offset, GLsizeiptr size, void * data));
-typedef void * (APIENTRY PFNGLMAPBUFFER_PROC (GLenum target, GLenum access));
-typedef GLboolean (APIENTRY PFNGLUNMAPBUFFER_PROC (GLenum target));
-typedef void (APIENTRY PFNGLGETBUFFERPARAMETERIV_PROC (GLenum target, GLenum pname, GLint * params));
-typedef void (APIENTRY PFNGLGETBUFFERPOINTERV_PROC (GLenum target, GLenum pname, void ** params));
-    
-/* GL_VERSION_2_0 */
-  
-typedef void (APIENTRY PFNGLBLENDEQUATIONSEPARATE_PROC (GLenum modeRGB, GLenum modeAlpha));
-typedef void (APIENTRY PFNGLDRAWBUFFERS_PROC (GLsizei n, const GLenum * bufs));
-typedef void (APIENTRY PFNGLSTENCILOPSEPARATE_PROC (GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass));
-typedef void (APIENTRY PFNGLSTENCILFUNCSEPARATE_PROC (GLenum face, GLenum func, GLint ref, GLuint mask));
-typedef void (APIENTRY PFNGLSTENCILMASKSEPARATE_PROC (GLenum face, GLuint mask));
-typedef void (APIENTRY PFNGLATTACHSHADER_PROC (GLuint program, GLuint shader));
-typedef void (APIENTRY PFNGLBINDATTRIBLOCATION_PROC (GLuint program, GLuint index, const GLchar * name));
-typedef void (APIENTRY PFNGLCOMPILESHADER_PROC (GLuint shader));
-typedef GLuint (APIENTRY PFNGLCREATEPROGRAM_PROC (void));
-typedef GLuint (APIENTRY PFNGLCREATESHADER_PROC (GLenum type));
-typedef void (APIENTRY PFNGLDELETEPROGRAM_PROC (GLuint program));
-typedef void (APIENTRY PFNGLDELETESHADER_PROC (GLuint shader));
-typedef void (APIENTRY PFNGLDETACHSHADER_PROC (GLuint program, GLuint shader));
-typedef void (APIENTRY PFNGLDISABLEVERTEXATTRIBARRAY_PROC (GLuint index));
-typedef void (APIENTRY PFNGLENABLEVERTEXATTRIBARRAY_PROC (GLuint index));
-typedef void (APIENTRY PFNGLGETACTIVEATTRIB_PROC (GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLint * size, GLenum * type, GLchar * name));
-typedef void (APIENTRY PFNGLGETACTIVEUNIFORM_PROC (GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLint * size, GLenum * type, GLchar * name));
-typedef void (APIENTRY PFNGLGETATTACHEDSHADERS_PROC (GLuint program, GLsizei maxCount, GLsizei * count, GLuint * shaders));
-typedef GLint (APIENTRY PFNGLGETATTRIBLOCATION_PROC (GLuint program, const GLchar * name));
-typedef void (APIENTRY PFNGLGETPROGRAMIV_PROC (GLuint program, GLenum pname, GLint * params));
-typedef void (APIENTRY PFNGLGETPROGRAMINFOLOG_PROC (GLuint program, GLsizei bufSize, GLsizei * length, GLchar * infoLog));
-typedef void (APIENTRY PFNGLGETSHADERIV_PROC (GLuint shader, GLenum pname, GLint * params));
-typedef void (APIENTRY PFNGLGETSHADERINFOLOG_PROC (GLuint shader, GLsizei bufSize, GLsizei * length, GLchar * infoLog));
-typedef void (APIENTRY PFNGLGETSHADERSOURCE_PROC (GLuint shader, GLsizei bufSize, GLsizei * length, GLchar * source));
-typedef GLint (APIENTRY PFNGLGETUNIFORMLOCATION_PROC (GLuint program, const GLchar * name));
-typedef void (APIENTRY PFNGLGETUNIFORMFV_PROC (GLuint program, GLint location, GLfloat * params));
-typedef void (APIENTRY PFNGLGETUNIFORMIV_PROC (GLuint program, GLint location, GLint * params));
-typedef void (APIENTRY PFNGLGETVERTEXATTRIBDV_PROC (GLuint index, GLenum pname, GLdouble * params));
-typedef void (APIENTRY PFNGLGETVERTEXATTRIBFV_PROC (GLuint index, GLenum pname, GLfloat * params));
-typedef void (APIENTRY PFNGLGETVERTEXATTRIBIV_PROC (GLuint index, GLenum pname, GLint * params));
-typedef void (APIENTRY PFNGLGETVERTEXATTRIBPOINTERV_PROC (GLuint index, GLenum pname, void ** pointer));
-typedef GLboolean (APIENTRY PFNGLISPROGRAM_PROC (GLuint program));
-typedef GLboolean (APIENTRY PFNGLISSHADER_PROC (GLuint shader));
-typedef void (APIENTRY PFNGLLINKPROGRAM_PROC (GLuint program));
-typedef void (APIENTRY PFNGLSHADERSOURCE_PROC (GLuint shader, GLsizei count, const GLchar *const* string, const GLint * length));
-typedef void (APIENTRY PFNGLUSEPROGRAM_PROC (GLuint program));
-typedef void (APIENTRY PFNGLUNIFORM1F_PROC (GLint location, GLfloat v0));
-typedef void (APIENTRY PFNGLUNIFORM2F_PROC (GLint location, GLfloat v0, GLfloat v1));
-typedef void (APIENTRY PFNGLUNIFORM3F_PROC (GLint location, GLfloat v0, GLfloat v1, GLfloat v2));
-typedef void (APIENTRY PFNGLUNIFORM4F_PROC (GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3));
-typedef void (APIENTRY PFNGLUNIFORM1I_PROC (GLint location, GLint v0));
-typedef void (APIENTRY PFNGLUNIFORM2I_PROC (GLint location, GLint v0, GLint v1));
-typedef void (APIENTRY PFNGLUNIFORM3I_PROC (GLint location, GLint v0, GLint v1, GLint v2));
-typedef void (APIENTRY PFNGLUNIFORM4I_PROC (GLint location, GLint v0, GLint v1, GLint v2, GLint v3));
-typedef void (APIENTRY PFNGLUNIFORM1FV_PROC (GLint location, GLsizei count, const GLfloat * value));
-typedef void (APIENTRY PFNGLUNIFORM2FV_PROC (GLint location, GLsizei count, const GLfloat * value));
-typedef void (APIENTRY PFNGLUNIFORM3FV_PROC (GLint location, GLsizei count, const GLfloat * value));
-typedef void (APIENTRY PFNGLUNIFORM4FV_PROC (GLint location, GLsizei count, const GLfloat * value));
-typedef void (APIENTRY PFNGLUNIFORM1IV_PROC (GLint location, GLsizei count, const GLint * value));
-typedef void (APIENTRY PFNGLUNIFORM2IV_PROC (GLint location, GLsizei count, const GLint * value));
-typedef void (APIENTRY PFNGLUNIFORM3IV_PROC (GLint location, GLsizei count, const GLint * value));
-typedef void (APIENTRY PFNGLUNIFORM4IV_PROC (GLint location, GLsizei count, const GLint * value));
-typedef void (APIENTRY PFNGLUNIFORMMATRIX2FV_PROC (GLint location, GLsizei count, GLboolean transpose, const GLfloat * value));
-typedef void (APIENTRY PFNGLUNIFORMMATRIX3FV_PROC (GLint location, GLsizei count, GLboolean transpose, const GLfloat * value));
-typedef void (APIENTRY PFNGLUNIFORMMATRIX4FV_PROC (GLint location, GLsizei count, GLboolean transpose, const GLfloat * value));
-typedef void (APIENTRY PFNGLVALIDATEPROGRAM_PROC (GLuint program));
-typedef void (APIENTRY PFNGLVERTEXATTRIB1D_PROC (GLuint index, GLdouble x));
-typedef void (APIENTRY PFNGLVERTEXATTRIB1DV_PROC (GLuint index, const GLdouble * v));
-typedef void (APIENTRY PFNGLVERTEXATTRIB1F_PROC (GLuint index, GLfloat x));
-typedef void (APIENTRY PFNGLVERTEXATTRIB1FV_PROC (GLuint index, const GLfloat * v));
-typedef void (APIENTRY PFNGLVERTEXATTRIB1S_PROC (GLuint index, GLshort x));
-typedef void (APIENTRY PFNGLVERTEXATTRIB1SV_PROC (GLuint index, const GLshort * v));
-typedef void (APIENTRY PFNGLVERTEXATTRIB2D_PROC (GLuint index, GLdouble x, GLdouble y));
-typedef void (APIENTRY PFNGLVERTEXATTRIB2DV_PROC (GLuint index, const GLdouble * v));
-typedef void (APIENTRY PFNGLVERTEXATTRIB2F_PROC (GLuint index, GLfloat x, GLfloat y));
-typedef void (APIENTRY PFNGLVERTEXATTRIB2FV_PROC (GLuint index, const GLfloat * v));
-typedef void (APIENTRY PFNGLVERTEXATTRIB2S_PROC (GLuint index, GLshort x, GLshort y));
-typedef void (APIENTRY PFNGLVERTEXATTRIB2SV_PROC (GLuint index, const GLshort * v));
-typedef void (APIENTRY PFNGLVERTEXATTRIB3D_PROC (GLuint index, GLdouble x, GLdouble y, GLdouble z));
-typedef void (APIENTRY PFNGLVERTEXATTRIB3DV_PROC (GLuint index, const GLdouble * v));
-typedef void (APIENTRY PFNGLVERTEXATTRIB3F_PROC (GLuint index, GLfloat x, GLfloat y, GLfloat z));
-typedef void (APIENTRY PFNGLVERTEXATTRIB3FV_PROC (GLuint index, const GLfloat * v));
-typedef void (APIENTRY PFNGLVERTEXATTRIB3S_PROC (GLuint index, GLshort x, GLshort y, GLshort z));
-typedef void (APIENTRY PFNGLVERTEXATTRIB3SV_PROC (GLuint index, const GLshort * v));
-typedef void (APIENTRY PFNGLVERTEXATTRIB4NBV_PROC (GLuint index, const GLbyte * v));
-typedef void (APIENTRY PFNGLVERTEXATTRIB4NIV_PROC (GLuint index, const GLint * v));
-typedef void (APIENTRY PFNGLVERTEXATTRIB4NSV_PROC (GLuint index, const GLshort * v));
-typedef void (APIENTRY PFNGLVERTEXATTRIB4NUB_PROC (GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w));
-typedef void (APIENTRY PFNGLVERTEXATTRIB4NUBV_PROC (GLuint index, const GLubyte * v));
-typedef void (APIENTRY PFNGLVERTEXATTRIB4NUIV_PROC (GLuint index, const GLuint * v));
-typedef void (APIENTRY PFNGLVERTEXATTRIB4NUSV_PROC (GLuint index, const GLushort * v));
-typedef void (APIENTRY PFNGLVERTEXATTRIB4BV_PROC (GLuint index, const GLbyte * v));
-typedef void (APIENTRY PFNGLVERTEXATTRIB4D_PROC (GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w));
-typedef void (APIENTRY PFNGLVERTEXATTRIB4DV_PROC (GLuint index, const GLdouble * v));
-typedef void (APIENTRY PFNGLVERTEXATTRIB4F_PROC (GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w));
-typedef void (APIENTRY PFNGLVERTEXATTRIB4FV_PROC (GLuint index, const GLfloat * v));
-typedef void (APIENTRY PFNGLVERTEXATTRIB4IV_PROC (GLuint index, const GLint * v));
-typedef void (APIENTRY PFNGLVERTEXATTRIB4S_PROC (GLuint index, GLshort x, GLshort y, GLshort z, GLshort w));
-typedef void (APIENTRY PFNGLVERTEXATTRIB4SV_PROC (GLuint index, const GLshort * v));
-typedef void (APIENTRY PFNGLVERTEXATTRIB4UBV_PROC (GLuint index, const GLubyte * v));
-typedef void (APIENTRY PFNGLVERTEXATTRIB4UIV_PROC (GLuint index, const GLuint * v));
-typedef void (APIENTRY PFNGLVERTEXATTRIB4USV_PROC (GLuint index, const GLushort * v));
-typedef void (APIENTRY PFNGLVERTEXATTRIBPOINTER_PROC (GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void * pointer));
-    
-/* GL_VERSION_2_1 */
-  
-typedef void (APIENTRY PFNGLUNIFORMMATRIX2X3FV_PROC (GLint location, GLsizei count, GLboolean transpose, const GLfloat * value));
-typedef void (APIENTRY PFNGLUNIFORMMATRIX3X2FV_PROC (GLint location, GLsizei count, GLboolean transpose, const GLfloat * value));
-typedef void (APIENTRY PFNGLUNIFORMMATRIX2X4FV_PROC (GLint location, GLsizei count, GLboolean transpose, const GLfloat * value));
-typedef void (APIENTRY PFNGLUNIFORMMATRIX4X2FV_PROC (GLint location, GLsizei count, GLboolean transpose, const GLfloat * value));
-typedef void (APIENTRY PFNGLUNIFORMMATRIX3X4FV_PROC (GLint location, GLsizei count, GLboolean transpose, const GLfloat * value));
-typedef void (APIENTRY PFNGLUNIFORMMATRIX4X3FV_PROC (GLint location, GLsizei count, GLboolean transpose, const GLfloat * value));
-    
-/* GL_VERSION_3_0 */
-  
-typedef void (APIENTRY PFNGLCOLORMASKI_PROC (GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a));
-typedef void (APIENTRY PFNGLGETBOOLEANI_V_PROC (GLenum target, GLuint index, GLboolean * data));
-typedef void (APIENTRY PFNGLGETINTEGERI_V_PROC (GLenum target, GLuint index, GLint * data));
-typedef void (APIENTRY PFNGLENABLEI_PROC (GLenum target, GLuint index));
-typedef void (APIENTRY PFNGLDISABLEI_PROC (GLenum target, GLuint index));
-typedef GLboolean (APIENTRY PFNGLISENABLEDI_PROC (GLenum target, GLuint index));
-typedef void (APIENTRY PFNGLBEGINTRANSFORMFEEDBACK_PROC (GLenum primitiveMode));
-typedef void (APIENTRY PFNGLENDTRANSFORMFEEDBACK_PROC (void));
-typedef void (APIENTRY PFNGLBINDBUFFERRANGE_PROC (GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size));
-typedef void (APIENTRY PFNGLBINDBUFFERBASE_PROC (GLenum target, GLuint index, GLuint buffer));
-typedef void (APIENTRY PFNGLTRANSFORMFEEDBACKVARYINGS_PROC (GLuint program, GLsizei count, const GLchar *const* varyings, GLenum bufferMode));
-typedef void (APIENTRY PFNGLGETTRANSFORMFEEDBACKVARYING_PROC (GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLsizei * size, GLenum * type, GLchar * name));
-typedef void (APIENTRY PFNGLCLAMPCOLOR_PROC (GLenum target, GLenum clamp));
-typedef void (APIENTRY PFNGLBEGINCONDITIONALRENDER_PROC (GLuint id, GLenum mode));
-typedef void (APIENTRY PFNGLENDCONDITIONALRENDER_PROC (void));
-typedef void (APIENTRY PFNGLVERTEXATTRIBIPOINTER_PROC (GLuint index, GLint size, GLenum type, GLsizei stride, const void * pointer));
-typedef void (APIENTRY PFNGLGETVERTEXATTRIBIIV_PROC (GLuint index, GLenum pname, GLint * params));
-typedef void (APIENTRY PFNGLGETVERTEXATTRIBIUIV_PROC (GLuint index, GLenum pname, GLuint * params));
-typedef void (APIENTRY PFNGLVERTEXATTRIBI1I_PROC (GLuint index, GLint x));
-typedef void (APIENTRY PFNGLVERTEXATTRIBI2I_PROC (GLuint index, GLint x, GLint y));
-typedef void (APIENTRY PFNGLVERTEXATTRIBI3I_PROC (GLuint index, GLint x, GLint y, GLint z));
-typedef void (APIENTRY PFNGLVERTEXATTRIBI4I_PROC (GLuint index, GLint x, GLint y, GLint z, GLint w));
-typedef void (APIENTRY PFNGLVERTEXATTRIBI1UI_PROC (GLuint index, GLuint x));
-typedef void (APIENTRY PFNGLVERTEXATTRIBI2UI_PROC (GLuint index, GLuint x, GLuint y));
-typedef void (APIENTRY PFNGLVERTEXATTRIBI3UI_PROC (GLuint index, GLuint x, GLuint y, GLuint z));
-typedef void (APIENTRY PFNGLVERTEXATTRIBI4UI_PROC (GLuint index, GLuint x, GLuint y, GLuint z, GLuint w));
-typedef void (APIENTRY PFNGLVERTEXATTRIBI1IV_PROC (GLuint index, const GLint * v));
-typedef void (APIENTRY PFNGLVERTEXATTRIBI2IV_PROC (GLuint index, const GLint * v));
-typedef void (APIENTRY PFNGLVERTEXATTRIBI3IV_PROC (GLuint index, const GLint * v));
-typedef void (APIENTRY PFNGLVERTEXATTRIBI4IV_PROC (GLuint index, const GLint * v));
-typedef void (APIENTRY PFNGLVERTEXATTRIBI1UIV_PROC (GLuint index, const GLuint * v));
-typedef void (APIENTRY PFNGLVERTEXATTRIBI2UIV_PROC (GLuint index, const GLuint * v));
-typedef void (APIENTRY PFNGLVERTEXATTRIBI3UIV_PROC (GLuint index, const GLuint * v));
-typedef void (APIENTRY PFNGLVERTEXATTRIBI4UIV_PROC (GLuint index, const GLuint * v));
-typedef void (APIENTRY PFNGLVERTEXATTRIBI4BV_PROC (GLuint index, const GLbyte * v));
-typedef void (APIENTRY PFNGLVERTEXATTRIBI4SV_PROC (GLuint index, const GLshort * v));
-typedef void (APIENTRY PFNGLVERTEXATTRIBI4UBV_PROC (GLuint index, const GLubyte * v));
-typedef void (APIENTRY PFNGLVERTEXATTRIBI4USV_PROC (GLuint index, const GLushort * v));
-typedef void (APIENTRY PFNGLGETUNIFORMUIV_PROC (GLuint program, GLint location, GLuint * params));
-typedef void (APIENTRY PFNGLBINDFRAGDATALOCATION_PROC (GLuint program, GLuint color, const GLchar * name));
-typedef GLint (APIENTRY PFNGLGETFRAGDATALOCATION_PROC (GLuint program, const GLchar * name));
-typedef void (APIENTRY PFNGLUNIFORM1UI_PROC (GLint location, GLuint v0));
-typedef void (APIENTRY PFNGLUNIFORM2UI_PROC (GLint location, GLuint v0, GLuint v1));
-typedef void (APIENTRY PFNGLUNIFORM3UI_PROC (GLint location, GLuint v0, GLuint v1, GLuint v2));
-typedef void (APIENTRY PFNGLUNIFORM4UI_PROC (GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3));
-typedef void (APIENTRY PFNGLUNIFORM1UIV_PROC (GLint location, GLsizei count, const GLuint * value));
-typedef void (APIENTRY PFNGLUNIFORM2UIV_PROC (GLint location, GLsizei count, const GLuint * value));
-typedef void (APIENTRY PFNGLUNIFORM3UIV_PROC (GLint location, GLsizei count, const GLuint * value));
-typedef void (APIENTRY PFNGLUNIFORM4UIV_PROC (GLint location, GLsizei count, const GLuint * value));
-typedef void (APIENTRY PFNGLTEXPARAMETERIIV_PROC (GLenum target, GLenum pname, const GLint * params));
-typedef void (APIENTRY PFNGLTEXPARAMETERIUIV_PROC (GLenum target, GLenum pname, const GLuint * params));
-typedef void (APIENTRY PFNGLGETTEXPARAMETERIIV_PROC (GLenum target, GLenum pname, GLint * params));
-typedef void (APIENTRY PFNGLGETTEXPARAMETERIUIV_PROC (GLenum target, GLenum pname, GLuint * params));
-typedef void (APIENTRY PFNGLCLEARBUFFERIV_PROC (GLenum buffer, GLint drawbuffer, const GLint * value));
-typedef void (APIENTRY PFNGLCLEARBUFFERUIV_PROC (GLenum buffer, GLint drawbuffer, const GLuint * value));
-typedef void (APIENTRY PFNGLCLEARBUFFERFV_PROC (GLenum buffer, GLint drawbuffer, const GLfloat * value));
-typedef void (APIENTRY PFNGLCLEARBUFFERFI_PROC (GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil));
-typedef const GLubyte * (APIENTRY PFNGLGETSTRINGI_PROC (GLenum name, GLuint index));
-typedef GLboolean (APIENTRY PFNGLISRENDERBUFFER_PROC (GLuint renderbuffer));
-typedef void (APIENTRY PFNGLBINDRENDERBUFFER_PROC (GLenum target, GLuint renderbuffer));
-typedef void (APIENTRY PFNGLDELETERENDERBUFFERS_PROC (GLsizei n, const GLuint * renderbuffers));
-typedef void (APIENTRY PFNGLGENRENDERBUFFERS_PROC (GLsizei n, GLuint * renderbuffers));
-typedef void (APIENTRY PFNGLRENDERBUFFERSTORAGE_PROC (GLenum target, GLenum internalformat, GLsizei width, GLsizei height));
-typedef void (APIENTRY PFNGLGETRENDERBUFFERPARAMETERIV_PROC (GLenum target, GLenum pname, GLint * params));
-typedef GLboolean (APIENTRY PFNGLISFRAMEBUFFER_PROC (GLuint framebuffer));
-typedef void (APIENTRY PFNGLBINDFRAMEBUFFER_PROC (GLenum target, GLuint framebuffer));
-typedef void (APIENTRY PFNGLDELETEFRAMEBUFFERS_PROC (GLsizei n, const GLuint * framebuffers));
-typedef void (APIENTRY PFNGLGENFRAMEBUFFERS_PROC (GLsizei n, GLuint * framebuffers));
-typedef GLenum (APIENTRY PFNGLCHECKFRAMEBUFFERSTATUS_PROC (GLenum target));
-typedef void (APIENTRY PFNGLFRAMEBUFFERTEXTURE1D_PROC (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level));
-typedef void (APIENTRY PFNGLFRAMEBUFFERTEXTURE2D_PROC (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level));
-typedef void (APIENTRY PFNGLFRAMEBUFFERTEXTURE3D_PROC (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset));
-typedef void (APIENTRY PFNGLFRAMEBUFFERRENDERBUFFER_PROC (GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer));
-typedef void (APIENTRY PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIV_PROC (GLenum target, GLenum attachment, GLenum pname, GLint * params));
-typedef void (APIENTRY PFNGLGENERATEMIPMAP_PROC (GLenum target));
-typedef void (APIENTRY PFNGLBLITFRAMEBUFFER_PROC (GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter));
-typedef void (APIENTRY PFNGLRENDERBUFFERSTORAGEMULTISAMPLE_PROC (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height));
-typedef void (APIENTRY PFNGLFRAMEBUFFERTEXTURELAYER_PROC (GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer));
-typedef void * (APIENTRY PFNGLMAPBUFFERRANGE_PROC (GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access));
-typedef void (APIENTRY PFNGLFLUSHMAPPEDBUFFERRANGE_PROC (GLenum target, GLintptr offset, GLsizeiptr length));
-typedef void (APIENTRY PFNGLBINDVERTEXARRAY_PROC (GLuint array));
-typedef void (APIENTRY PFNGLDELETEVERTEXARRAYS_PROC (GLsizei n, const GLuint * arrays));
-typedef void (APIENTRY PFNGLGENVERTEXARRAYS_PROC (GLsizei n, GLuint * arrays));
-typedef GLboolean (APIENTRY PFNGLISVERTEXARRAY_PROC (GLuint array));
-    
-/* GL_VERSION_3_1 */
-  
-typedef void (APIENTRY PFNGLDRAWARRAYSINSTANCED_PROC (GLenum mode, GLint first, GLsizei count, GLsizei instancecount));
-typedef void (APIENTRY PFNGLDRAWELEMENTSINSTANCED_PROC (GLenum mode, GLsizei count, GLenum type, const void * indices, GLsizei instancecount));
-typedef void (APIENTRY PFNGLTEXBUFFER_PROC (GLenum target, GLenum internalformat, GLuint buffer));
-typedef void (APIENTRY PFNGLPRIMITIVERESTARTINDEX_PROC (GLuint index));
-typedef void (APIENTRY PFNGLCOPYBUFFERSUBDATA_PROC (GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size));
-typedef void (APIENTRY PFNGLGETUNIFORMINDICES_PROC (GLuint program, GLsizei uniformCount, const GLchar *const* uniformNames, GLuint * uniformIndices));
-typedef void (APIENTRY PFNGLGETACTIVEUNIFORMSIV_PROC (GLuint program, GLsizei uniformCount, const GLuint * uniformIndices, GLenum pname, GLint * params));
-typedef void (APIENTRY PFNGLGETACTIVEUNIFORMNAME_PROC (GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei * length, GLchar * uniformName));
-typedef GLuint (APIENTRY PFNGLGETUNIFORMBLOCKINDEX_PROC (GLuint program, const GLchar * uniformBlockName));
-typedef void (APIENTRY PFNGLGETACTIVEUNIFORMBLOCKIV_PROC (GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint * params));
-typedef void (APIENTRY PFNGLGETACTIVEUNIFORMBLOCKNAME_PROC (GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei * length, GLchar * uniformBlockName));
-typedef void (APIENTRY PFNGLUNIFORMBLOCKBINDING_PROC (GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding));
-    
-/* GL_VERSION_3_2 */
-  
-typedef void (APIENTRY PFNGLDRAWELEMENTSBASEVERTEX_PROC (GLenum mode, GLsizei count, GLenum type, const void * indices, GLint basevertex));
-typedef void (APIENTRY PFNGLDRAWRANGEELEMENTSBASEVERTEX_PROC (GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void * indices, GLint basevertex));
-typedef void (APIENTRY PFNGLDRAWELEMENTSINSTANCEDBASEVERTEX_PROC (GLenum mode, GLsizei count, GLenum type, const void * indices, GLsizei instancecount, GLint basevertex));
-typedef void (APIENTRY PFNGLMULTIDRAWELEMENTSBASEVERTEX_PROC (GLenum mode, const GLsizei * count, GLenum type, const void *const* indices, GLsizei drawcount, const GLint * basevertex));
-typedef void (APIENTRY PFNGLPROVOKINGVERTEX_PROC (GLenum mode));
-typedef GLsync (APIENTRY PFNGLFENCESYNC_PROC (GLenum condition, GLbitfield flags));
-typedef GLboolean (APIENTRY PFNGLISSYNC_PROC (GLsync sync));
-typedef void (APIENTRY PFNGLDELETESYNC_PROC (GLsync sync));
-typedef GLenum (APIENTRY PFNGLCLIENTWAITSYNC_PROC (GLsync sync, GLbitfield flags, GLuint64 timeout));
-typedef void (APIENTRY PFNGLWAITSYNC_PROC (GLsync sync, GLbitfield flags, GLuint64 timeout));
-typedef void (APIENTRY PFNGLGETINTEGER64V_PROC (GLenum pname, GLint64 * data));
-typedef void (APIENTRY PFNGLGETSYNCIV_PROC (GLsync sync, GLenum pname, GLsizei bufSize, GLsizei * length, GLint * values));
-typedef void (APIENTRY PFNGLGETINTEGER64I_V_PROC (GLenum target, GLuint index, GLint64 * data));
-typedef void (APIENTRY PFNGLGETBUFFERPARAMETERI64V_PROC (GLenum target, GLenum pname, GLint64 * params));
-typedef void (APIENTRY PFNGLFRAMEBUFFERTEXTURE_PROC (GLenum target, GLenum attachment, GLuint texture, GLint level));
-typedef void (APIENTRY PFNGLTEXIMAGE2DMULTISAMPLE_PROC (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations));
-typedef void (APIENTRY PFNGLTEXIMAGE3DMULTISAMPLE_PROC (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations));
-typedef void (APIENTRY PFNGLGETMULTISAMPLEFV_PROC (GLenum pname, GLuint index, GLfloat * val));
-typedef void (APIENTRY PFNGLSAMPLEMASKI_PROC (GLuint maskNumber, GLbitfield mask));
-    
-/* GL_VERSION_3_3 */
-  
-typedef void (APIENTRY PFNGLBINDFRAGDATALOCATIONINDEXED_PROC (GLuint program, GLuint colorNumber, GLuint index, const GLchar * name));
-typedef GLint (APIENTRY PFNGLGETFRAGDATAINDEX_PROC (GLuint program, const GLchar * name));
-typedef void (APIENTRY PFNGLGENSAMPLERS_PROC (GLsizei count, GLuint * samplers));
-typedef void (APIENTRY PFNGLDELETESAMPLERS_PROC (GLsizei count, const GLuint * samplers));
-typedef GLboolean (APIENTRY PFNGLISSAMPLER_PROC (GLuint sampler));
-typedef void (APIENTRY PFNGLBINDSAMPLER_PROC (GLuint unit, GLuint sampler));
-typedef void (APIENTRY PFNGLSAMPLERPARAMETERI_PROC (GLuint sampler, GLenum pname, GLint param));
-typedef void (APIENTRY PFNGLSAMPLERPARAMETERIV_PROC (GLuint sampler, GLenum pname, const GLint * param));
-typedef void (APIENTRY PFNGLSAMPLERPARAMETERF_PROC (GLuint sampler, GLenum pname, GLfloat param));
-typedef void (APIENTRY PFNGLSAMPLERPARAMETERFV_PROC (GLuint sampler, GLenum pname, const GLfloat * param));
-typedef void (APIENTRY PFNGLSAMPLERPARAMETERIIV_PROC (GLuint sampler, GLenum pname, const GLint * param));
-typedef void (APIENTRY PFNGLSAMPLERPARAMETERIUIV_PROC (GLuint sampler, GLenum pname, const GLuint * param));
-typedef void (APIENTRY PFNGLGETSAMPLERPARAMETERIV_PROC (GLuint sampler, GLenum pname, GLint * params));
-typedef void (APIENTRY PFNGLGETSAMPLERPARAMETERIIV_PROC (GLuint sampler, GLenum pname, GLint * params));
-typedef void (APIENTRY PFNGLGETSAMPLERPARAMETERFV_PROC (GLuint sampler, GLenum pname, GLfloat * params));
-typedef void (APIENTRY PFNGLGETSAMPLERPARAMETERIUIV_PROC (GLuint sampler, GLenum pname, GLuint * params));
-typedef void (APIENTRY PFNGLQUERYCOUNTER_PROC (GLuint id, GLenum target));
-typedef void (APIENTRY PFNGLGETQUERYOBJECTI64V_PROC (GLuint id, GLenum pname, GLint64 * params));
-typedef void (APIENTRY PFNGLGETQUERYOBJECTUI64V_PROC (GLuint id, GLenum pname, GLuint64 * params));
-typedef void (APIENTRY PFNGLVERTEXATTRIBDIVISOR_PROC (GLuint index, GLuint divisor));
-typedef void (APIENTRY PFNGLVERTEXATTRIBP1UI_PROC (GLuint index, GLenum type, GLboolean normalized, GLuint value));
-typedef void (APIENTRY PFNGLVERTEXATTRIBP1UIV_PROC (GLuint index, GLenum type, GLboolean normalized, const GLuint * value));
-typedef void (APIENTRY PFNGLVERTEXATTRIBP2UI_PROC (GLuint index, GLenum type, GLboolean normalized, GLuint value));
-typedef void (APIENTRY PFNGLVERTEXATTRIBP2UIV_PROC (GLuint index, GLenum type, GLboolean normalized, const GLuint * value));
-typedef void (APIENTRY PFNGLVERTEXATTRIBP3UI_PROC (GLuint index, GLenum type, GLboolean normalized, GLuint value));
-typedef void (APIENTRY PFNGLVERTEXATTRIBP3UIV_PROC (GLuint index, GLenum type, GLboolean normalized, const GLuint * value));
-typedef void (APIENTRY PFNGLVERTEXATTRIBP4UI_PROC (GLuint index, GLenum type, GLboolean normalized, GLuint value));
-typedef void (APIENTRY PFNGLVERTEXATTRIBP4UIV_PROC (GLuint index, GLenum type, GLboolean normalized, const GLuint * value));
-        
-struct OpenGLBindings
-{
-    
-  /* GL_VERSION_1_2 */
-
-  PFNGLDRAWRANGEELEMENTS_PROC* glDrawRangeElements;
-  PFNGLTEXIMAGE3D_PROC* glTexImage3D;
-  PFNGLTEXSUBIMAGE3D_PROC* glTexSubImage3D;
-  PFNGLCOPYTEXSUBIMAGE3D_PROC* glCopyTexSubImage3D;
-    
-  /* GL_VERSION_1_3 */
-
-  PFNGLACTIVETEXTURE_PROC* glActiveTexture;
-  PFNGLSAMPLECOVERAGE_PROC* glSampleCoverage;
-  PFNGLCOMPRESSEDTEXIMAGE3D_PROC* glCompressedTexImage3D;
-  PFNGLCOMPRESSEDTEXIMAGE2D_PROC* glCompressedTexImage2D;
-  PFNGLCOMPRESSEDTEXIMAGE1D_PROC* glCompressedTexImage1D;
-  PFNGLCOMPRESSEDTEXSUBIMAGE3D_PROC* glCompressedTexSubImage3D;
-  PFNGLCOMPRESSEDTEXSUBIMAGE2D_PROC* glCompressedTexSubImage2D;
-  PFNGLCOMPRESSEDTEXSUBIMAGE1D_PROC* glCompressedTexSubImage1D;
-  PFNGLGETCOMPRESSEDTEXIMAGE_PROC* glGetCompressedTexImage;
-    
-  /* GL_VERSION_1_4 */
-
-  PFNGLBLENDFUNCSEPARATE_PROC* glBlendFuncSeparate;
-  PFNGLMULTIDRAWARRAYS_PROC* glMultiDrawArrays;
-  PFNGLMULTIDRAWELEMENTS_PROC* glMultiDrawElements;
-  PFNGLPOINTPARAMETERF_PROC* glPointParameterf;
-  PFNGLPOINTPARAMETERFV_PROC* glPointParameterfv;
-  PFNGLPOINTPARAMETERI_PROC* glPointParameteri;
-  PFNGLPOINTPARAMETERIV_PROC* glPointParameteriv;
-  PFNGLBLENDCOLOR_PROC* glBlendColor;
-  PFNGLBLENDEQUATION_PROC* glBlendEquation;
-    
-  /* GL_VERSION_1_5 */
-
-  PFNGLGENQUERIES_PROC* glGenQueries;
-  PFNGLDELETEQUERIES_PROC* glDeleteQueries;
-  PFNGLISQUERY_PROC* glIsQuery;
-  PFNGLBEGINQUERY_PROC* glBeginQuery;
-  PFNGLENDQUERY_PROC* glEndQuery;
-  PFNGLGETQUERYIV_PROC* glGetQueryiv;
-  PFNGLGETQUERYOBJECTIV_PROC* glGetQueryObjectiv;
-  PFNGLGETQUERYOBJECTUIV_PROC* glGetQueryObjectuiv;
-  PFNGLBINDBUFFER_PROC* glBindBuffer;
-  PFNGLDELETEBUFFERS_PROC* glDeleteBuffers;
-  PFNGLGENBUFFERS_PROC* glGenBuffers;
-  PFNGLISBUFFER_PROC* glIsBuffer;
-  PFNGLBUFFERDATA_PROC* glBufferData;
-  PFNGLBUFFERSUBDATA_PROC* glBufferSubData;
-  PFNGLGETBUFFERSUBDATA_PROC* glGetBufferSubData;
-  PFNGLMAPBUFFER_PROC* glMapBuffer;
-  PFNGLUNMAPBUFFER_PROC* glUnmapBuffer;
-  PFNGLGETBUFFERPARAMETERIV_PROC* glGetBufferParameteriv;
-  PFNGLGETBUFFERPOINTERV_PROC* glGetBufferPointerv;
-    
-  /* GL_VERSION_2_0 */
-
-  PFNGLBLENDEQUATIONSEPARATE_PROC* glBlendEquationSeparate;
-  PFNGLDRAWBUFFERS_PROC* glDrawBuffers;
-  PFNGLSTENCILOPSEPARATE_PROC* glStencilOpSeparate;
-  PFNGLSTENCILFUNCSEPARATE_PROC* glStencilFuncSeparate;
-  PFNGLSTENCILMASKSEPARATE_PROC* glStencilMaskSeparate;
-  PFNGLATTACHSHADER_PROC* glAttachShader;
-  PFNGLBINDATTRIBLOCATION_PROC* glBindAttribLocation;
-  PFNGLCOMPILESHADER_PROC* glCompileShader;
-  PFNGLCREATEPROGRAM_PROC* glCreateProgram;
-  PFNGLCREATESHADER_PROC* glCreateShader;
-  PFNGLDELETEPROGRAM_PROC* glDeleteProgram;
-  PFNGLDELETESHADER_PROC* glDeleteShader;
-  PFNGLDETACHSHADER_PROC* glDetachShader;
-  PFNGLDISABLEVERTEXATTRIBARRAY_PROC* glDisableVertexAttribArray;
-  PFNGLENABLEVERTEXATTRIBARRAY_PROC* glEnableVertexAttribArray;
-  PFNGLGETACTIVEATTRIB_PROC* glGetActiveAttrib;
-  PFNGLGETACTIVEUNIFORM_PROC* glGetActiveUniform;
-  PFNGLGETATTACHEDSHADERS_PROC* glGetAttachedShaders;
-  PFNGLGETATTRIBLOCATION_PROC* glGetAttribLocation;
-  PFNGLGETPROGRAMIV_PROC* glGetProgramiv;
-  PFNGLGETPROGRAMINFOLOG_PROC* glGetProgramInfoLog;
-  PFNGLGETSHADERIV_PROC* glGetShaderiv;
-  PFNGLGETSHADERINFOLOG_PROC* glGetShaderInfoLog;
-  PFNGLGETSHADERSOURCE_PROC* glGetShaderSource;
-  PFNGLGETUNIFORMLOCATION_PROC* glGetUniformLocation;
-  PFNGLGETUNIFORMFV_PROC* glGetUniformfv;
-  PFNGLGETUNIFORMIV_PROC* glGetUniformiv;
-  PFNGLGETVERTEXATTRIBDV_PROC* glGetVertexAttribdv;
-  PFNGLGETVERTEXATTRIBFV_PROC* glGetVertexAttribfv;
-  PFNGLGETVERTEXATTRIBIV_PROC* glGetVertexAttribiv;
-  PFNGLGETVERTEXATTRIBPOINTERV_PROC* glGetVertexAttribPointerv;
-  PFNGLISPROGRAM_PROC* glIsProgram;
-  PFNGLISSHADER_PROC* glIsShader;
-  PFNGLLINKPROGRAM_PROC* glLinkProgram;
-  PFNGLSHADERSOURCE_PROC* glShaderSource;
-  PFNGLUSEPROGRAM_PROC* glUseProgram;
-  PFNGLUNIFORM1F_PROC* glUniform1f;
-  PFNGLUNIFORM2F_PROC* glUniform2f;
-  PFNGLUNIFORM3F_PROC* glUniform3f;
-  PFNGLUNIFORM4F_PROC* glUniform4f;
-  PFNGLUNIFORM1I_PROC* glUniform1i;
-  PFNGLUNIFORM2I_PROC* glUniform2i;
-  PFNGLUNIFORM3I_PROC* glUniform3i;
-  PFNGLUNIFORM4I_PROC* glUniform4i;
-  PFNGLUNIFORM1FV_PROC* glUniform1fv;
-  PFNGLUNIFORM2FV_PROC* glUniform2fv;
-  PFNGLUNIFORM3FV_PROC* glUniform3fv;
-  PFNGLUNIFORM4FV_PROC* glUniform4fv;
-  PFNGLUNIFORM1IV_PROC* glUniform1iv;
-  PFNGLUNIFORM2IV_PROC* glUniform2iv;
-  PFNGLUNIFORM3IV_PROC* glUniform3iv;
-  PFNGLUNIFORM4IV_PROC* glUniform4iv;
-  PFNGLUNIFORMMATRIX2FV_PROC* glUniformMatrix2fv;
-  PFNGLUNIFORMMATRIX3FV_PROC* glUniformMatrix3fv;
-  PFNGLUNIFORMMATRIX4FV_PROC* glUniformMatrix4fv;
-  PFNGLVALIDATEPROGRAM_PROC* glValidateProgram;
-  PFNGLVERTEXATTRIB1D_PROC* glVertexAttrib1d;
-  PFNGLVERTEXATTRIB1DV_PROC* glVertexAttrib1dv;
-  PFNGLVERTEXATTRIB1F_PROC* glVertexAttrib1f;
-  PFNGLVERTEXATTRIB1FV_PROC* glVertexAttrib1fv;
-  PFNGLVERTEXATTRIB1S_PROC* glVertexAttrib1s;
-  PFNGLVERTEXATTRIB1SV_PROC* glVertexAttrib1sv;
-  PFNGLVERTEXATTRIB2D_PROC* glVertexAttrib2d;
-  PFNGLVERTEXATTRIB2DV_PROC* glVertexAttrib2dv;
-  PFNGLVERTEXATTRIB2F_PROC* glVertexAttrib2f;
-  PFNGLVERTEXATTRIB2FV_PROC* glVertexAttrib2fv;
-  PFNGLVERTEXATTRIB2S_PROC* glVertexAttrib2s;
-  PFNGLVERTEXATTRIB2SV_PROC* glVertexAttrib2sv;
-  PFNGLVERTEXATTRIB3D_PROC* glVertexAttrib3d;
-  PFNGLVERTEXATTRIB3DV_PROC* glVertexAttrib3dv;
-  PFNGLVERTEXATTRIB3F_PROC* glVertexAttrib3f;
-  PFNGLVERTEXATTRIB3FV_PROC* glVertexAttrib3fv;
-  PFNGLVERTEXATTRIB3S_PROC* glVertexAttrib3s;
-  PFNGLVERTEXATTRIB3SV_PROC* glVertexAttrib3sv;
-  PFNGLVERTEXATTRIB4NBV_PROC* glVertexAttrib4Nbv;
-  PFNGLVERTEXATTRIB4NIV_PROC* glVertexAttrib4Niv;
-  PFNGLVERTEXATTRIB4NSV_PROC* glVertexAttrib4Nsv;
-  PFNGLVERTEXATTRIB4NUB_PROC* glVertexAttrib4Nub;
-  PFNGLVERTEXATTRIB4NUBV_PROC* glVertexAttrib4Nubv;
-  PFNGLVERTEXATTRIB4NUIV_PROC* glVertexAttrib4Nuiv;
-  PFNGLVERTEXATTRIB4NUSV_PROC* glVertexAttrib4Nusv;
-  PFNGLVERTEXATTRIB4BV_PROC* glVertexAttrib4bv;
-  PFNGLVERTEXATTRIB4D_PROC* glVertexAttrib4d;
-  PFNGLVERTEXATTRIB4DV_PROC* glVertexAttrib4dv;
-  PFNGLVERTEXATTRIB4F_PROC* glVertexAttrib4f;
-  PFNGLVERTEXATTRIB4FV_PROC* glVertexAttrib4fv;
-  PFNGLVERTEXATTRIB4IV_PROC* glVertexAttrib4iv;
-  PFNGLVERTEXATTRIB4S_PROC* glVertexAttrib4s;
-  PFNGLVERTEXATTRIB4SV_PROC* glVertexAttrib4sv;
-  PFNGLVERTEXATTRIB4UBV_PROC* glVertexAttrib4ubv;
-  PFNGLVERTEXATTRIB4UIV_PROC* glVertexAttrib4uiv;
-  PFNGLVERTEXATTRIB4USV_PROC* glVertexAttrib4usv;
-  PFNGLVERTEXATTRIBPOINTER_PROC* glVertexAttribPointer;
-    
-  /* GL_VERSION_2_1 */
-
-  PFNGLUNIFORMMATRIX2X3FV_PROC* glUniformMatrix2x3fv;
-  PFNGLUNIFORMMATRIX3X2FV_PROC* glUniformMatrix3x2fv;
-  PFNGLUNIFORMMATRIX2X4FV_PROC* glUniformMatrix2x4fv;
-  PFNGLUNIFORMMATRIX4X2FV_PROC* glUniformMatrix4x2fv;
-  PFNGLUNIFORMMATRIX3X4FV_PROC* glUniformMatrix3x4fv;
-  PFNGLUNIFORMMATRIX4X3FV_PROC* glUniformMatrix4x3fv;
-    
-  /* GL_VERSION_3_0 */
-
-  PFNGLCOLORMASKI_PROC* glColorMaski;
-  PFNGLGETBOOLEANI_V_PROC* glGetBooleani_v;
-  PFNGLGETINTEGERI_V_PROC* glGetIntegeri_v;
-  PFNGLENABLEI_PROC* glEnablei;
-  PFNGLDISABLEI_PROC* glDisablei;
-  PFNGLISENABLEDI_PROC* glIsEnabledi;
-  PFNGLBEGINTRANSFORMFEEDBACK_PROC* glBeginTransformFeedback;
-  PFNGLENDTRANSFORMFEEDBACK_PROC* glEndTransformFeedback;
-  PFNGLBINDBUFFERRANGE_PROC* glBindBufferRange;
-  PFNGLBINDBUFFERBASE_PROC* glBindBufferBase;
-  PFNGLTRANSFORMFEEDBACKVARYINGS_PROC* glTransformFeedbackVaryings;
-  PFNGLGETTRANSFORMFEEDBACKVARYING_PROC* glGetTransformFeedbackVarying;
-  PFNGLCLAMPCOLOR_PROC* glClampColor;
-  PFNGLBEGINCONDITIONALRENDER_PROC* glBeginConditionalRender;
-  PFNGLENDCONDITIONALRENDER_PROC* glEndConditionalRender;
-  PFNGLVERTEXATTRIBIPOINTER_PROC* glVertexAttribIPointer;
-  PFNGLGETVERTEXATTRIBIIV_PROC* glGetVertexAttribIiv;
-  PFNGLGETVERTEXATTRIBIUIV_PROC* glGetVertexAttribIuiv;
-  PFNGLVERTEXATTRIBI1I_PROC* glVertexAttribI1i;
-  PFNGLVERTEXATTRIBI2I_PROC* glVertexAttribI2i;
-  PFNGLVERTEXATTRIBI3I_PROC* glVertexAttribI3i;
-  PFNGLVERTEXATTRIBI4I_PROC* glVertexAttribI4i;
-  PFNGLVERTEXATTRIBI1UI_PROC* glVertexAttribI1ui;
-  PFNGLVERTEXATTRIBI2UI_PROC* glVertexAttribI2ui;
-  PFNGLVERTEXATTRIBI3UI_PROC* glVertexAttribI3ui;
-  PFNGLVERTEXATTRIBI4UI_PROC* glVertexAttribI4ui;
-  PFNGLVERTEXATTRIBI1IV_PROC* glVertexAttribI1iv;
-  PFNGLVERTEXATTRIBI2IV_PROC* glVertexAttribI2iv;
-  PFNGLVERTEXATTRIBI3IV_PROC* glVertexAttribI3iv;
-  PFNGLVERTEXATTRIBI4IV_PROC* glVertexAttribI4iv;
-  PFNGLVERTEXATTRIBI1UIV_PROC* glVertexAttribI1uiv;
-  PFNGLVERTEXATTRIBI2UIV_PROC* glVertexAttribI2uiv;
-  PFNGLVERTEXATTRIBI3UIV_PROC* glVertexAttribI3uiv;
-  PFNGLVERTEXATTRIBI4UIV_PROC* glVertexAttribI4uiv;
-  PFNGLVERTEXATTRIBI4BV_PROC* glVertexAttribI4bv;
-  PFNGLVERTEXATTRIBI4SV_PROC* glVertexAttribI4sv;
-  PFNGLVERTEXATTRIBI4UBV_PROC* glVertexAttribI4ubv;
-  PFNGLVERTEXATTRIBI4USV_PROC* glVertexAttribI4usv;
-  PFNGLGETUNIFORMUIV_PROC* glGetUniformuiv;
-  PFNGLBINDFRAGDATALOCATION_PROC* glBindFragDataLocation;
-  PFNGLGETFRAGDATALOCATION_PROC* glGetFragDataLocation;
-  PFNGLUNIFORM1UI_PROC* glUniform1ui;
-  PFNGLUNIFORM2UI_PROC* glUniform2ui;
-  PFNGLUNIFORM3UI_PROC* glUniform3ui;
-  PFNGLUNIFORM4UI_PROC* glUniform4ui;
-  PFNGLUNIFORM1UIV_PROC* glUniform1uiv;
-  PFNGLUNIFORM2UIV_PROC* glUniform2uiv;
-  PFNGLUNIFORM3UIV_PROC* glUniform3uiv;
-  PFNGLUNIFORM4UIV_PROC* glUniform4uiv;
-  PFNGLTEXPARAMETERIIV_PROC* glTexParameterIiv;
-  PFNGLTEXPARAMETERIUIV_PROC* glTexParameterIuiv;
-  PFNGLGETTEXPARAMETERIIV_PROC* glGetTexParameterIiv;
-  PFNGLGETTEXPARAMETERIUIV_PROC* glGetTexParameterIuiv;
-  PFNGLCLEARBUFFERIV_PROC* glClearBufferiv;
-  PFNGLCLEARBUFFERUIV_PROC* glClearBufferuiv;
-  PFNGLCLEARBUFFERFV_PROC* glClearBufferfv;
-  PFNGLCLEARBUFFERFI_PROC* glClearBufferfi;
-  PFNGLGETSTRINGI_PROC* glGetStringi;
-  PFNGLISRENDERBUFFER_PROC* glIsRenderbuffer;
-  PFNGLBINDRENDERBUFFER_PROC* glBindRenderbuffer;
-  PFNGLDELETERENDERBUFFERS_PROC* glDeleteRenderbuffers;
-  PFNGLGENRENDERBUFFERS_PROC* glGenRenderbuffers;
-  PFNGLRENDERBUFFERSTORAGE_PROC* glRenderbufferStorage;
-  PFNGLGETRENDERBUFFERPARAMETERIV_PROC* glGetRenderbufferParameteriv;
-  PFNGLISFRAMEBUFFER_PROC* glIsFramebuffer;
-  PFNGLBINDFRAMEBUFFER_PROC* glBindFramebuffer;
-  PFNGLDELETEFRAMEBUFFERS_PROC* glDeleteFramebuffers;
-  PFNGLGENFRAMEBUFFERS_PROC* glGenFramebuffers;
-  PFNGLCHECKFRAMEBUFFERSTATUS_PROC* glCheckFramebufferStatus;
-  PFNGLFRAMEBUFFERTEXTURE1D_PROC* glFramebufferTexture1D;
-  PFNGLFRAMEBUFFERTEXTURE2D_PROC* glFramebufferTexture2D;
-  PFNGLFRAMEBUFFERTEXTURE3D_PROC* glFramebufferTexture3D;
-  PFNGLFRAMEBUFFERRENDERBUFFER_PROC* glFramebufferRenderbuffer;
-  PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIV_PROC* glGetFramebufferAttachmentParameteriv;
-  PFNGLGENERATEMIPMAP_PROC* glGenerateMipmap;
-  PFNGLBLITFRAMEBUFFER_PROC* glBlitFramebuffer;
-  PFNGLRENDERBUFFERSTORAGEMULTISAMPLE_PROC* glRenderbufferStorageMultisample;
-  PFNGLFRAMEBUFFERTEXTURELAYER_PROC* glFramebufferTextureLayer;
-  PFNGLMAPBUFFERRANGE_PROC* glMapBufferRange;
-  PFNGLFLUSHMAPPEDBUFFERRANGE_PROC* glFlushMappedBufferRange;
-  PFNGLBINDVERTEXARRAY_PROC* glBindVertexArray;
-  PFNGLDELETEVERTEXARRAYS_PROC* glDeleteVertexArrays;
-  PFNGLGENVERTEXARRAYS_PROC* glGenVertexArrays;
-  PFNGLISVERTEXARRAY_PROC* glIsVertexArray;
-    
-  /* GL_VERSION_3_1 */
-
-  PFNGLDRAWARRAYSINSTANCED_PROC* glDrawArraysInstanced;
-  PFNGLDRAWELEMENTSINSTANCED_PROC* glDrawElementsInstanced;
-  PFNGLTEXBUFFER_PROC* glTexBuffer;
-  PFNGLPRIMITIVERESTARTINDEX_PROC* glPrimitiveRestartIndex;
-  PFNGLCOPYBUFFERSUBDATA_PROC* glCopyBufferSubData;
-  PFNGLGETUNIFORMINDICES_PROC* glGetUniformIndices;
-  PFNGLGETACTIVEUNIFORMSIV_PROC* glGetActiveUniformsiv;
-  PFNGLGETACTIVEUNIFORMNAME_PROC* glGetActiveUniformName;
-  PFNGLGETUNIFORMBLOCKINDEX_PROC* glGetUniformBlockIndex;
-  PFNGLGETACTIVEUNIFORMBLOCKIV_PROC* glGetActiveUniformBlockiv;
-  PFNGLGETACTIVEUNIFORMBLOCKNAME_PROC* glGetActiveUniformBlockName;
-  PFNGLUNIFORMBLOCKBINDING_PROC* glUniformBlockBinding;
-    
-  /* GL_VERSION_3_2 */
-
-  PFNGLDRAWELEMENTSBASEVERTEX_PROC* glDrawElementsBaseVertex;
-  PFNGLDRAWRANGEELEMENTSBASEVERTEX_PROC* glDrawRangeElementsBaseVertex;
-  PFNGLDRAWELEMENTSINSTANCEDBASEVERTEX_PROC* glDrawElementsInstancedBaseVertex;
-  PFNGLMULTIDRAWELEMENTSBASEVERTEX_PROC* glMultiDrawElementsBaseVertex;
-  PFNGLPROVOKINGVERTEX_PROC* glProvokingVertex;
-  PFNGLFENCESYNC_PROC* glFenceSync;
-  PFNGLISSYNC_PROC* glIsSync;
-  PFNGLDELETESYNC_PROC* glDeleteSync;
-  PFNGLCLIENTWAITSYNC_PROC* glClientWaitSync;
-  PFNGLWAITSYNC_PROC* glWaitSync;
-  PFNGLGETINTEGER64V_PROC* glGetInteger64v;
-  PFNGLGETSYNCIV_PROC* glGetSynciv;
-  PFNGLGETINTEGER64I_V_PROC* glGetInteger64i_v;
-  PFNGLGETBUFFERPARAMETERI64V_PROC* glGetBufferParameteri64v;
-  PFNGLFRAMEBUFFERTEXTURE_PROC* glFramebufferTexture;
-  PFNGLTEXIMAGE2DMULTISAMPLE_PROC* glTexImage2DMultisample;
-  PFNGLTEXIMAGE3DMULTISAMPLE_PROC* glTexImage3DMultisample;
-  PFNGLGETMULTISAMPLEFV_PROC* glGetMultisamplefv;
-  PFNGLSAMPLEMASKI_PROC* glSampleMaski;
-    
-  /* GL_VERSION_3_3 */
-
-  PFNGLBINDFRAGDATALOCATIONINDEXED_PROC* glBindFragDataLocationIndexed;
-  PFNGLGETFRAGDATAINDEX_PROC* glGetFragDataIndex;
-  PFNGLGENSAMPLERS_PROC* glGenSamplers;
-  PFNGLDELETESAMPLERS_PROC* glDeleteSamplers;
-  PFNGLISSAMPLER_PROC* glIsSampler;
-  PFNGLBINDSAMPLER_PROC* glBindSampler;
-  PFNGLSAMPLERPARAMETERI_PROC* glSamplerParameteri;
-  PFNGLSAMPLERPARAMETERIV_PROC* glSamplerParameteriv;
-  PFNGLSAMPLERPARAMETERF_PROC* glSamplerParameterf;
-  PFNGLSAMPLERPARAMETERFV_PROC* glSamplerParameterfv;
-  PFNGLSAMPLERPARAMETERIIV_PROC* glSamplerParameterIiv;
-  PFNGLSAMPLERPARAMETERIUIV_PROC* glSamplerParameterIuiv;
-  PFNGLGETSAMPLERPARAMETERIV_PROC* glGetSamplerParameteriv;
-  PFNGLGETSAMPLERPARAMETERIIV_PROC* glGetSamplerParameterIiv;
-  PFNGLGETSAMPLERPARAMETERFV_PROC* glGetSamplerParameterfv;
-  PFNGLGETSAMPLERPARAMETERIUIV_PROC* glGetSamplerParameterIuiv;
-  PFNGLQUERYCOUNTER_PROC* glQueryCounter;
-  PFNGLGETQUERYOBJECTI64V_PROC* glGetQueryObjecti64v;
-  PFNGLGETQUERYOBJECTUI64V_PROC* glGetQueryObjectui64v;
-  PFNGLVERTEXATTRIBDIVISOR_PROC* glVertexAttribDivisor;
-  PFNGLVERTEXATTRIBP1UI_PROC* glVertexAttribP1ui;
-  PFNGLVERTEXATTRIBP1UIV_PROC* glVertexAttribP1uiv;
-  PFNGLVERTEXATTRIBP2UI_PROC* glVertexAttribP2ui;
-  PFNGLVERTEXATTRIBP2UIV_PROC* glVertexAttribP2uiv;
-  PFNGLVERTEXATTRIBP3UI_PROC* glVertexAttribP3ui;
-  PFNGLVERTEXATTRIBP3UIV_PROC* glVertexAttribP3uiv;
-  PFNGLVERTEXATTRIBP4UI_PROC* glVertexAttribP4ui;
-  PFNGLVERTEXATTRIBP4UIV_PROC* glVertexAttribP4uiv;
-};
-
-typedef struct OpenGLBindings OpenGLBindings;
-
-/* --------------------------- CATEGORY DEFINES ------------------------------ */
-
-#define GL_VERSION_1_0
-#define GL_VERSION_1_1
-#define GL_VERSION_1_2
-#define GL_VERSION_1_3
-#define GL_VERSION_1_4
-#define GL_VERSION_1_5
-#define GL_VERSION_2_0
-#define GL_VERSION_2_1
-#define GL_VERSION_3_0
-#define GL_VERSION_3_1
-#define GL_VERSION_3_2
-#define GL_VERSION_3_3
-
-/* ---------------------- Flags for optional extensions ---------------------- */
-
-
-
-struct GLFWwindow;
-typedef struct GLFWwindow GLFWwindow;
-
-int flextInit(GLFWwindow* window, OpenGLBindings *bindings);
-
-#define FLEXT_MAJOR_VERSION 3
-#define FLEXT_MINOR_VERSION 3
-#define FLEXT_CORE_PROFILE 1
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* _gl_h_ */
diff --git a/examples/protonect/src/cpu_depth_packet_processor.cpp b/examples/protonect/src/cpu_depth_packet_processor.cpp
index 9a89c70bd..6ac4624a8 100644
--- a/examples/protonect/src/cpu_depth_packet_processor.cpp
+++ b/examples/protonect/src/cpu_depth_packet_processor.cpp
@@ -28,8 +28,6 @@
 #include <libfreenect2/resource.h>
 #include <libfreenect2/protocol/response.h>
 
-#ifdef LIBFREENECT2_OPENCV_FOUND
-#endif
 #include <iostream>
 #include <fstream>
 
diff --git a/examples/protonect/src/turbo_jpeg_rgb_packet_processor.cpp b/examples/protonect/src/turbo_jpeg_rgb_packet_processor.cpp
index dadf5ae54..137f0dc80 100644
--- a/examples/protonect/src/turbo_jpeg_rgb_packet_processor.cpp
+++ b/examples/protonect/src/turbo_jpeg_rgb_packet_processor.cpp
@@ -26,7 +26,7 @@
 
 #include <libfreenect2/rgb_packet_processor.h>
 #ifdef LIBFREENECT2_OPENCV_FOUND
-//#include <opencv2/opencv.hpp>
+    #include <opencv2/opencv.hpp>
 #endif
 #include <turbojpeg.h>
 #include <iostream>
diff --git a/examples/protonect/viewer.cpp b/examples/protonect/viewer.cpp
index 7a031f5e0..12ac04757 100644
--- a/examples/protonect/viewer.cpp
+++ b/examples/protonect/viewer.cpp
@@ -30,7 +30,7 @@ void Viewer::initialize()
 
     std::string vertexshadersrc = ""
         "#version 330\n"
-                                                \
+                                                
         "in vec2 Position;"
         "in vec2 TexCoord;"
                     
@@ -190,7 +190,7 @@ bool Viewer::render()
     return shouldStop || glfwWindowShouldClose(window);
 }
 
-void Viewer::AddFrame(std::string id, libfreenect2::Frame* frame)
+void Viewer::addFrame(std::string id, libfreenect2::Frame* frame)
 {
     frames[id] = frame;
 }
\ No newline at end of file
diff --git a/examples/protonect/viewer.h b/examples/protonect/viewer.h
index 5dcc22897..306ee6a36 100644
--- a/examples/protonect/viewer.h
+++ b/examples/protonect/viewer.h
@@ -8,7 +8,7 @@
 #include <string>
 #include <map>
 
-#include "flextGL.h"
+#include <../src/flextGL.h>
 #include <GLFW/glfw3.h>
 
 struct Vertex
@@ -280,8 +280,7 @@ class Viewer : WithOpenGLBindings {
     void initialize();
     virtual void onOpenGLBindingsChanged(OpenGLBindings *b);
     bool render();
-    void AddFrame(std::string id,libfreenect2::Frame* frame);
-    void testMethod(libfreenect2::Frame* frame);
+    void addFrame(std::string id,libfreenect2::Frame* frame);
     void key_callback(GLFWwindow* window, int key, int scancode, int action, int mods);
     static void key_callbackstatic(GLFWwindow* window, int key, int scancode, int action, int mods);
 };

From bdebe6495f5d4b35bf13d71533907e67915f6da4 Mon Sep 17 00:00:00 2001
From: larshg <larshg@gmail.com>
Date: Wed, 17 Jun 2015 18:01:25 +0200
Subject: [PATCH 8/8] Unnecessary.

---
 examples/protonect/viewer.cpp | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/examples/protonect/viewer.cpp b/examples/protonect/viewer.cpp
index 12ac04757..bd1958053 100644
--- a/examples/protonect/viewer.cpp
+++ b/examples/protonect/viewer.cpp
@@ -16,9 +16,6 @@ Viewer::Viewer() : shader_folder("src/shader/")
     //glfwWindowHint(GLFW_VISIBLE, debug ? GL_TRUE : GL_FALSE);
 
     window = glfwCreateWindow(1280, 800, "Viewer", 0, NULL);
-
-    triangle_vbo = NULL;
-    triangle_vao = NULL;
 }
 
 void Viewer::initialize()