roglew 0.1.0

data/lib/roglew/extensions/GL_VERSION_1_3.rb

@@ -0,0 +1,154 @@
+module Roglew
+  module GL
+    ACTIVE_TEXTURE                 ||= 0x84E0
+    ADD_SIGNED                     ||= 0x8574
+    CLAMP_TO_BORDER                ||= 0x812D
+    CLIENT_ACTIVE_TEXTURE          ||= 0x84E1
+    COMBINE                        ||= 0x8570
+    COMBINE_ALPHA                  ||= 0x8572
+    COMBINE_RGB                    ||= 0x8571
+    COMPRESSED_ALPHA               ||= 0x84E9
+    COMPRESSED_INTENSITY           ||= 0x84EC
+    COMPRESSED_LUMINANCE           ||= 0x84EA
+    COMPRESSED_LUMINANCE_ALPHA     ||= 0x84EB
+    COMPRESSED_RGB                 ||= 0x84ED
+    COMPRESSED_RGBA                ||= 0x84EE
+    COMPRESSED_TEXTURE_FORMATS     ||= 0x86A3
+    CONSTANT                       ||= 0x8576
+    DOT3_RGB                       ||= 0x86AE
+    DOT3_RGBA                      ||= 0x86AF
+    INTERPOLATE                    ||= 0x8575
+    MAX_CUBE_MAP_TEXTURE_SIZE      ||= 0x851C
+    MAX_TEXTURE_UNITS              ||= 0x84E2
+    MULTISAMPLE                    ||= 0x809D
+    MULTISAMPLE_BIT                ||= 0x20000000
+    NORMAL_MAP                     ||= 0x8511
+    NUM_COMPRESSED_TEXTURE_FORMATS ||= 0x86A2
+    OPERAND0_ALPHA                 ||= 0x8598
+    OPERAND0_RGB                   ||= 0x8590
+    OPERAND1_ALPHA                 ||= 0x8599
+    OPERAND1_RGB                   ||= 0x8591
+    OPERAND2_ALPHA                 ||= 0x859A
+    OPERAND2_RGB                   ||= 0x8592
+    PREVIOUS                       ||= 0x8578
+    PRIMARY_COLOR                  ||= 0x8577
+    PROXY_TEXTURE_CUBE_MAP         ||= 0x851B
+    REFLECTION_MAP                 ||= 0x8512
+    RGB_SCALE                      ||= 0x8573
+    SAMPLE_ALPHA_TO_COVERAGE       ||= 0x809E
+    SAMPLE_ALPHA_TO_ONE            ||= 0x809F
+    SAMPLE_BUFFERS                 ||= 0x80A8
+    SAMPLE_COVERAGE                ||= 0x80A0
+    SAMPLE_COVERAGE_INVERT         ||= 0x80AB
+    SAMPLE_COVERAGE_VALUE          ||= 0x80AA
+    SAMPLES                        ||= 0x80A9
+    SOURCE0_ALPHA                  ||= 0x8588
+    SOURCE0_RGB                    ||= 0x8580
+    SOURCE1_ALPHA                  ||= 0x8589
+    SOURCE1_RGB                    ||= 0x8581
+    SOURCE2_ALPHA                  ||= 0x858A
+    SOURCE2_RGB                    ||= 0x8582
+    SUBTRACT                       ||= 0x84E7
+    TEXTURE_BINDING_CUBE_MAP       ||= 0x8514
+    TEXTURE_COMPRESSED             ||= 0x86A1
+    TEXTURE_COMPRESSED_IMAGE_SIZE  ||= 0x86A0
+    TEXTURE_COMPRESSION_HINT       ||= 0x84EF
+    TEXTURE_CUBE_MAP               ||= 0x8513
+    TEXTURE_CUBE_MAP_NEGATIVE_X    ||= 0x8516
+    TEXTURE_CUBE_MAP_NEGATIVE_Y    ||= 0x8518
+    TEXTURE_CUBE_MAP_NEGATIVE_Z    ||= 0x851A
+    TEXTURE_CUBE_MAP_POSITIVE_X    ||= 0x8515
+    TEXTURE_CUBE_MAP_POSITIVE_Y    ||= 0x8517
+    TEXTURE_CUBE_MAP_POSITIVE_Z    ||= 0x8519
+    TEXTURE0                       ||= 0x84C0
+    TEXTURE1                       ||= 0x84C1
+    TEXTURE10                      ||= 0x84CA
+    TEXTURE11                      ||= 0x84CB
+    TEXTURE12                      ||= 0x84CC
+    TEXTURE13                      ||= 0x84CD
+    TEXTURE14                      ||= 0x84CE
+    TEXTURE15                      ||= 0x84CF
+    TEXTURE16                      ||= 0x84D0
+    TEXTURE17                      ||= 0x84D1
+    TEXTURE18                      ||= 0x84D2
+    TEXTURE19                      ||= 0x84D3
+    TEXTURE2                       ||= 0x84C2
+    TEXTURE20                      ||= 0x84D4
+    TEXTURE21                      ||= 0x84D5
+    TEXTURE22                      ||= 0x84D6
+    TEXTURE23                      ||= 0x84D7
+    TEXTURE24                      ||= 0x84D8
+    TEXTURE25                      ||= 0x84D9
+    TEXTURE26                      ||= 0x84DA
+    TEXTURE27                      ||= 0x84DB
+    TEXTURE28                      ||= 0x84DC
+    TEXTURE29                      ||= 0x84DD
+    TEXTURE3                       ||= 0x84C3
+    TEXTURE30                      ||= 0x84DE
+    TEXTURE31                      ||= 0x84DF
+    TEXTURE4                       ||= 0x84C4
+    TEXTURE5                       ||= 0x84C5
+    TEXTURE6                       ||= 0x84C6
+    TEXTURE7                       ||= 0x84C7
+    TEXTURE8                       ||= 0x84C8
+    TEXTURE9                       ||= 0x84C9
+    TRANSPOSE_COLOR_MATRIX         ||= 0x84E6
+    TRANSPOSE_MODELVIEW_MATRIX     ||= 0x84E3
+    TRANSPOSE_PROJECTION_MATRIX    ||= 0x84E4
+    TRANSPOSE_TEXTURE_MATRIX       ||= 0x84E5
+  end
+end
+
+module GL_VERSION_1_3
+  module RenderContext
+    include Roglew::GLExtension
+
+    functions [:glActiveTexture, [ :uint ], :void],
+              [:glClientActiveTexture,  [ :uint ], :void],
+              [:glCompressedTexImage1D, [ :uint, :int, :uint, :int, :int, :int, :pointer ], :void],
+              [:glCompressedTexImage2D, [ :uint, :int, :uint, :int, :int, :int, :int, :pointer ], :void],
+              [:glCompressedTexImage3D, [ :uint, :int, :uint, :int, :int, :int, :int, :int, :pointer ], :void],
+              [:glCompressedTexSubImage1D, [ :uint, :int, :int, :int, :uint, :int, :pointer ], :void],
+              [:glCompressedTexSubImage2D, [ :uint, :int, :int, :int, :int, :int, :uint, :int, :pointer ], :void],
+              [:glCompressedTexSubImage3D, [ :uint, :int, :int, :int, :int, :int, :int, :int, :uint, :int, :pointer ], :void],
+              [:glGetCompressedTexImage, [ :uint, :int, :pointer ], :void],
+              [:glLoadTransposeMatrixd,  [:double] * 16, :void],
+              [:glLoadTransposeMatrixf,  [:float] * 16, :void],
+              [:glMultiTexCoord1d,  [ :uint, :double ], :void],
+              [:glMultiTexCoord1dv, [ :uint, :pointer ], :void],
+              [:glMultiTexCoord1f,  [ :uint, :float ], :void],
+              [:glMultiTexCoord1fv, [ :uint, :pointer ], :void],
+              [:glMultiTexCoord1i,  [ :uint, :int ], :void],
+              [:glMultiTexCoord1iv, [ :uint, :pointer ], :void],
+              [:glMultiTexCoord1s,  [ :uint, :short ], :void],
+              [:glMultiTexCoord1sv, [ :uint, :pointer ], :void],
+              [:glMultiTexCoord2d,  [ :uint, :double, :double ], :void],
+              [:glMultiTexCoord2dv, [ :uint, :pointer ], :void],
+              [:glMultiTexCoord2f,  [ :uint, :float, :float ], :void],
+              [:glMultiTexCoord2fv, [ :uint, :pointer ], :void],
+              [:glMultiTexCoord2i,  [ :uint, :int, :int ], :void],
+              [:glMultiTexCoord2iv, [ :uint, :pointer ], :void],
+              [:glMultiTexCoord2s,  [ :uint, :short, :short ], :void],
+              [:glMultiTexCoord2sv, [ :uint, :pointer ], :void],
+              [:glMultiTexCoord3d,  [ :uint, :double, :double, :double ], :void],
+              [:glMultiTexCoord3dv, [ :uint, :pointer ], :void],
+              [:glMultiTexCoord3f,  [ :uint, :float, :float, :float ], :void],
+              [:glMultiTexCoord3fv, [ :uint, :pointer ], :void],
+              [:glMultiTexCoord3i,  [ :uint, :int, :int, :int ], :void],
+              [:glMultiTexCoord3iv, [ :uint, :pointer ], :void],
+              [:glMultiTexCoord3s,  [ :uint, :short, :short, :short ], :void],
+              [:glMultiTexCoord3sv, [ :uint, :pointer ], :void],
+              [:glMultiTexCoord4d,  [ :uint, :double, :double, :double, :double ], :void],
+              [:glMultiTexCoord4dv, [ :uint, :pointer ], :void],
+              [:glMultiTexCoord4f,  [ :uint, :float, :float, :float, :float ], :void],
+              [:glMultiTexCoord4fv, [ :uint, :pointer ], :void],
+              [:glMultiTexCoord4i,  [ :uint, :int, :int, :int, :int ], :void],
+              [:glMultiTexCoord4iv, [ :uint, :pointer ], :void],
+              [:glMultiTexCoord4s,  [ :uint, :short, :short, :short, :short ], :void],
+              [:glMultiTexCoord4sv, [ :uint, :pointer ], :void],
+              [:glMultTransposeMatrixd, [:double] * 16, :void],
+              [:glMultTransposeMatrixf, [:float] * 16, :void],
+              [:glSampleCoverage, [ :float, :uchar ], :void]
+
+  end
+end

