rubygl 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d0db02206c2e8a176817a841bc3ced8cfe60b4af
+  data.tar.gz: cc0aee2bc3df4f86b43b151e666b967ad9153b03
+SHA512:
+  metadata.gz: c37b401ada50218e49983b17a3e7d8f9486fe1a05f1b5bd99ac1ec67fd83cea4a6254c9febf8fa903a21b1f9364bed9bb8c1f8399a862e7eb7e71c3f220d5911
+  data.tar.gz: 7148dd01e893ed00fcfccb884b34d05e24a946ee01d668b637b3defc22a77b0f378784b225512394e6728a2f8210a266e2b247e3c36b3b05204623c3d33d7a86

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Andrew
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/Rakefile

@@ -0,0 +1,83 @@
+require 'rake/task'
+require 'rake/testtask'
+require 'tmpdir'
+
+SDL_INCLUDE = 'C:\Users\GG\Desktop\SDL2-2.0.3\i686-w64-mingw32\include\SDL2'
+SDL_LIB = 'C:\Users\GG\Desktop\SDL2-2.0.3\i686-w64-mingw32\lib'
+SDL_BIN = 'C:\Users\GG\Desktop\SDL2-2.0.3\i686-w64-mingw32\bin'
+
+MINGW_LIB = ''
+
+PROJ_INCLUDE = 'lib/RubyGL/Native/include'
+PROJ_SRC = 'lib/RubyGL/Native/src/'
+
+# OS Detection
+def os
+    @os ||= (
+        host_os = RbConfig::CONFIG['host_os']
+        
+        case host_os
+            when /mswin|msys|mingw|cygwin|bccwin|wince|emc/
+                :windows
+            when /darwin|mac os/
+                :macosx
+            when /linux/
+                :linux
+            when /solaris|bsd/
+                :unix
+            else
+                raise Error::WebDriverError, "unknown os: #{host_os.inspect}"
+        end
+    )
+end
+
+/---------------------------------RAKE JOBS-----------------------------------/
+
+task :default do
+    files = ['Audio', 'Window', 'GLContext', 'Input', 'OpenGL']
+    
+    # Build Object Files
+    obj = "gcc -I#{SDL_INCLUDE}  -I#{PROJ_INCLUDE} -c -fPIC REPLACE.c -o REPLACE.o"
+    files.each { |file|
+        sh (obj.gsub(/REPLACE/, PROJ_SRC + file))
+        file = file.prepend PROJ_SRC
+    }
+
+    # Build Shared Object File
+    bin = "gcc -L#{SDL_LIB} -L#{MINGW_LIB} #{files.join('.o ') << '.o'} \
+        -lmingw32 -lSDL2main -lSDL2 -lopengl32 -shared -o \
+        ext/#{os.to_s}/RubyGL.so"
+    sh bin
+end
+
+task :clean do
+    # Clean Out Object Files
+    FileUtils.rm Dir.glob(PROJ_SRC + '/*.o')
+end
+
+task :bindings do
+    shared_lib = "RubyGL.so"
+
+    Dir.mktmpdir { |dir|
+        # Generates Header And Source C Files
+        sh "ruby bin/gl_code_gen.rb gl 4.5 OpenGL #{dir}"
+    
+        # Run Preprocessor On Source File
+        sh "gcc -E -I#{SDL_INCLUDE} -o #{dir}/OpenGL.o #{dir}/OpenGL.c"
+    
+        # Pipe Preprocessor(ed) File And Header File To Generate Bindings
+        sh "ruby bin/ffi_code_gen.rb #{dir}/OpenGL.o #{dir}/OpenGL.h \
+            #{dir}/opengl.rb #{shared_lib}"
+    
+        # Move Files To Correct Folders
+        mv "#{dir}/OpenGL.h", PROJ_INCLUDE
+        mv "#{dir}/OpenGL.c", PROJ_SRC
+        mv "#{dir}/opengl.rb", "lib/RubyGL/Native/"
+    }
+end
+
+Rake::TestTask.new do |t|
+  t.libs << "tests"
+  t.test_files = FileList['tests/test*.rb']
+  t.verbose = true
+end

