opengl3 0.0.1.pre1

data/examples/ogl-4_0-triangle_tessellation.rb

@@ -0,0 +1,262 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'opengl'
+require 'glut'
+require_relative 'math3d'
+
+class TestApp
+  include GLUT
+  include OpenGL::Constants
+  
+  def initialize
+    caps = GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE
+    if FFI::Platform.mac?
+      caps |= GLUT_4_0_CORE_PROFILE
+    else
+      glutInitContextVersion(4, 0)
+      glutInitContextProfile(:core)
+    end
+    glutInitDisplayMode(caps)
+    glutInitWindowPosition(300, 200)
+    glutInitWindowSize(512, 512)
+    glutCreateWindow('tessellation')
+    
+    glutDisplayFunc(@draw_method ||= method(:draw))
+    glutReshapeFunc(@resize_method ||= method(:resize))
+    glutMouseFunc(@mouse_press_method ||= method(:mouse_press))
+    glutMotionFunc(@mouse_track_method ||= method(:mouse_track))
+  end
+  
+  def start
+    self.extend OpenGL::GL.entrypoints
+    puts glGetString(GL_VERSION)
+    
+    @triangle = begin
+      vertex_buffer = glGenBuffers(1)[0]
+      glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer)
+      glBufferData(GL_ARRAY_BUFFER, 4*2*3, nil, GL_STATIC_DRAW)
+      glMapBuffer(GL_ARRAY_BUFFER, GL_WRITE_ONLY) do |ptr|
+        r = 1.0
+        s = Math.sqrt(0.75) * r
+        ptr.put_array_of_GLfloat(0, [0.0, r])
+        ptr.put_array_of_GLfloat(8, [s, -0.5*r])
+        ptr.put_array_of_GLfloat(16, [-s, -0.5*r])
+      end
+      
+      array = glGenVertexArrays(1)[0]
+      glBindVertexArray(array)
+      glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer)
+      glEnableVertexAttribArray(0)
+      glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, nil)
+      
+      glBindVertexArray(0)
+      glBindBuffer(GL_ARRAY_BUFFER, 0)
+      glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0)
+      
+      array
+    end
+    
+    @program = begin
+      vertex_shader = glCreateShader(:vertex)
+      glShaderSource(vertex_shader, VS_CODE)
+      glCompileShader(vertex_shader)
+      unless glIsShaderCompiled?(vertex_shader)
+        msg = glGetShaderInfoLog(vertex_shader)
+        raise RuntimeError, "vertex_shader:\n#{msg}"
+      end
+      
+      tess_control_shader = glCreateShader(:tess_control)
+      glShaderSource(tess_control_shader, TC_CODE)
+      glCompileShader(tess_control_shader)
+      unless glIsShaderCompiled?(tess_control_shader)
+        msg = glGetShaderInfoLog(tess_control_shader)
+        raise RuntimeError, "tess_control_shader:\n#{msg}"
+      end
+      
+      tess_eval_shader = glCreateShader(:tess_eval)
+      glShaderSource(tess_eval_shader, TE_CODE)
+      glCompileShader(tess_eval_shader)
+      unless glIsShaderCompiled?(tess_eval_shader)
+        msg = glGetShaderInfoLog(tess_eval_shader)
+        raise RuntimeError, "tess_eval_shader:\n#{msg}"
+      end
+      
+      geometry_shader = glCreateShader(:geometry)
+      glShaderSource(geometry_shader, GS_CODE)
+      glCompileShader(geometry_shader)
+      unless glIsShaderCompiled?(geometry_shader)
+        msg = glGetShaderInfoLog(geometry_shader)
+        raise RuntimeError, "geometry_shader:\n#{msg}"
+      end
+      
+      fragment_shader = glCreateShader(:fragment)
+      glShaderSource(fragment_shader, FS_CODE)
+      glCompileShader(fragment_shader)
+      unless glIsShaderCompiled?(fragment_shader)
+        msg = glGetShaderInfoLog(fragment_shader)
+        raise RuntimeError, "fragment_shader:\n#{msg}"
+      end
+      
+      program = glCreateProgram()
+      glAttachShader(program, vertex_shader)
+      glAttachShader(program, tess_control_shader)
+      glAttachShader(program, tess_eval_shader)
+      glAttachShader(program, geometry_shader)
+      glAttachShader(program, fragment_shader)
+      glLinkProgram(program)
+      unless glIsProgramLinked?(program)
+        msg = glGetProgramInfoLog(program)
+        raise RuntimeError, "program:\n#{msg}"
+      end
+      glDeleteShader(vertex_shader)
+      glDeleteShader(tess_control_shader)
+      glDeleteShader(tess_eval_shader)
+      glDeleteShader(geometry_shader)
+      glDeleteShader(fragment_shader)
+      program
+    end
+    
+    @view = Matrix.translate(0, 0, -5)
+    @world = Matrix.scale(5, 5, 5)
+    
+    glutMainLoop()
+  end
+  
+  def draw
+    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
+    
+    glPolygonMode(GL_FRONT_AND_BACK, GL_LINE)
+    
+    glUseProgram(@program)
+    if (loc = glGetUniformLocation(@program, "u_Projection")) != -1
+      OpenGL::Type.GLfloat(16) do |ptr|
+        ptr.write_array_of_GLfloat(@projection.to_a.flatten)
+        glUniformMatrix4fv(loc, 1, GL_TRUE, ptr)
+      end
+    end
+    if (loc = glGetUniformLocation(@program, "u_ModelView")) != -1
+      OpenGL::Type.GLfloat(16) do |ptr|
+        modelview = @view * @world
+        ptr.write_array_of_GLfloat(modelview.to_a.flatten)
+        glUniformMatrix4fv(loc, 1, GL_TRUE, ptr)
+      end
+    end
+    glPatchParameteri(GL_PATCH_VERTICES, 3)
+    
+    glBindVertexArray(@triangle)
+    glDrawArrays(GL_PATCHES, 0, 3)
+    
+    glutSwapBuffers()
+  end
+  
+  def resize(width, height)
+    glViewport(0, 0, width, height)
+    
+    fovy = 45.0 / 180.0 * Math::PI
+    aspect = Float(width) / Float(height)
+    z_near, z_far = 1.0, 100.0
+    @projection = Matrix.perspective(fovy, aspect, z_near, z_far)
+  end
+  
+  def mouse_press(button, button_state, x, y)
+    if button == :LEFT
+      case button_state
+      when :DOWN
+        @mouse_tracking_pos = [x, y]
+      when :UP
+        remove_instance_variable(:@mouse_tracking_pos)
+      end
+    end
+  end
+  
+  def mouse_track(x, y)
+    if defined? @mouse_tracking_pos
+      delta_x = (x - @mouse_tracking_pos[0]) * 0.01
+      delta_y = (y - @mouse_tracking_pos[1]) * 0.01
+      
+      #@world = Matrix.rotate_x(delta_y) * Matrix.rotate_y(delta_x) * @world
+      @world = Matrix.translate(0,0,delta_y) * @world
+      
+      @mouse_tracking_pos = [x, y]
+      glutPostRedisplay()
+    end
+  end
+  
+  VS_CODE =<<-GLSL
+#version 400 core
+uniform mat4 u_Projection;
+uniform mat4 u_ModelView;
+layout(location = 0) in vec4 in_Position;
+//out vec3 vs_Position;
+//out vec2 vs_TexCoord;
+void main()
+{
+  gl_Position = u_Projection * u_ModelView * in_Position;
+  //vs_Position = in_Position.xyz;
+  //vs_TexCoord = in_Position.xy + 0.5;
+}
+  GLSL
+  
+  TC_CODE =<<-GLSL
+#version 400 core
+layout(vertices=3) out;
+#define ID gl_InvocationID
+void main()
+{
+  gl_out[ID].gl_Position = gl_in[ID].gl_Position;
+  if (ID == 0) {
+    float sum = 0.0;
+    for (int i = 0; i < 3; ++i) {
+      vec4 v = gl_in[i].gl_Position;
+      sum += v.z / v.w;
+    }
+    sum /= 3;
+    float k = 40 * clamp(1.0 - sum, 0.0, 2.0);
+    gl_TessLevelInner[0] = k;
+    gl_TessLevelOuter[0] = k;
+    gl_TessLevelOuter[1] = k;
+    gl_TessLevelOuter[2] = k;
+  }
+}
+  GLSL
+  
+  TE_CODE =<<-GLSL
+#version 400 core
+layout(triangles, fractional_even_spacing, ccw) in;
+void main()
+{
+  vec4 p0 = gl_TessCoord.x * gl_in[0].gl_Position;
+  vec4 p1 = gl_TessCoord.y * gl_in[1].gl_Position;
+  vec4 p2 = gl_TessCoord.z * gl_in[2].gl_Position;
+  gl_Position = p0 + p1 + p2;
+}
+  GLSL
+  
+  GS_CODE =<<-GLSL
+#version 400 core
+layout(triangles) in;
+layout(triangle_strip, max_vertices=3) out;
+void main()
+{
+  for (int i = 0; i < 3; ++i) {
+    gl_Position = gl_in[i].gl_Position;
+    EmitVertex();
+  }
+  EndPrimitive();
+}
+  GLSL
+  
+  FS_CODE =<<-GLSL
+#version 400 core
+//in vec2 vs_TexCoord;
+layout(location = 0) out vec4 fs_FragColor;
+void main()
+{
+  //fs_FragColor = vec4(vs_TexCoord, 0.0, 1.0);
+  fs_FragColor = vec4(1.0);
+}
+  GLSL
+  
+end
+
+TestApp.new.start