data/lib/roglew/extensions/GL_VERSION_1_4.rb

@@ -0,0 +1,99 @@
+module Roglew
+  module GL
+    BLEND_DST_ALPHA               ||= 0x80CA
+    BLEND_DST_RGB                 ||= 0x80C8
+    BLEND_SRC_ALPHA               ||= 0x80CB
+    BLEND_SRC_RGB                 ||= 0x80C9
+    COLOR_SUM                     ||= 0x8458
+    COMPARE_R_TO_TEXTURE          ||= 0x884E
+    CURRENT_FOG_COORDINATE        ||= 0x8453
+    CURRENT_SECONDARY_COLOR       ||= 0x8459
+    DECR_WRAP                     ||= 0x8508
+    DEPTH_COMPONENT16             ||= 0x81A5
+    DEPTH_COMPONENT24             ||= 0x81A6
+    DEPTH_COMPONENT32             ||= 0x81A7
+    DEPTH_TEXTURE_MODE            ||= 0x884B
+    FOG_COORDINATE                ||= 0x8451
+    FOG_COORDINATE_ARRAY          ||= 0x8457
+    FOG_COORDINATE_ARRAY_POINTER  ||= 0x8456
+    FOG_COORDINATE_ARRAY_STRIDE   ||= 0x8455
+    FOG_COORDINATE_ARRAY_TYPE     ||= 0x8454
+    FOG_COORDINATE_SOURCE         ||= 0x8450
+    FRAGMENT_DEPTH                ||= 0x8452
+    GENERATE_MIPMAP               ||= 0x8191
+    GENERATE_MIPMAP_HINT          ||= 0x8192
+    INCR_WRAP                     ||= 0x8507
+    MAX_TEXTURE_LOD_BIAS          ||= 0x84FD
+    MIRRORED_REPEAT               ||= 0x8370
+    POINT_DISTANCE_ATTENUATION    ||= 0x8129
+    POINT_FADE_THRESHOLD_SIZE     ||= 0x8128
+    POINT_SIZE_MAX                ||= 0x8127
+    POINT_SIZE_MIN                ||= 0x8126
+    SECONDARY_COLOR_ARRAY         ||= 0x845E
+    SECONDARY_COLOR_ARRAY_POINTER ||= 0x845D
+    SECONDARY_COLOR_ARRAY_SIZE    ||= 0x845A
+    SECONDARY_COLOR_ARRAY_STRIDE  ||= 0x845C
+    SECONDARY_COLOR_ARRAY_TYPE    ||= 0x845B
+    TEXTURE_COMPARE_FUNC          ||= 0x884D
+    TEXTURE_COMPARE_MODE          ||= 0x884C
+    TEXTURE_DEPTH_SIZE            ||= 0x884A
+    TEXTURE_FILTER_CONTROL        ||= 0x8500
+    TEXTURE_LOD_BIAS              ||= 0x8501
+
+  end
+end
+
+module GL_VERSION_1_4
+  module RenderContext
+    include Roglew::GLExtension
+
+    functions [:glBlendColor, [ :float, :float, :float, :float ], :void],
+              [:glBlendEquation, [ :uint ], :void],
+              [:glBlendFuncSeparate, [ :uint, :uint, :uint, :uint ], :void],
+              [:glFogCoordd, [ :double ], :void],
+              [:glFogCoorddv, [ :pointer ], :void],
+              [:glFogCoordf, [ :float ], :void],
+              [:glFogCoordfv, [ :pointer ], :void],
+              [:glFogCoordPointer, [ :uint, :int, :pointer ], :void],
+              [:glMultiDrawArrays, [ :uint, :pointer, :pointer, :int ], :void],
+              [:glMultiDrawElements, [ :uint, :pointer, :uint, :pointer, :int ], :void],
+              [:glPointParameterf, [ :uint, :float ], :void],
+              [:glPointParameterfv, [ :uint, :pointer ], :void],
+              [:glPointParameteri, [ :uint, :int ], :void],
+              [:glPointParameteriv, [ :uint, :pointer ], :void],
+              [:glSecondaryColor3b, [ :char, :char, :char ], :void],
+              [:glSecondaryColor3bv, [ :pointer ], :void],
+              [:glSecondaryColor3d, [ :double, :double, :double ], :void],
+              [:glSecondaryColor3dv, [ :pointer ], :void],
+              [:glSecondaryColor3f, [ :float, :float, :float ], :void],
+              [:glSecondaryColor3fv, [ :pointer ], :void],
+              [:glSecondaryColor3i, [ :int, :int, :int ], :void],
+              [:glSecondaryColor3iv, [ :pointer ], :void],
+              [:glSecondaryColor3s, [ :short, :short, :short ], :void],
+              [:glSecondaryColor3sv, [ :pointer ], :void],
+              [:glSecondaryColor3ub, [ :uchar, :uchar, :uchar ], :void],
+              [:glSecondaryColor3ubv, [ :pointer ], :void],
+              [:glSecondaryColor3ui, [ :uint, :uint, :uint ], :void],
+              [:glSecondaryColor3uiv, [ :pointer ], :void],
+              [:glSecondaryColor3us, [ :ushort, :ushort, :ushort ], :void],
+              [:glSecondaryColor3usv, [ :pointer ], :void],
+              [:glSecondaryColorPointer, [ :int, :uint, :int, :pointer ], :void],
+              [:glWindowPos2d, [ :double, :double ], :void],
+              [:glWindowPos2dv, [ :pointer ], :void],
+              [:glWindowPos2f, [ :float, :float ], :void],
+              [:glWindowPos2fv, [ :pointer ], :void],
+              [:glWindowPos2i, [ :int, :int ], :void],
+              [:glWindowPos2iv, [ :pointer ], :void],
+              [:glWindowPos2s, [ :short, :short ], :void],
+              [:glWindowPos2sv, [ :pointer ], :void],
+              [:glWindowPos3d, [ :double, :double, :double ], :void],
+              [:glWindowPos3dv, [ :pointer ], :void],
+              [:glWindowPos3f, [ :float, :float, :float ], :void],
+              [:glWindowPos3fv, [ :pointer ], :void],
+              [:glWindowPos3i, [ :int, :int, :int ], :void],
+              [:glWindowPos3iv, [ :pointer ], :void],
+              [:glWindowPos3s, [ :short, :short, :short ], :void],
+              [:glWindowPos3sv, [ :pointer ], :void]
+
+  end
+end