data/RubyGL.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+
+Gem::Specification.new do |spec|
+  spec.name          = 'rubygl'
+  spec.version       = '0.1.0'
+  spec.authors       = ["Andrew Miller"]
+  spec.email         = ["millera9@seattleu.edu"]
+  spec.summary       = %q{A Complete Solution For Graphics Programming In Ruby}
+  spec.description   = %q{This library provides you with all of the essentials for 
+  doing graphics programming in Ruby including windowing, context management, 
+  1:1 mapping of OpenGL calls, and input handling. The backend of this library 
+  consists of FFI functions with 1:1 mapping to the C code that makes all of this 
+  possible. The frontend of this library provides abstractions for interacting with
+  the backend functionality so that you do not have to deal with the manual memory
+  management from within Ruby that the backend requires.}
+  spec.homepage      = "https://github.com/GGist/RubyGL"
+  spec.license       = "MIT"
+  
+  spec.files         = `git ls-files`.split($/)
+  spec.require_paths = ["lib"]
+  
+  spec.add_dependency 'ffi'
+end

data/bin/ffi_code_gen.rb

@@ -0,0 +1,167 @@
+require 'fileutils'
+
+def resolve_typedef(type, type_defs)
+    while (type_defs[type]) do
+        type = type_defs[type]
+    end
+    
+    return type
+end
+
+def get_type(type, hash)
+    hash[type]
+end
+
+def match_type(type, regex_hash)
+    regex_hash.select { |key,val|
+        type =~ key
+    }.values[0]
+end
+
+def write_file(name, contents, mode = 'w+')
+    File.open(name, mode) { |file|
+        file << contents
+    }
+end
+
+/--------------------------------START SCRIPT---------------------------------/
+# ARGV: [Object File] [Header File] [Ruby Source Name] [Library Name]
+
+SOURCE_INDENTS = 4
+FFI_TYPES = { 'char' => 'char', 'signed char' => 'char',
+'unsigned char' => 'uchar', 'int8_t' => 'int8', 'uint8_t' => 'uint8', 
+'short' => 'short', 'unsigned short' => 'ushort', 'int16_t' => 'int16', 
+'uint16_t' => 'uint16', 'int' => 'int', 'unsigned int' => 'uint', 
+'int32_t' => 'int32', 'uint32_t' => 'uint32', 'long int' => 'long', 
+'unsigned long int' => 'ulong', 'int64_t' => 'int64', 'uint64_t' => 'uint64', 
+'long long int' => 'long_long', 'unsigned long long int' => 'ulong_long', 
+'float' => 'float', 'double' => 'double' }
+FFI_PTR_TYPES = { /\Aconst +(?:unsigned +)?char *\*\Z/ => 'string', /\*/ => 'pointer' }
+
+# Open Pre-Processor(ed) Source File
+source_code = ''
+File.open(ARGV[0]) { |file|
+    source_code = file.read
+}
+
+# Associate Type Definitions With Their Actual Types
+typedef_hash = {}
+source_code.scan(/^typedef (.*?;)$/).flatten.each { |segment|
+    segment.gsub!(/\*/, '* ')
+    
+    if (segment =~ /\(.*?\*.*?\)/) then # Function Pointer
+        key = segment[/\* *(.*?) *\)/, 1]
+
+        typedef_hash[key] = segment[0..-2] # Remove Semi-Colon
+    else # Other Type
+        key = segment[/([^ ]+);/, 1]
+        
+        typedef_hash[key] = segment[/(.*?) +[^ ]+;/, 1]
+    end
+}
+
+# Open Header File
+source_code = ''
+File.open(ARGV[1]) { |file|
+    source_code = file.read
+}
+
+# Associate Macros With Their Literal Types (OpenGL Enumerations)
+macro_tuples = []
+source_code.scan(/^#define GL_.+?$/i).each { |macro|
+    token = macro[/^.+ +(.+) +.+$/, 1]
+    value = macro[/^.+ +.+ +(.+)$/, 1]
+    macro_tuples.push([token, value])
+}
+
+# Pull Out OpenGL Function Names From Header
+gl_functions = source_code.scan(/^.+?gl.+?\(.*?\);$/)
+
+ffi_template = "require 'ffi'
+
+module RubyGL::Native
+FUNCTIONS_GO_HERE
+    
+CONSTANTS_GO_HERE
+end
+"
+
+# Append Functions (Param Type -> Typedefs -> Ruby Type)
+buffer = ''
+gl_functions.each { |signature|
+    buffer << ' ' * SOURCE_INDENTS + 'attach_function :' +
+        signature[/(gl.*?)\(.*?\);/, 1] + ', ['
+
+    # Get Type List
+    param_type_list = signature[/\((.*?)\);/, 1].split(', ').map { |full_param|
+        full_param[/(.+) [[:alnum:]]+/, 1]
+    }
+    
+    # Type Definition -> Primitive (Actual) Type
+    param_type_list.map! { |param_type|
+        # Parameter Type Could Use Multiple Type Definitions
+        
+        simple_param_types = param_type.gsub(/(?:\*|const)/, ' ').split(' ')
+        # Translate Each Type And Put Back Into param_type
+        simple_param_types.each { |simple_param_type|
+            primitive_type = resolve_typedef(simple_param_type, typedef_hash)
+        
+            param_type.sub!(/#{simple_param_type}/, primitive_type)
+        }
+        
+        param_type
+    }
+
+    # Primitive Type -> Ruby FFI Type
+    param_type_list.each { |param_type|
+        mutable_type = param_type.gsub(/const/, '').strip
+
+        if (get_type(mutable_type, FFI_TYPES)) then
+            param_type = get_type(mutable_type, FFI_TYPES)
+        else
+            param_type = match_type(param_type, FFI_PTR_TYPES)
+        end
+
+        # Write Out FFI Type
+        buffer << ':' + param_type + ', '
+    }
+    if (buffer[-1] == '[') then # No Parameters
+        buffer << '],'
+    else # At Least One Parameter
+        buffer[-2..-1] = '],'
+    end
+    
+    # Get Return Type
+    # We Do Not Care About const If We Can Match Our Return Type With A
+    # Primitive Type. Otherwise, We Might Be Able To Match Against A 
+    # const char* Or const unsigned char* In Which Case We Prefer To Use A 
+    # string Type.
+    return_type = signature[/(.*?) gl[^ ]+\(/, 1]
+    mutable_return_type = return_type.gsub(/ *const */, '')
+
+    mutable_return_type.gsub(/\*/, ' ').split(' ').each { |type|
+        resolved_type = resolve_typedef(type, typedef_hash)
+        
+        mutable_return_type.sub!(/#{type}/, resolved_type)
+        return_type.sub!(/#{type}/, resolved_type)
+    }
+        
+    if (get_type(mutable_return_type, FFI_TYPES)) then
+        return_type = get_type(mutable_return_type, FFI_TYPES)
+    elsif (match_type(return_type, FFI_PTR_TYPES))
+        return_type = match_type(return_type, FFI_PTR_TYPES)
+    end
+    
+    buffer << ' :' + return_type + "\n"
+}
+ffi_template.sub!(/FUNCTIONS_GO_HERE/, buffer)
+
+# Append OpenGL Enumerations (Macros)
+buffer = ''
+macro_tuples.each { |name,val|
+    buffer << ' ' * SOURCE_INDENTS + "#{name} = #{val}\n"
+}
+ffi_template.sub!(/CONSTANTS_GO_HERE/, buffer)
+
+write_file(ARGV[2], ffi_template)
+/---------------------------------END SCRIPT----------------------------------/

data/bin/gl_code_gen.rb

@@ -0,0 +1,459 @@
+require 'net/http'
+require 'openssl'
+require 'rexml/document'
+require 'fileutils'
+
+# Decorate String Class With Convenience Methods For Parsing
+class String
+    def to_bool
+        return true if self == true || self =~ (/^(?:true|t|yes|y|1)$/i)
+        return false if self == false || self.blank? || self =~ (/^(?:false|f|no|n|0)$/i)
+        raise ArgumentError.new("Invalid Boolean: \"#{self}\"")
+    end
+    def to_bool?
+        begin
+            self.to_bool
+        rescue
+            return false
+        end
+        return true
+    end
+    def is_i?
+        !!(self =~ /\A[-+]?[0-9]+\Z/)
+    end
+    def replace_tags(sub)
+        self.gsub(/\<.*?\>/, sub)
+    end
+end
+
+# Returns The Page Source Of The url And Aborts If Anything Other Than A 200
+# Is Received.
+def get_page_source(url)
+    uri = URI.parse url
+    
+    http = Net::HTTP.new(uri.host, uri.port)
+    if (uri.kind_of? URI::HTTPS) then
+        http.use_ssl = true
+        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+    end
+    
+    response = http.get(uri.path)
+    if (response.code != '200') then
+        abort("\nWas not able to pull xml file from #{uri}" +
+        "Response Code: #{response.code}")
+    end
+    
+    return response.body
+end
+
+# Returns An API List In The Form Of [[API, Version], ...]
+def get_api_list(root)
+    api_list = []
+
+    root.each_element('feature') { |element|
+        api = element.attributes['api']
+        version = element.attributes['number']
+        
+        api_list.push [api, version]
+    }
+    
+    return api_list
+end
+
+# Builds An ASCII Grid View From The Tuple List Supplied. The Cell Sizes Will
+# Dynamically Scale Based On The Biggest Cell So That Columns Are Aligned.
+def get_grid_view(console_width, tuple_list)
+    formatting_chars = 6
+
+    # Find Size Of Longest String Element (With Formatting)
+    max_length = tuple_list.sort {    |a,b|
+        string_one = a[0] + a[1]
+        string_two = b[0] + b[1]
+        
+        string_one.size <=> string_two.size
+    }.last.join('').size + tuple_list.size.to_s.size + formatting_chars
+    
+    options_per_row = console_width / max_length
+    
+    # Build 1-D Array Of Concatenated Strings
+    curr_iteraion = -1
+    concat_list = tuple_list.collect { |a,b|
+        curr_iteraion += 1
+        ' ' + curr_iteraion.to_s + ': ' + a + ' ' + b + ' '
+    }
+    formatting_chars -= 5
+    
+    # Expand Concatenated Strings Into Result
+    result = '-' * console_width
+    curr_column = 1
+    concat_list.each { |concat_item|
+        num_padding = max_length - concat_item.size - formatting_chars
+        
+        result << concat_item << ' ' * num_padding
+        
+        if (curr_column == options_per_row) then
+            result << "\n" + ('-' * console_width)
+            curr_column = 1
+        else
+            result << '|'
+            curr_column += 1
+        end
+    }
+    
+    result << "\n" + ('-' * console_width) if result[-1] != '-'
+    
+    return result
+end
+
+# Pads The String With pad_char So That It Fills columns Completely
+def get_pretty(columns, pad_char, string)
+    padding = pad_char * ((columns - string.size) / 2)
+    
+    result = (padding + string + padding)
+    result << pad_char if result.size < columns
+    
+    return result
+end
+
+# Writes contents Out To path/name Using mode
+def write_file(path, name, contents, mode = 'w+')
+    FileUtils.mkdir_p(path)
+    
+    File.open(path + '/' + name, mode) { |file|
+        file << contents
+    }
+end
+
+# Verify The Supplied api And version Numbers Against The api_list
+def valid_api_values?(api_list, api, version)
+    api_list.find_index { |api_tuple|
+        api_tuple[0].casecmp(api) && api_tuple[1].to_f == version
+    } != nil
+end
+
+# Verify The Supplied "api_index" To Make Sure It Is Valid
+def valid_api_index?(api_list, api_index)
+    api_index.is_i? && (0...api_list.size).include?(api_index.to_i)
+end
+
+# Prompt User With An api_list In A Grid View For An api_index Selection
+def prompt_user(api_list)
+    # Prompt User
+    print get_pretty(COLUMN_WIDTH, ' ', GRID_TITLE)
+    print get_grid_view(COLUMN_WIDTH, api_list)
+    puts "Note: OpenGL 3.2 introduced the notion of a 'core' profile which
+    essentially means that it is not completely backwards compatible with
+    earlier versions. To retain this backwards compatibility (not recommended)
+    append a 'C' to the index number of the API you want.".gsub(/\s/, ' ')
+
+    # User Input
+    print "\nEnter The Index Number Next To The API You Want: "
+    api_index = gets.chomp
+    compatibility_mode = false
+
+    if (api_index[-1].upcase == 'C') then
+        compatibility_mode = true
+        api_index = api_index[0..-2]
+    end
+
+    while (!valid_api_index?(api_list, api_index)) do
+        print "Please Enter A Valid Input: "
+        api_index = gets.chomp
+    
+        if (api_index[-1].upcase == 'C') then
+            compatibility_mode = true
+            api_index = api_index[0..-2]
+        else
+            compatibility_mode = false
+        end
+    end
+    api_index = api_index.to_i
+    
+    return [api_list[api_index][0], api_list[api_index][1].to_f, 
+        compatibility_mode]
+end
+
+/--------------------------------START SCRIPT---------------------------------/
+
+# ARGV: (GL_API GL_VERSION) NAME FOLDER 
+# All Optional, If GL_API Is Specified Then GL_VERSION Must Be As Well
+
+# Constants
+COLUMN_WIDTH = 80
+GRID_TITLE = "OpenGL API Versions"
+GL_URL = 'https://cvs.khronos.org/svn/repos/ogl/trunk/doc/registry/public/api'
+GL_PATH = '/gl.xml'
+EGL_URL = 'http://www.khronos.org/registry/egl/api'
+EGL_KHR_PATH = '/KHR/khrplatform.h'
+SOURCE_INDENTS = 2
+
+# Execution Variables
+gl_header = 'OpenGL.h'
+gl_source = 'OpenGL.c'
+directory = './'
+api, version, compatibility_mode = nil, nil, false
+
+# Check Command Line Arguments
+if (ARGV[0]) then
+    api = ARGV[0]
+    version = ARGV[1].to_f
+    compatibility_mode = ARGV[1][-1].casecmp('C') == 0
+end
+if (ARGV[2]) then
+    gl_header = ARGV[2] + '.h'
+    gl_source = ARGV[2] + '.c'
+end
+if (ARGV[3]) then
+    directory = ARGV[3]
+end
+
+print "\n" + get_pretty(COLUMN_WIDTH, '-', "Pulling Data From Web")
+puts "- #{GL_URL + GL_PATH}"
+source = get_page_source(GL_URL + GL_PATH)
+puts get_pretty(COLUMN_WIDTH, '-', "Finished Pulling Data")
+
+print get_pretty(COLUMN_WIDTH, '-', "Building XML Structure")
+puts "Bytes: #{source.size}"
+root = REXML::Document.new(source).root
+puts get_pretty(COLUMN_WIDTH, '-', "Finished Building XML Structure")
+    
+# Extract API And Version Information
+api_list = get_api_list(root) # [[API, Version], ...]
+
+if (!api || !version) then # Prompt User
+    api_tuple = prompt_user(api_list)
+    
+    api = api_tuple[0]
+    version = api_tuple[1]
+    compatibility_mode = api_tuple[3]
+else # Verify User Parameters
+    if (!valid_api_values?(api_list, api, version)) then
+        abort("Invalid API Or Version Parameters Passed To Script")
+    end
+end
+
+puts get_pretty(COLUMN_WIDTH, '-', "API/Version/Profile - #{api}/#{version}/" + 
+    (compatibility_mode ? "Compatibility" : "Core"))
+
+# Parse All Enumerations And Commands
+all_enums, all_commands = {}, {}
+print get_pretty(COLUMN_WIDTH, '-', "Crawling XML Structure")
+
+puts "Parsing Enumerations..."
+root.each_element('enums/enum') { |element|
+    all_enums[element.attributes['name']] = element.attributes['value']
+}
+puts "Parsed All Enumerations\n\n"
+
+puts "Parsing Commands..."
+root.each_element('commands/command') { |element|
+    comm_name = element.elements['proto/name'].text
+    
+    command = element.elements['proto'].to_s.replace_tags(' ').squeeze(' ').strip
+    command << '('
+    
+    element.each_element('param') { |innerElement|
+        command << innerElement.to_s.replace_tags(' ').squeeze(' ').strip + ', '
+    }
+    command[-2..-1] = '' if command.end_with? ', '
+
+    all_commands[comm_name] = command + ');'
+}
+puts "Parsed All Commands"
+
+puts get_pretty(COLUMN_WIDTH, '-', "Finished Crawling XML Structure")
+
+#-----------------------------Build Header File-------------------------------
+used_enums, used_commands = {}, {}
+
+header_template = "#ifndef #{gl_header.upcase.sub(/\./, '_')}
+#define #{gl_header.upcase.sub(/\./, '_')}
+
+#ifdef __cplusplus
+extern \"C\" {
+#endif
+
+#if defined(_WIN32) && !defined(APIENTRY) && !defined(__CYGWIN__) && !defined(__SCITECH_SNAP__)
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN 1
+#endif
+#include <windows.h>
+#undef near // Used As An Identifier In OpenGL
+#undef far // Used As An Identifier In OpenGL
+#endif
+
+#ifndef APIENTRY
+#define APIENTRY
+#endif
+
+COMMENTS_GO_HERE
+
+TYPEDEFS_GO_HERE
+
+DEFINES_GO_HERE
+
+FUNCTIONS_GO_HERE
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif"
+
+print get_pretty(COLUMN_WIDTH, '-', "Generating File #{gl_header}")
+
+puts "Appending Comments To #{gl_header}..."
+buffer = "/*\n"
+root.elements['comment'].text.each_line { |line|
+    buffer << '** ' << line
+}
+buffer << "\n*/"
+header_template.sub!(/COMMENTS_GO_HERE/, buffer)
+puts "Comments Have Been Appended\n\n"
+
+# Pull Out All Possible Include Dependencies
+puts "Appending Type Definitions To #{gl_header}..."
+possible_includes = {}
+root.each_element('types/type[@name]') { |element|
+    possible_includes[element.attributes['name']] = element.text
+}
+
+# Pull Out All Possible Types And Check If They Have Include Dependencies
+actual_includes, buffer = {}, ''
+attrib_filter = api == 'gl' ? 'not(@api)' : "@api='#{api}'"
+root.each_element("types/type[#{attrib_filter} and not(@name)]") { |element|
+    content = element.to_s.replace_tags(' ').squeeze(' ').strip
+    content.gsub!(/ +;/, ';')
+    buffer << content << "\n"
+    
+    requires = element.attributes['requires']
+    if (requires && !actual_includes[requires]) then
+        actual_includes[requires] = possible_includes[requires]
+    end
+}
+
+# Any Header Dependencies Found
+actual_includes.each { |require,include|
+    if (require == 'khrplatform') then
+        print get_pretty(COLUMN_WIDTH, '-', "Pulling Data From Web")
+        puts "- #{EGL_URL + EGL_KHR_PATH}"
+        
+        source = get_page_source(EGL_URL + EGL_KHR_PATH)
+        write_file("#{directory}/KHR", 'khrplatform.h', source)
+        
+        print get_pretty(COLUMN_WIDTH, '-', "Finished Pulling Data")
+    end
+    
+    # Ugh, Khronos Re-Used The Require Attribute For Non-Header Dependencies!!!
+    if (include) then
+        buffer.prepend(include + "\n")
+    end
+}
+header_template.sub!(/TYPEDEFS_GO_HERE/, buffer)
+puts "Appended Type Definitions\n\n"
+
+puts "Filtering Macros And Commands..."
+root.each_element('feature') { |element|
+    if (element.attributes['api'] == api && element.attributes['number'].to_f <= version) then
+        element.each_element('require/enum') { |inner_element|
+            enum_name = inner_element.attributes['name']
+            used_enums[enum_name] = all_enums[enum_name]
+        }
+        
+        element.each_element('require/command') { |inner_element|
+            comm_name = inner_element.attributes['name']
+            used_commands[comm_name] = all_commands[comm_name]
+        }
+        if (!compatibility_mode) then
+            element.each_element('remove/enum') { |inner_element|
+                enum_name = inner_element.attributes['name']
+                used_enums.delete(enum_name)
+            }
+            element.each_element('remove/command') { |inner_element|
+                comm_name = inner_element.attributes['name']
+                used_commands.delete(comm_name)
+            }
+        end
+    end
+}
+puts "Filtered Macros And Commands\n\n"
+
+puts "Appending Macro To #{gl_header}..."
+used_enums, buffer = used_enums.to_a.sort, ''
+used_enums.each { |name,value|
+    buffer << '#define ' << name << ' ' << value << "\n"
+}
+header_template.sub!(/DEFINES_GO_HERE/, buffer)
+puts "Appended Macros\n\n"
+
+puts "Appending Commands To #{gl_header}..."
+used_commands, buffer = used_commands.to_a.sort, ''
+used_commands.each { |name,signature|
+    buffer << signature << "\n"
+}
+header_template.sub!(/FUNCTIONS_GO_HERE/, buffer)
+puts "Appended Commands"
+
+write_file(directory, gl_header, header_template)
+puts get_pretty(COLUMN_WIDTH, '-', "Finished Generating #{gl_header}")
+
+#-----------------------------Build Source File-------------------------------
+print get_pretty(COLUMN_WIDTH, '-', "Generating File #{gl_source}")
+
+buffer = "#include \"#{gl_header}\"\n#include \"SDL.h\"\n\n"
+
+puts "Appending Command Definitions To #{gl_source}..."
+used_commands.each { |name,signature|
+    buffer << signature[0..-2] + " {\n"
+
+    # Break Function Down
+    func_return_type = signature[/\A(.*?)gl/, 1].strip
+    typedef_name = 'GL_' + name[2..-1] + '_Func'
+    func_ptr_name = name + '_ptr'
+    param_type_list = []
+    unless (signature =~ /\(\);/) then # Has At Least One Parameter
+        param_type_list = signature[/\((.*?);/, 1].split(/ *\w+[,\)] */)
+    end
+    param_name_list = signature.scan(/(\w+)[,\)]/).flatten
+
+    # Append Typedef
+    buffer << ' ' * SOURCE_INDENTS + 'typedef ' + func_return_type + 
+        " (APIENTRY * #{typedef_name})("
+    param_type_list.each { |param_type|
+        buffer << param_type + ', '
+    }
+    if (buffer[-2..-1] == ', ') then
+        buffer[-2..-1] = ');'
+    else
+        buffer << ');'
+    end
+    buffer << "\n"
+
+    # Append Pointer Initialization
+    buffer << ' ' * SOURCE_INDENTS + 'static ' + typedef_name + ' ' + 
+        func_ptr_name + " = NULL;\n\n"
+
+    buffer << ' ' * SOURCE_INDENTS + "if (#{func_ptr_name} == NULL) {\n" +
+        ' ' * (SOURCE_INDENTS * 2) + func_ptr_name + 
+        " = (#{typedef_name})SDL_GL_GetProcAddress(__func__);\n" +
+        ' ' * SOURCE_INDENTS + "}\n\n"
+            
+    # Append Function Pointer Call
+    buffer << ' ' * SOURCE_INDENTS + func_ptr_name + '('
+    param_name_list.each { |param_name|
+        buffer << param_name + ', '
+    }
+    if (buffer[-2..-1] == ', ') then
+        buffer[-2..-1] = ');'
+    else
+        buffer << ');'
+    end
+    
+    buffer << "\n}\n\n"
+}
+write_file(directory, gl_source, buffer)
+puts "Finished Appending Command Definitions"
+
+print get_pretty(COLUMN_WIDTH, '-', "Finished Generating #{gl_source}")
+
+/---------------------------------END SCRIPT----------------------------------/