data/lib/glut.rb

@@ -0,0 +1,125 @@
+require 'ffi'
+
+module GLUT
+  extend FFI::Library
+  
+  case FFI::Platform::OS
+  when "darwin"
+    ffi_lib "/System/Library/Frameworks/GLUT.framework/GLUT"
+  when "linux"
+    ffi_lib "libglut.so.3"
+  else raise RuntimeError, "GLUT: Unsupported OS"
+  end
+  
+  # keyboard / mouse callback constants
+  typedef :uchar, :key
+  enum :special_key, [:F1, 0x1] + (2..12).map{|n| :"F#{n}" } + 
+                     [:LEFT, 0x64, :UP, :RIGHT, :DOWN, :PAGE_UP, :PAGE_DOWN, 
+                      :HOME, :END, :INSERT]
+  
+  enum :mouse_button, [:LEFT, 0x0, :MIDDLE, :RIGHT]
+  enum :mouse_button_state, [:DOWN, 0x0, :UP]
+  enum :mouse_entry_state, [:LEFT, 0x0, :ENTERED]
+  
+  # display mode bit masks
+  GLUT_RGB              = 0x0000
+  GLUT_RGBA             = 0x0000
+  GLUT_INDEX            = 0x0001
+  GLUT_SINGLE           = 0x0000
+  GLUT_DOUBLE           = 0x0002
+  GLUT_ACCUM            = 0x0004
+  GLUT_ALPHA            = 0x0008
+  GLUT_DEPTH            = 0x0010
+  GLUT_STENCIL          = 0x0020
+  GLUT_MULTISAMPLE      = 0x0080
+  GLUT_STEREO           = 0x0100
+  GLUT_3_2_CORE_PROFILE = 0x0800 # only for OS X 10.7 and later
+  
+  # Init GLUT
+  attach_function :glutInit, [:pointer, :pointer], :void
+  
+  # Enter MainLoop (never return)
+  attach_function :glutMainLoop, [], :void
+  
+  # Display Buffer
+  attach_function :glutSwapBuffers, [], :void
+  
+  # Window
+  typedef :int, :window
+  attach_function :glutInitDisplayMode, [:uint], :void
+  attach_function :glutInitDisplayString, [:string], :void
+  attach_function :glutInitWindowPosition, [:int, :int], :void
+  attach_function :glutInitWindowSize, [:int, :int], :void
+  attach_function :glutCreateWindow, [:string], :window
+  attach_function :glutDestroyWindow, [:window], :void
+  attach_function :glutSetWindow, [:window], :void
+  attach_function :glutGetWindow, [], :window
+  attach_function :glutSetWindowTitle, [:string], :void
+  attach_function :glutReshapeWindow, [ :int, :int ], :void
+  attach_function :glutPositionWindow, [ :int, :int ], :void
+  attach_function :glutShowWindow, [], :void
+  attach_function :glutHideWindow, [], :void
+  
+  # Post Redisplay Event
+  attach_function :glutPostWindowRedisplay, [:window], :void
+  attach_function :glutPostRedisplay, [], :void
+  
+  # Window Callbacks
+  callback :display_proc, [], :void
+  callback :mouse_proc, [:mouse_button, :mouse_button_state, :int, :int], :void
+  callback :motion_proc, [:int, :int], :void
+  callback :resize_proc, [:int, :int], :void
+  callback :keyboard_proc, [:key, :int, :int], :void
+  callback :special_proc, [:special_key, :int, :int], :void
+  callback :timer_proc, [:int], :void
+  callback :idle_proc, [], :void
+  callback :entry_proc, [:mouse_entry_state], :void
+  attach_function :glutDisplayFunc, [:display_proc], :void
+  attach_function :glutMouseFunc, [:mouse_proc], :void
+  attach_function :glutMotionFunc, [:motion_proc], :void
+  attach_function :glutPassiveMotionFunc, [:motion_proc], :void
+  attach_function :glutReshapeFunc, [:resize_proc], :void
+  attach_function :glutKeyboardFunc, [:keyboard_proc], :void
+  attach_function :glutSpecialFunc, [:special_proc], :void
+  attach_function :glutTimerFunc, [:uint, :timer_proc, :int], :void
+  attach_function :glutIdleFunc, [:idle_proc], :void
+  attach_function :glutEntryFunc, [:entry_proc], :void
+  attach_function :glutKeyboardUpFunc, [:keyboard_proc], :void
+  attach_function :glutSpecialUpFunc, [:special_proc], :void
+  
+  # glutGet parameter names
+  enum :glut_pname, [:WINDOW_X, 0x64, :WINDOW_Y, :WINDOW_WIDTH, :WINDOW_HEIGHT, 
+                     :ELAPSED_TIME, 0x02BC]
+  
+  # Misc
+  attach_function :glutGet, [:glut_pname], :int
+  attach_function :raw_glutGetModifiers, :glutGetModifiers, [], :int
+  
+  def glutGetModifiers
+    bitfield = raw_glutGetModifiers
+    result = []
+    result << :SHIFT if bitfield & 0x1 != 0
+    result << :CTRL if bitfield & 0x2 != 0
+    result << :ALT if bitfield & 0x4 != 0
+    return result
+  end
+  module_function :glutGetModifiers
+  
+  # Init Context
+  unless FFI::Platform.mac?
+    enum :context_profile, [:core, 0x1, :compatibility, 0x2]
+    attach_function :glutInitContextVersion, [:int, :int], :void
+    attach_function :glutInitContextProfile, [:context_profile], :void
+  end
+  
+  # Module Initializer
+  def self.init
+    argc = FFI::MemoryPointer.new(:int, 1).write_int(0)
+    argv = FFI::MemoryPointer.new(:pointer, 1)
+    argv.write_pointer(FFI::MemoryPointer::NULL)
+    glutInit(argc, argv)
+  end
+  
+end
+
+GLUT.init