data/lib/roglew/extensions/GL_VERSION_1_5.rb

@@ -0,0 +1,79 @@
+module Roglew
+  module GL
+    ARRAY_BUFFER                         ||= 0x8892
+    ARRAY_BUFFER_BINDING                 ||= 0x8894
+    BUFFER_ACCESS                        ||= 0x88BB
+    BUFFER_MAP_POINTER                   ||= 0x88BD
+    BUFFER_MAPPED                        ||= 0x88BC
+    BUFFER_SIZE                          ||= 0x8764
+    BUFFER_USAGE                         ||= 0x8765
+    COLOR_ARRAY_BUFFER_BINDING           ||= 0x8898
+    CURRENT_FOG_COORD                    ||= CURRENT_FOG_COORDINATE
+    CURRENT_QUERY                        ||= 0x8865
+    DYNAMIC_COPY                         ||= 0x88EA
+    DYNAMIC_DRAW                         ||= 0x88E8
+    DYNAMIC_READ                         ||= 0x88E9
+    EDGE_FLAG_ARRAY_BUFFER_BINDING       ||= 0x889B
+    ELEMENT_ARRAY_BUFFER                 ||= 0x8893
+    ELEMENT_ARRAY_BUFFER_BINDING         ||= 0x8895
+    FOG_COORD                            ||= FOG_COORDINATE
+    FOG_COORD_ARRAY                      ||= FOG_COORDINATE_ARRAY
+    FOG_COORD_ARRAY_BUFFER_BINDING       ||= 0x889D
+    FOG_COORD_ARRAY_POINTER              ||= FOG_COORDINATE_ARRAY_POINTER
+    FOG_COORD_ARRAY_STRIDE               ||= FOG_COORDINATE_ARRAY_STRIDE
+    FOG_COORD_ARRAY_TYPE                 ||= FOG_COORDINATE_ARRAY_TYPE
+    FOG_COORD_SRC                        ||= FOG_COORDINATE_SOURCE
+    FOG_COORDINATE_ARRAY_BUFFER_BINDING  ||= FOG_COORD_ARRAY_BUFFER_BINDING
+    INDEX_ARRAY_BUFFER_BINDING           ||= 0x8899
+    NORMAL_ARRAY_BUFFER_BINDING          ||= 0x8897
+    QUERY_COUNTER_BITS                   ||= 0x8864
+    QUERY_RESULT                         ||= 0x8866
+    QUERY_RESULT_AVAILABLE               ||= 0x8867
+    READ_ONLY                            ||= 0x88B8
+    READ_WRITE                           ||= 0x88BA
+    SECONDARY_COLOR_ARRAY_BUFFER_BINDING ||= 0x889C
+    SRC0_ALPHA                           ||= SOURCE0_ALPHA
+    SRC0_RGB                             ||= SOURCE0_RGB
+    SRC1_ALPHA                           ||= SOURCE1_ALPHA
+    SRC1_RGB                             ||= SOURCE1_RGB
+    SRC2_ALPHA                           ||= SOURCE2_ALPHA
+    SRC2_RGB                             ||= SOURCE2_RGB
+    STATIC_COPY                          ||= 0x88E6
+    STATIC_DRAW                          ||= 0x88E4
+    STATIC_READ                          ||= 0x88E5
+    STREAM_COPY                          ||= 0x88E2
+    STREAM_DRAW                          ||= 0x88E0
+    STREAM_READ                          ||= 0x88E1
+    TEXTURE_COORD_ARRAY_BUFFER_BINDING   ||= 0x889A
+    VERTEX_ARRAY_BUFFER_BINDING          ||= 0x8896
+    VERTEX_ATTRIB_ARRAY_BUFFER_BINDING   ||= 0x889F
+    WEIGHT_ARRAY_BUFFER_BINDING          ||= 0x889E
+    WRITE_ONLY                           ||= 0x88B9
+  end
+end
+
+module GL_VERSION_1_5
+  module RenderContext
+    include Roglew::GLExtension
+
+    functions [:glBeginQuery, [ :uint, :uint ], :void],
+              [:glBindBuffer, [ :uint, :uint ], :void],
+              [:glBufferData, [ :uint, :size_t, :pointer, :uint ], :void],
+              [:glBufferSubData, [ :uint, :size_t, :size_t, :pointer ], :void],
+              [:glDeleteBuffers, [ :int, :pointer ], :void],
+              [:glDeleteQueries, [ :int, :pointer ], :void],
+              [:glEndQuery, [ :uint ], :void],
+              [:glGenBuffers, [ :int, :pointer ], :void],
+              [:glGenQueries, [ :int, :pointer ], :void],
+              [:glGetBufferParameteriv, [ :uint, :uint, :pointer ], :void],
+              [:glGetBufferPointerv, [ :uint, :uint, :pointer ], :void],
+              [:glGetBufferSubData, [ :uint, :size_t, :size_t, :pointer ], :void],
+              [:glGetQueryiv, [ :uint, :uint, :pointer ], :void],
+              [:glGetQueryObjectiv, [ :uint, :uint, :pointer ], :void],
+              [:glGetQueryObjectuiv, [ :uint, :uint, :pointer ], :void],
+              [:glIsBuffer, [ :uint ], :uchar],
+              [:glIsQuery, [ :uint ], :uchar],
+              [:glMapBuffer, [ :uint, :uint ], :pointer],
+              [:glUnmapBuffer, [ :uint ], :uchar]
+  end
+end