data/lib/opengl.rb

@@ -0,0 +1,7 @@
+require_relative "opengl/version"
+require_relative "opengl/constants"
+require_relative "opengl/platform"
+require_relative "opengl/gl"
+
+module OpenGL
+end

data/lib/opengl/constants.rb

@@ -0,0 +1,15 @@
+require 'yaml'
+
+module OpenGL::Constants
+  
+  Dir[File.expand_path("../constants/**/GL_*.yml", __FILE__)].each do |path|
+    obj = YAML.load(File.read(path))
+    obj.each do |name, value|
+      unless value.is_a? Integer
+        raise RuntimeError, "#{name} = #{value} must be an integer"
+      end
+      self.const_set(name, value)
+    end
+  end
+  
+end

data/lib/opengl/constants/core/2_x/GL_VERSION_1_1.yml

@@ -0,0 +1,230 @@
+# AttribMask
+GL_DEPTH_BUFFER_BIT:               0x00000100
+GL_STENCIL_BUFFER_BIT:             0x00000400
+GL_COLOR_BUFFER_BIT:               0x00004000
+# Boolean
+GL_FALSE:                          0
+GL_TRUE:                           1
+# BeginMode
+GL_POINTS:                         0x0000
+GL_LINES:                          0x0001
+GL_LINE_LOOP:                      0x0002
+GL_LINE_STRIP:                     0x0003
+GL_TRIANGLES:                      0x0004
+GL_TRIANGLE_STRIP:                 0x0005
+GL_TRIANGLE_FAN:                   0x0006
+GL_QUADS:                          0x0007
+# AlphaFunction
+GL_NEVER:                          0x0200
+GL_LESS:                           0x0201
+GL_EQUAL:                          0x0202
+GL_LEQUAL:                         0x0203
+GL_GREATER:                        0x0204
+GL_NOTEQUAL:                       0x0205
+GL_GEQUAL:                         0x0206
+GL_ALWAYS:                         0x0207
+# BlendingFactorDest
+GL_ZERO:                           0
+GL_ONE:                            1
+GL_SRC_COLOR:                      0x0300
+GL_ONE_MINUS_SRC_COLOR:            0x0301
+GL_SRC_ALPHA:                      0x0302
+GL_ONE_MINUS_SRC_ALPHA:            0x0303
+GL_DST_ALPHA:                      0x0304
+GL_ONE_MINUS_DST_ALPHA:            0x0305
+# BlendingFactorSrc
+GL_DST_COLOR:                      0x0306
+GL_ONE_MINUS_DST_COLOR:            0x0307
+GL_SRC_ALPHA_SATURATE:             0x0308
+# DrawBufferMode
+GL_NONE:                           0
+GL_FRONT_LEFT:                     0x0400
+GL_FRONT_RIGHT:                    0x0401
+GL_BACK_LEFT:                      0x0402
+GL_BACK_RIGHT:                     0x0403
+GL_FRONT:                          0x0404
+GL_BACK:                           0x0405
+GL_LEFT:                           0x0406
+GL_RIGHT:                          0x0407
+GL_FRONT_AND_BACK:                 0x0408
+# ErrorCode
+GL_NO_ERROR:                       0
+GL_INVALID_ENUM:                   0x0500
+GL_INVALID_VALUE:                  0x0501
+GL_INVALID_OPERATION:              0x0502
+GL_OUT_OF_MEMORY:                  0x0505
+# FrontFaceDirection
+GL_CW:                             0x0900
+GL_CCW:                            0x0901
+# GetPName
+GL_POINT_SIZE:                     0x0B11
+GL_POINT_SIZE_RANGE:               0x0B12
+GL_POINT_SIZE_GRANULARITY:         0x0B13
+GL_LINE_SMOOTH:                    0x0B20
+GL_LINE_WIDTH:                     0x0B21
+GL_LINE_WIDTH_RANGE:               0x0B22
+GL_LINE_WIDTH_GRANULARITY:         0x0B23
+GL_POLYGON_MODE:                   0x0B40
+GL_POLYGON_SMOOTH:                 0x0B41
+GL_CULL_FACE:                      0x0B44
+GL_CULL_FACE_MODE:                 0x0B45
+GL_FRONT_FACE:                     0x0B46
+GL_DEPTH_RANGE:                    0x0B70
+GL_DEPTH_TEST:                     0x0B71
+GL_DEPTH_WRITEMASK:                0x0B72
+GL_DEPTH_CLEAR_VALUE:              0x0B73
+GL_DEPTH_FUNC:                     0x0B74
+GL_STENCIL_TEST:                   0x0B90
+GL_STENCIL_CLEAR_VALUE:            0x0B91
+GL_STENCIL_FUNC:                   0x0B92
+GL_STENCIL_VALUE_MASK:             0x0B93
+GL_STENCIL_FAIL:                   0x0B94
+GL_STENCIL_PASS_DEPTH_FAIL:        0x0B95
+GL_STENCIL_PASS_DEPTH_PASS:        0x0B96
+GL_STENCIL_REF:                    0x0B97
+GL_STENCIL_WRITEMASK:              0x0B98
+GL_VIEWPORT:                       0x0BA2
+GL_DITHER:                         0x0BD0
+GL_BLEND_DST:                      0x0BE0
+GL_BLEND_SRC:                      0x0BE1
+GL_BLEND:                          0x0BE2
+GL_LOGIC_OP_MODE:                  0x0BF0
+GL_COLOR_LOGIC_OP:                 0x0BF2
+GL_DRAW_BUFFER:                    0x0C01
+GL_READ_BUFFER:                    0x0C02
+GL_SCISSOR_BOX:                    0x0C10
+GL_SCISSOR_TEST:                   0x0C11
+GL_COLOR_CLEAR_VALUE:              0x0C22
+GL_COLOR_WRITEMASK:                0x0C23
+GL_DOUBLEBUFFER:                   0x0C32
+GL_STEREO:                         0x0C33
+GL_LINE_SMOOTH_HINT:               0x0C52
+GL_POLYGON_SMOOTH_HINT:            0x0C53
+GL_UNPACK_SWAP_BYTES:              0x0CF0
+GL_UNPACK_LSB_FIRST:               0x0CF1
+GL_UNPACK_ROW_LENGTH:              0x0CF2
+GL_UNPACK_SKIP_ROWS:               0x0CF3
+GL_UNPACK_SKIP_PIXELS:             0x0CF4
+GL_UNPACK_ALIGNMENT:               0x0CF5
+GL_PACK_SWAP_BYTES:                0x0D00
+GL_PACK_LSB_FIRST:                 0x0D01
+GL_PACK_ROW_LENGTH:                0x0D02
+GL_PACK_SKIP_ROWS:                 0x0D03
+GL_PACK_SKIP_PIXELS:               0x0D04
+GL_PACK_ALIGNMENT:                 0x0D05
+GL_MAX_TEXTURE_SIZE:               0x0D33
+GL_MAX_VIEWPORT_DIMS:              0x0D3A
+GL_SUBPIXEL_BITS:                  0x0D50
+GL_TEXTURE_1D:                     0x0DE0
+GL_TEXTURE_2D:                     0x0DE1
+GL_POLYGON_OFFSET_UNITS:           0x2A00
+GL_POLYGON_OFFSET_POINT:           0x2A01
+GL_POLYGON_OFFSET_LINE:            0x2A02
+GL_POLYGON_OFFSET_FILL:            0x8037
+GL_POLYGON_OFFSET_FACTOR:          0x8038
+GL_TEXTURE_BINDING_1D:             0x8068
+GL_TEXTURE_BINDING_2D:             0x8069
+# GetTextureParameter
+GL_TEXTURE_WIDTH:                  0x1000
+GL_TEXTURE_HEIGHT:                 0x1001
+GL_TEXTURE_INTERNAL_FORMAT:        0x1003
+GL_TEXTURE_BORDER_COLOR:           0x1004
+GL_TEXTURE_RED_SIZE:               0x805C
+GL_TEXTURE_GREEN_SIZE:             0x805D
+GL_TEXTURE_BLUE_SIZE:              0x805E
+GL_TEXTURE_ALPHA_SIZE:             0x805F
+# HintMode
+GL_DONT_CARE:                      0x1100
+GL_FASTEST:                        0x1101
+GL_NICEST:                         0x1102
+# DataType
+GL_BYTE:                           0x1400
+GL_UNSIGNED_BYTE:                  0x1401
+GL_SHORT:                          0x1402
+GL_UNSIGNED_SHORT:                 0x1403
+GL_INT:                            0x1404
+GL_UNSIGNED_INT:                   0x1405
+GL_FLOAT:                          0x1406
+GL_DOUBLE:                         0x140A
+# ErrorCode
+GL_STACK_OVERFLOW:                 0x0503
+GL_STACK_UNDERFLOW:                0x0504
+# LogicOp
+GL_CLEAR:                          0x1500
+GL_AND:                            0x1501
+GL_AND_REVERSE:                    0x1502
+GL_COPY:                           0x1503
+GL_AND_INVERTED:                   0x1504
+GL_NOOP:                           0x1505
+GL_XOR:                            0x1506
+GL_OR:                             0x1507
+GL_NOR:                            0x1508
+GL_EQUIV:                          0x1509
+GL_INVERT:                         0x150A
+GL_OR_REVERSE:                     0x150B
+GL_COPY_INVERTED:                  0x150C
+GL_OR_INVERTED:                    0x150D
+GL_NAND:                           0x150E
+GL_SET:                            0x150F
+# MatrixMode (for gl3.h, FBO attachment type)
+GL_TEXTURE:                        0x1702
+# PixelCopyType
+GL_COLOR:                          0x1800
+GL_DEPTH:                          0x1801
+GL_STENCIL:                        0x1802
+# PixelFormat
+GL_STENCIL_INDEX:                  0x1901
+GL_DEPTH_COMPONENT:                0x1902
+GL_RED:                            0x1903
+GL_GREEN:                          0x1904
+GL_BLUE:                           0x1905
+GL_ALPHA:                          0x1906
+GL_RGB:                            0x1907
+GL_RGBA:                           0x1908
+# PolygonMode
+GL_POINT:                          0x1B00
+GL_LINE:                           0x1B01
+GL_FILL:                           0x1B02
+# StencilOp
+GL_KEEP:                           0x1E00
+GL_REPLACE:                        0x1E01
+GL_INCR:                           0x1E02
+GL_DECR:                           0x1E03
+# StringName
+GL_VENDOR:                         0x1F00
+GL_RENDERER:                       0x1F01
+GL_VERSION:                        0x1F02
+GL_EXTENSIONS:                     0x1F03
+# TextureMagFilter
+GL_NEAREST:                        0x2600
+GL_LINEAR:                         0x2601
+# TextureMinFilter
+GL_NEAREST_MIPMAP_NEAREST:         0x2700
+GL_LINEAR_MIPMAP_NEAREST:          0x2701
+GL_NEAREST_MIPMAP_LINEAR:          0x2702
+GL_LINEAR_MIPMAP_LINEAR:           0x2703
+# TextureParameterName
+GL_TEXTURE_MAG_FILTER:             0x2800
+GL_TEXTURE_MIN_FILTER:             0x2801
+GL_TEXTURE_WRAP_S:                 0x2802
+GL_TEXTURE_WRAP_T:                 0x2803
+# TextureTarget
+GL_PROXY_TEXTURE_1D:               0x8063
+GL_PROXY_TEXTURE_2D:               0x8064
+# TextureWrapMode
+GL_REPEAT:                         0x2901
+# PixelInternalFormat
+GL_R3_G3_B2:                       0x2A10
+GL_RGB4:                           0x804F
+GL_RGB5:                           0x8050
+GL_RGB8:                           0x8051
+GL_RGB10:                          0x8052
+GL_RGB12:                          0x8053
+GL_RGB16:                          0x8054
+GL_RGBA2:                          0x8055
+GL_RGBA4:                          0x8056
+GL_RGB5_A1:                        0x8057
+GL_RGBA8:                          0x8058
+GL_RGB10_A2:                       0x8059
+GL_RGBA12:                         0x805A
+GL_RGBA16:                         0x805B