data/lib/roglew/extensions/GL_VERSION_2_0/shader.rb

@@ -0,0 +1,52 @@
+module Roglew
+  class Shader
+    attr_reader :context, :id, :type
+
+    def initialize(context, type, src = nil)
+      @context = context.bind { |c| @id = c.glCreateShader(type) }
+      @type = type
+      raise OpenGLError, "couldn't create a shader of type #{type.to_s(16)}" if @id == 0
+
+      if src
+        src = File.read(src) if File.file? src
+        @context.bind { |_| compile(src) }
+      end
+
+      self.class.finalize(self, @id, @context)
+    end
+
+    def self.finalize(obj, id, ctx)
+      ObjectSpace.define_finalizer(obj, proc do
+        ctx.glDeleteShader(id)
+      end)
+    end
+
+    def compile(src)
+      @context.shader_sources(@id, src)
+      @context.glCompileShader(@id)
+      raise CompileError, info_log unless compile_status
+    end
+
+    def compile_status
+      @context.get_shader(@id, GL::COMPILE_STATUS)
+    end
+
+    def delete_status
+      @context.get_shader(@id, GL::DELETE_STATUS)
+    end
+
+    def info_log_length
+      @context.get_shader(@id, GL::INFO_LOG_LENGTH)
+    end
+
+    def info_log
+      @context.get_shader_info_log(@id)
+    end
+
+    def source_length
+      @context.get_shader(@id, GL::SHADER_SOURCE_LENGTH)
+    end
+
+    alias_method :compiled?, :compile_status
+  end
+end

data/lib/roglew/extensions/GL_VERSION_2_0/shader_program.rb

@@ -0,0 +1,33 @@
+module Roglew
+  class ShaderProgram
+    attr_reader :context,
+                :id,
+                :shaders
+
+    def initialize(context)
+      @context = context.bind { |c| @id = c.glCreateProgram() }
+    end
+
+    def attach(*shaders)
+      @shaders = shaders unless shaders.length == 0
+      @shaders.each { |shader| @context.glAttachShader(@id, shader.id) }
+      nil
+    end
+
+    def link_program
+      @context.glLinkProgram(@id)
+      raise CompileError, info_log unless link_status
+    end
+
+    def link_status
+      @context.get_program(@id, GL::LINK_STATUS)
+    end
+
+    def use_program
+      @context.glUseProgram(@id)
+    end
+
+    alias_method :link, :link_program
+    alias_method :use,  :use_program
+  end
+end

data/lib/roglew/extensions/GL_VERSION_2_0.rb

@@ -0,0 +1,251 @@
+module Roglew
+  module GL
+    ACTIVE_ATTRIBUTE_MAX_LENGTH      ||= 0x8B8A
+    ACTIVE_ATTRIBUTES                ||= 0x8B89
+    ACTIVE_UNIFORM_MAX_LENGTH        ||= 0x8B87
+    ACTIVE_UNIFORMS                  ||= 0x8B86
+    ATTACHED_SHADERS                 ||= 0x8B85
+    BLEND_EQUATION_ALPHA             ||= 0x883D
+    BLEND_EQUATION                   ||= 0x8009
+    BLEND_EQUATION_RGB               ||= BLEND_EQUATION
+    BOOL                             ||= 0x8B56
+    BOOL_VEC2                        ||= 0x8B57
+    BOOL_VEC3                        ||= 0x8B58
+    BOOL_VEC4                        ||= 0x8B59
+    COMPILE_STATUS                   ||= 0x8B81
+    COORD_REPLACE                    ||= 0x8862
+    CURRENT_PROGRAM                  ||= 0x8B8D
+    CURRENT_VERTEX_ATTRIB            ||= 0x8626
+    DELETE_STATUS                    ||= 0x8B80
+    DRAW_BUFFER0                     ||= 0x8825
+    DRAW_BUFFER1                     ||= 0x8826
+    DRAW_BUFFER10                    ||= 0x882F
+    DRAW_BUFFER11                    ||= 0x8830
+    DRAW_BUFFER12                    ||= 0x8831
+    DRAW_BUFFER13                    ||= 0x8832
+    DRAW_BUFFER14                    ||= 0x8833
+    DRAW_BUFFER15                    ||= 0x8834
+    DRAW_BUFFER2                     ||= 0x8827
+    DRAW_BUFFER3                     ||= 0x8828
+    DRAW_BUFFER4                     ||= 0x8829
+    DRAW_BUFFER5                     ||= 0x882A
+    DRAW_BUFFER6                     ||= 0x882B
+    DRAW_BUFFER7                     ||= 0x882C
+    DRAW_BUFFER8                     ||= 0x882D
+    DRAW_BUFFER9                     ||= 0x882E
+    FLOAT_MAT2                       ||= 0x8B5A
+    FLOAT_MAT3                       ||= 0x8B5B
+    FLOAT_MAT4                       ||= 0x8B5C
+    FLOAT_VEC2                       ||= 0x8B50
+    FLOAT_VEC3                       ||= 0x8B51
+    FLOAT_VEC4                       ||= 0x8B52
+    FRAGMENT_SHADER                  ||= 0x8B30
+    FRAGMENT_SHADER_DERIVATIVE_HINT  ||= 0x8B8B
+    INFO_LOG_LENGTH                  ||= 0x8B84
+    INT_VEC2                         ||= 0x8B53
+    INT_VEC3                         ||= 0x8B54
+    INT_VEC4                         ||= 0x8B55
+    LINK_STATUS                      ||= 0x8B82
+    LOWER_LEFT                       ||= 0x8CA1
+    MAX_COMBINED_TEXTURE_IMAGE_UNITS ||= 0x8B4D
+    MAX_DRAW_BUFFERS                 ||= 0x8824
+    MAX_FRAGMENT_UNIFORM_COMPONENTS  ||= 0x8B49
+    MAX_TEXTURE_COORDS               ||= 0x8871
+    MAX_TEXTURE_IMAGE_UNITS          ||= 0x8872
+    MAX_VARYING_FLOATS               ||= 0x8B4B
+    MAX_VERTEX_ATTRIBS               ||= 0x8869
+    MAX_VERTEX_TEXTURE_IMAGE_UNITS   ||= 0x8B4C
+    MAX_VERTEX_UNIFORM_COMPONENTS    ||= 0x8B4A
+    POINT_SPRITE                     ||= 0x8861
+    POINT_SPRITE_COORD_ORIGIN        ||= 0x8CA0
+    SAMPLER_1D                       ||= 0x8B5D
+    SAMPLER_1D_SHADOW                ||= 0x8B61
+    SAMPLER_2D                       ||= 0x8B5E
+    SAMPLER_2D_SHADOW                ||= 0x8B62
+    SAMPLER_3D                       ||= 0x8B5F
+    SAMPLER_CUBE                     ||= 0x8B60
+    SHADER_SOURCE_LENGTH             ||= 0x8B88
+    SHADER_TYPE                      ||= 0x8B4F
+    SHADING_LANGUAGE_VERSION         ||= 0x8B8C
+    STENCIL_BACK_FAIL                ||= 0x8801
+    STENCIL_BACK_FUNC                ||= 0x8800
+    STENCIL_BACK_PASS_DEPTH_FAIL     ||= 0x8802
+    STENCIL_BACK_PASS_DEPTH_PASS     ||= 0x8803
+    STENCIL_BACK_REF                 ||= 0x8CA3
+    STENCIL_BACK_VALUE_MASK          ||= 0x8CA4
+    STENCIL_BACK_WRITEMASK           ||= 0x8CA5
+    UPPER_LEFT                       ||= 0x8CA2
+    VALIDATE_STATUS                  ||= 0x8B83
+    VERTEX_ATTRIB_ARRAY_ENABLED      ||= 0x8622
+    VERTEX_ATTRIB_ARRAY_NORMALIZED   ||= 0x886A
+    VERTEX_ATTRIB_ARRAY_POINTER      ||= 0x8645
+    VERTEX_ATTRIB_ARRAY_SIZE         ||= 0x8623
+    VERTEX_ATTRIB_ARRAY_STRIDE       ||= 0x8624
+    VERTEX_ATTRIB_ARRAY_TYPE         ||= 0x8625
+    VERTEX_PROGRAM_POINT_SIZE        ||= 0x8642
+    VERTEX_PROGRAM_TWO_SIDE          ||= 0x8643
+    VERTEX_SHADER                    ||= 0x8B31
+  end
+end
+
+module GL_VERSION_2_0
+  module RenderContext
+    include Roglew::GLExtension
+
+    def create_program(shaders = nil)
+      program = Roglew::ShaderProgram.new(self)
+      return program unless shaders
+      shaders = case shaders
+      when Hash
+        shaders.map { |type, source| create_shader(type, source) }
+      when Array
+        shaders
+      else
+        raise ArgumentError, "It must be Hash or Array. Given: #{shaders.class}"
+      end
+      bind { |_|
+        program.attach(*shaders)
+        program.link
+      }
+      program
+    end
+
+    def create_shader(*args)
+      Roglew::Shader.new(self, *args)
+    end
+
+    functions	[:glAttachShader,             [:uint, :uint],                                               :void],
+              [:glBindAttribLocation,       [:uint, :uint, :string],                                      :void],
+              [:glBlendEquationSeparate,    [:uint, :uint],                                               :void],
+              [:glCompileShader,            [:uint],                                                      :void],
+              [:glCreateProgram,            [],                                                           :uint],
+              [:glCreateShader,             [:uint],                                                      :uint],
+              [:glDeleteProgram,            [:uint],                                                      :void],
+              [:glDeleteShader,             [:uint],                                                      :void],
+              [:glDetachShader,             [:uint, :uint],                                               :void],
+              [:glDisableVertexAttribArray, [:uint],                                                      :void],
+              [:glDrawBuffers,              [:int, :pointer],                                             :void],
+              [:glEnableVertexAttribArray,  [:uint],                                                      :void],
+              [:glGetActiveAttrib,          [:uint, :uint, :int, :pointer, :pointer, :pointer, :pointer], :void],
+              [:glGetActiveUniform,         [:uint, :uint, :int, :pointer, :pointer, :pointer, :pointer], :void],
+              [:glGetAttachedShaders,       [:uint, :int, :pointer, :pointer],                            :void],
+              [:glGetAttribLocation,        [:uint, :string],                                             :int],
+              [:glGetProgramInfoLog,        [:uint, :int, :pointer, :pointer],                            :void],
+              [:glGetProgramiv,             [:uint, :uint, :pointer],                                     :void],
+              [:glGetShaderInfoLog,         [:uint, :int, :pointer, :pointer],                            :void],
+              [:glGetShaderiv,              [:uint, :uint, :pointer],                                     :void],
+              [:glGetShaderSource,          [:uint, :int, :pointer, :pointer],                            :void],
+              [:glGetUniformfv,             [:uint, :int, :pointer],                                      :void],
+              [:glGetUniformiv,             [:uint, :int, :pointer],                                      :void],
+              [:glGetUniformLocation,       [:uint, :string],                                             :int],
+              [:glGetVertexAttribdv,        [:uint, :uint, :pointer],                                     :void],
+              [:glGetVertexAttribfv,        [:uint, :uint, :pointer],                                     :void],
+              [:glGetVertexAttribiv,        [:uint, :uint, :pointer],                                     :void],
+              [:glGetVertexAttribPointerv,  [:uint, :uint, :pointer],                                     :void],
+              [:glIsProgram,                [:uint],                                                      :bool],
+              [:glIsShader,                 [:uint],                                                      :bool],
+              [:glLinkProgram,              [:uint],                                                      :void],
+              [:glShaderSource,             [:uint, :int, :pointer, :pointer],                            :void],
+              [:glStencilFuncSeparate,      [:uint, :uint, :int, :uint],                                  :void],
+              [:glStencilMaskSeparate,      [:uint, :uint],                                               :void],
+              [:glStencilOpSeparate,        [:uint, :uint, :uint, :uint],                                 :void],
+              [:glUniform1f,                [:int, :float],                                               :void],
+              [:glUniform1fv,               [:int, :int, :pointer],                                       :void],
+              [:glUniform1i,                [:int, :int],                                                 :void],
+              [:glUniform1iv,               [:int, :int, :pointer],                                       :void],
+              [:glUniform2f,                [:int, :float, :float],                                       :void],
+              [:glUniform2fv,               [:int, :int, :pointer],                                       :void],
+              [:glUniform2i,                [:int, :int, :int],                                           :void],
+              [:glUniform2iv,               [:int, :int, :pointer],                                       :void],
+              [:glUniform3f,                [:int, :float, :float, :float],                               :void],
+              [:glUniform3fv,               [:int, :int, :pointer],                                       :void],
+              [:glUniform3i,                [:int, :int, :int, :int],                                     :void],
+              [:glUniform3iv,               [:int, :int, :pointer],                                       :void],
+              [:glUniform4f,                [:int, :float, :float, :float, :float],                       :void],
+              [:glUniform4fv,               [:int, :int, :pointer],                                       :void],
+              [:glUniform4i,                [:int, :int, :int, :int, :int],                               :void],
+              [:glUniform4iv,               [:int, :int, :pointer],                                       :void],
+              [:glUniformMatrix2fv,         [:int, :int, :bool, :pointer],                                :void],
+              [:glUniformMatrix3fv,         [:int, :int, :bool, :pointer],                                :void],
+              [:glUniformMatrix4fv,         [:int, :int, :bool, :pointer],                                :void],
+              [:glUseProgram,               [:uint],                                                      :void],
+              [:glValidateProgram,          [:uint],                                                      :void],
+              [:glVertexAttrib1d,           [:uint, :double],                                             :void],
+              [:glVertexAttrib1dv,          [:uint, :pointer],                                            :void],
+              [:glVertexAttrib1f,           [:uint, :float],                                              :void],
+              [:glVertexAttrib1fv,          [:uint, :pointer],                                            :void],
+              [:glVertexAttrib1s,           [:uint, :short],                                              :void],
+              [:glVertexAttrib1sv,          [:uint, :pointer],                                            :void],
+              [:glVertexAttrib2d,           [:uint, :double, :double],                                    :void],
+              [:glVertexAttrib2dv,          [:uint, :pointer],                                            :void],
+              [:glVertexAttrib2f,           [:uint, :float, :float],                                      :void],
+              [:glVertexAttrib2fv,          [:uint, :pointer],                                            :void],
+              [:glVertexAttrib2s,           [:uint, :short, :short],                                      :void],
+              [:glVertexAttrib2sv,          [:uint, :pointer],                                            :void],
+              [:glVertexAttrib3d,           [:uint, :double, :double, :double],                           :void],
+              [:glVertexAttrib3dv,          [:uint, :pointer],                                            :void],
+              [:glVertexAttrib3f,           [:uint, :float, :float, :float],                              :void],
+              [:glVertexAttrib3fv,          [:uint, :pointer],                                            :void],
+              [:glVertexAttrib3s,           [:uint, :short, :short, :short],                              :void],
+              [:glVertexAttrib3sv,          [:uint, :pointer],                                            :void],
+              [:glVertexAttrib4bv,          [:uint, :pointer],                                            :void],
+              [:glVertexAttrib4d,           [:uint, :double, :double, :double, :double],                  :void],
+              [:glVertexAttrib4dv,          [:uint, :pointer],                                            :void],
+              [:glVertexAttrib4f,           [:uint, :float, :float, :float, :float],                      :void],
+              [:glVertexAttrib4fv,          [:uint, :pointer],                                            :void],
+              [:glVertexAttrib4iv,          [:uint, :pointer],                                            :void],
+              [:glVertexAttrib4Nbv,         [:uint, :pointer],                                            :void],
+              [:glVertexAttrib4Niv,         [:uint, :pointer],                                            :void],
+              [:glVertexAttrib4Nsv,         [:uint, :pointer],                                            :void],
+              [:glVertexAttrib4Nub,         [:uint, :uchar, :uchar, :uchar, :uchar],                      :void],
+              [:glVertexAttrib4Nubv,        [:uint, :pointer],                                            :void],
+              [:glVertexAttrib4Nuiv,        [:uint, :pointer],                                            :void],
+              [:glVertexAttrib4Nusv,        [:uint, :pointer],                                            :void],
+              [:glVertexAttrib4s,           [:uint, :short, :short, :short, :short],                      :void],
+              [:glVertexAttrib4sv,          [:uint, :pointer],                                            :void],
+              [:glVertexAttrib4ubv,         [:uint, :pointer],                                            :void],
+              [:glVertexAttrib4uiv,         [:uint, :pointer],                                            :void],
+              [:glVertexAttrib4usv,         [:uint, :pointer],                                            :void],
+              [:glVertexAttribPointer,      [:uint, :int, :uint, :bool, :int, :pointer],                  :void]
+
+    def get_program(program, pname)
+      p = FFI::MemoryPointer.new(:int)
+      glGetProgramiv(program, pname, p)
+      result = p.read_int
+      [Roglew::GL::DELETE_STATUS, Roglew::GL::COMPILE_STATUS].include?(pname) ? result == Roglew::GL::TRUE : result
+    end
+
+    def get_program_info_log(program)
+      length = get_program(program, Roglew::GL::INFO_LOG_LENGTH)
+      p = FFI::MemoryPointer.new(:char, length)
+      glGetProgramInfoLog(program, length, nil, p)
+      p.read_string
+    end
+
+    def get_shader(shader, pname)
+      p = FFI::MemoryPointer.new(:int)
+      glGetShaderiv(shader, pname, p)
+      result = p.read_int
+      [Roglew::GL::DELETE_STATUS, Roglew::GL::COMPILE_STATUS].include?(pname) ? result == Roglew::GL::TRUE : result
+    end
+
+    def get_shader_info_log(shader)
+      length = get_shader(shader, Roglew::GL::INFO_LOG_LENGTH)
+      p = FFI::MemoryPointer.new(:char, length)
+      glGetShaderInfoLog(shader, length, nil, p)
+      p.read_string
+    end
+
+    def shader_sources(shader, *srcs)
+      ps = FFI::MemoryPointer.new(:string, srcs.length)
+      ps.write_array_of_pointer(srcs.map { |src| FFI::MemoryPointer.from_string(src) })
+      pl = FFI::MemoryPointer.new(:int, srcs.length)
+      pl.write_array_of_int(srcs.map { |src| src.length })
+      glShaderSource(shader, srcs.length, ps, pl)
+    end
+  end
+end
+
+%w'shader
+shader_program
+'.each { |f| require "#{File.expand_path(__FILE__)[0..-4]}/#{f}" }