rubygl 0.1.0 → 0.2.1

data/examples/faceted_example.rb

@@ -1,65 +1,72 @@
-require '../lib/rubygl'
-
-# Default Setup (Window + OpenGL Context), OpenGL Calls Are Valid After This Is Created
-config = RubyGL::DefaultSetup.new({:width => 400, :height => 400})
-puts RubyGL::Native::glGetString(RubyGL::Native::GL_VERSION)
-
-# Generate Vertices For A Diamond And Push Them To GPU Memory
-diamond_vertices = RubyGL::ComplexShape.gen_diamond(0.6, 0.6, 14)
-diamond_buff = RubyGL::VertexArray.new(diamond_vertices)
-
-# Set Up Our Perspective Matrix And Pre-Programmed Shader
-persp_mat = RubyGL::Mat4.perspective(90, 500.0 / 500.0, -0.001, -500)
-shader = RubyGL::ShaderGenerator.faceted_shader()
-shader.use_program()
-
-# Get The Locations Of Our Input "Attribute" Variables To The Shader
-position_loc = shader.attrib_location("position")
-
-# Associate Our position Variable With Our Diamond GPU Buffer (3 Components Per Vertex)
-diamond_buff.vertex_attrib_ptr(position_loc, 3)
-
-# Powerful Shorthand For Specifying An OpenGL Uniform Function, Uniform Variable 
-# Name, Input Data, And Any Extra Parameters Required By The Given Function Symbol 
-shader.send_uniform(:glUniformMatrix4fv, "perspective", persp_mat.to_a, 1, RubyGL::Native::GL_FALSE)
-shader.send_uniform(:glUniform3fv, "light", [-1.0, 0.0, -0.6], 1)
-shader.send_uniform(:glUniform4fv, "color", [1.0, 0.0, 0.0, 0.2], 1)
-
-# Standard Depth Test So That Z-Buffer Testing Is Used
-RubyGL::Native.glEnable(RubyGL::Native::GL_DEPTH_TEST)
-
-# Track The Frame Rate And Get A Counter For Rotation
-frames, counter = 0, 0
-time = Time.now.strftime("%s").to_i
-
-# Main Program Loop
-loop {
-    RubyGL::Native.glClearColor(1.0, 1.0, 1.0, 1.0)
-    RubyGL::Native.glClear(RubyGL::Native::GL_COLOR_BUFFER_BIT | RubyGL::Native::GL_DEPTH_BUFFER_BIT)
-    
-    # Matrix Operations Are Always Applied In Reverse Order They Were Multiplied
-    t1 = RubyGL::Mat4.translation(0.0, -0.25, -0.30) # 4: Translate
-    r1 = RubyGL::Mat4.rotation(0.0, 1.0, 0.0, counter)
-    r2 = RubyGL::Mat4.rotation(0.0, 0.0, 1.0, 45)
-    r3 = RubyGL::Mat4.rotation(0.0, 1.0, 0.0, -counter)
-    t1 *= r1 # 3: Spin Around New Y Axis
-    t1 *= r2 # 2: Tilt (45 Degrees)
-    t1 *= r3 # 1: Spin Around Initial Y Axis
-    shader.send_uniform(:glUniformMatrix4fv, "modelview", t1.to_a, 1, RubyGL::Native::GL_FALSE)
-    
-    frames += 1
-    counter += 0.8
-    
-    # Draw Our Diamond (3 Components Per Vertex)
-    diamond_buff.draw(3)
-    
-    # Calculate Frame Rate
-    if (((Time.now.strftime("%s").to_i - time) * 1000.0).to_i > 1) then
-        puts frames
-        frames = 0
-        time = Time.now.strftime("%s").to_i
-    end
-    
-    # Updates Screen And Executes Input Callbacks
-    config.end_frame()
+require '../lib/rubygl'
+
+# Default Setup (Window + OpenGL Context), OpenGL Calls Are Valid After This Is Created
+config = RubyGL::DefaultSetup.new({:width => 400, :height => 400})
+puts RubyGL::Native::glGetString(RubyGL::Native::GL_VERSION)
+
+# Generate Vertices For A Diamond And Push Them To GPU Memory
+diamond_vertices = RubyGL::ComplexShape.gen_diamond(0.6, 0.6, 14)
+diamond_buff = RubyGL::VertexArray.new(diamond_vertices)
+
+# Set Up Our Perspective Matrix And Pre-Programmed Shader
+persp_mat = RubyGL::Mat4.perspective(90, 500.0 / 500.0, -0.001, -500)
+shader = RubyGL::ShaderGenerator.faceted_shader()
+shader.use_program()
+
+# Get The Locations Of Our Input "Attribute" Variables To The Shader
+position_loc = shader.attrib_location("position")
+
+# Associate Our position Variable With Our Diamond GPU Buffer (3 Components Per Vertex)
+diamond_buff.vertex_attrib_ptr(position_loc, 3)
+
+# Powerful Shorthand For Specifying An OpenGL Uniform Function, Uniform Variable 
+# Name, Input Data, And Any Extra Parameters Required By The Given Function Symbol 
+shader.send_uniform(:glUniformMatrix4fv, "perspective", persp_mat.to_a, 1, RubyGL::Native::GL_FALSE)
+shader.send_uniform(:glUniform3fv, "light", [-1.0, 0.0, -0.6], 1)
+shader.send_uniform(:glUniform4fv, "color", [1.0, 0.0, 0.0, 0.2], 1)
+
+# Standard Depth Test So That Z-Buffer Testing Is Used
+RubyGL::Native.glEnable(RubyGL::Native::GL_DEPTH_TEST)
+
+# Track The Frame Rate And Get A Counter For Rotation
+frames, counter = 0, 0
+time = Time.now.strftime("%s").to_i
+
+# Callback Triggered When Application Is Closed
+RubyGL::Event.register(:quit) {
+    diamond_buff.release
+    config.teardown
+    abort("Application Closed")
+}
+
+# Main Program Loop
+loop {
+    RubyGL::Native.glClearColor(1.0, 1.0, 1.0, 1.0)
+    RubyGL::Native.glClear(RubyGL::Native::GL_COLOR_BUFFER_BIT | RubyGL::Native::GL_DEPTH_BUFFER_BIT)
+    
+    # Matrix Operations Are Always Applied In Reverse Order They Were Multiplied
+    t1 = RubyGL::Mat4.translation(0.0, -0.25, -0.30) # 4: Translate
+    r1 = RubyGL::Mat4.rotation(0.0, 1.0, 0.0, counter)
+    r2 = RubyGL::Mat4.rotation(0.0, 0.0, 1.0, 45)
+    r3 = RubyGL::Mat4.rotation(0.0, 1.0, 0.0, -counter)
+    t1 *= r1 # 3: Spin Around New Y Axis
+    t1 *= r2 # 2: Tilt (45 Degrees)
+    t1 *= r3 # 1: Spin Around Initial Y Axis
+    shader.send_uniform(:glUniformMatrix4fv, "modelview", t1.to_a, 1, RubyGL::Native::GL_FALSE)
+    
+    frames += 1
+    counter += 0.8
+    
+    # Draw Our Diamond (3 Components Per Vertex)
+    diamond_buff.draw(3)
+    
+    # Calculate Frame Rate
+    if (((Time.now.strftime("%s").to_i - time) * 1000.0).to_i > 1) then
+        puts frames
+        frames = 0
+        time = Time.now.strftime("%s").to_i
+    end
+    
+    # Updates Screen And Executes Input Callbacks
+    config.end_frame()
 }

data/examples/instanced_example.rb

@@ -1,128 +1,136 @@
-require '../lib/rubygl'
-
-# Default Setup (Window + OpenGL Context), OpenGL Calls Are Valid After This Is Created
-config = RubyGL::DefaultSetup.new({:width => 400, :height => 400})
-puts RubyGL::Native::glGetString(RubyGL::Native::GL_VERSION)
-
-# Create A Custom Faceted Shader
-shader = RubyGL::Shader.new('''
-    #version 130
-	uniform mat4 perspective;
-	uniform mat4 modelview;
-    in vec3 position;
-    in vec3 offset;
-    out vec3 vPosition;
-	
-    void main() {
-		vec4 hPosition = modelview * vec4(offset + position, 1);
-        vPosition = hPosition.xyz;
-        
-		gl_Position = perspective * hPosition;
-    }
-''','''
-    #version 130
-    in vec3 vPosition;
-    uniform vec4 color;
-    uniform vec3 light;
-    out vec4 fColor;
-
-    void main() {
-        vec3 dx = dFdy(vPosition);
-        vec3 dy = dFdx(vPosition);
-        vec3 triangle_norm = normalize(cross(dx, dy));
-        float factor = clamp(dot(triangle_norm, light), 0, 1);
-        
-        fColor = vec4(color.xyz * factor, color.w);
-    }
-''')
-shader.use_program()
-
-# Generate A Sphere With Radius 0.2 And 0 Extra Rings (Double Tetrahedron)
-sphere = RubyGL::ComplexShape.gen_sphere(0.2, 0)
-
-# Generate Positions For Multiple Copies Of Our Shape
-pos = []
-for x in 1..60
-    for y in 1..60
-        for z in 1..60
-            pos.push([x * 2, y * 2, -z * 2])
-        end
-    end
-end
-pos.flatten!
-puts pos.size / 3
-# Allocate Vertex Attribute Arrays
-vertices = RubyGL::VertexArray.new(sphere)
-positions = RubyGL::VertexArray.new(pos)
-
-persp_mat = RubyGL::Mat4.perspective(90, 500.0 / 500.0, -0.001, -500)
-
-# Associate in Values With Our Attribute Arrays
-vertices.vertex_attrib_ptr(shader.attrib_location("position"), 3)
-positions.vertex_attrib_ptr(shader.attrib_location("offset"), 3)
-
-# Increment Our Position Vector Once Every Instance
-positions.vertex_attrib_div(shader.attrib_location("offset"), 1)
-
-# Send Uniforms To Their Respective Shaders
-shader.send_uniform(:glUniformMatrix4fv, "perspective", persp_mat.to_a, 1, RubyGL::Native::GL_FALSE)
-shader.send_uniform(:glUniform3fv, "light", [-1.0, -1.0, -1.0], 1)
-shader.send_uniform(:glUniform4fv, "color", [1.0, 0.0, 0.0, 1.0], 1)
-
-# Standard Depth Test So That Z-Buffer Testing Is Used
-RubyGL::Native.glEnable(RubyGL::Native::GL_DEPTH_TEST)
-
-# Used To Reduce Graininess Between Clustered Fragments On The Screen
-RubyGL::Native.glEnable(RubyGL::Native::GL_BLEND)
-RubyGL::Native.glBlendFunc(RubyGL::Native::GL_ONE, RubyGL::Native::GL_SRC_COLOR)
-
-# Track The Frame Rate And Get A Counter For Rotation
-frames, counter = 0, 0
-time = Time.now.strftime("%s").to_i
-
-# Center Our Grid Of Shapes
-t1 = RubyGL::Mat4.translation(-61, -60, -40)
-focused, angle = false, 150
-
-# Main Program Loop
-loop {
-    RubyGL::Native.glClearColor(1.0, 1.0, 1.0, 1.0)
-    RubyGL::Native.glClear(RubyGL::Native::GL_COLOR_BUFFER_BIT | RubyGL::Native::GL_DEPTH_BUFFER_BIT)
-    
-    # Cube Is Rotated Into Place And Zoomed In To In A Spiral
-    r1 = nil
-    if !focused then
-        r1 = RubyGL::Mat4.rotation(0.0, 1.0, 0.0, angle)
-        angle -= 0.7
-        
-        if angle <= 0 then
-            focused = true
-        end
-        
-        r1 *= t1
-    else
-        r1 = RubyGL::Mat4.rotation(0.0, 0.0, 1.0, counter)
-        
-        r1 *= t1
-        
-        t1[3][2] += 0.3
-        counter += 0.3
-    end
-    
-    shader.send_uniform(:glUniformMatrix4fv, "modelview", r1.to_a, 1, RubyGL::Native::GL_FALSE)
-	
-    frames += 1
-    
-    # Draw Shapes (3 Components Per Vertex & (pos.size / 3) Number Of Instances)
-    vertices.draw_instanced(3, pos.size / 3)
-    
-    # Calculate Frame Rate
-    if (((Time.now.strftime("%s").to_i - time) * 1000.0).to_i > 1) then
-        puts frames
-        frames = 0
-        time = Time.now.strftime("%s").to_i
-    end
-    
-    # Updates Screen And Executes Input Callbacks
-    config.end_frame()
+require '../lib/rubygl'
+
+# Default Setup (Window + OpenGL Context), OpenGL Calls Are Valid After This Is Created
+config = RubyGL::DefaultSetup.new({:width => 360, :height => 360})
+puts RubyGL::Native::glGetString(RubyGL::Native::GL_VERSION)
+
+# Create A Custom Faceted Shader
+shader = RubyGL::Shader.new('''
+    #version 130
+	uniform mat4 perspective;
+	uniform mat4 modelview;
+    in vec3 position;
+    in vec3 offset;
+    out vec3 vPosition;
+	
+    void main() {
+		vec4 hPosition = modelview * vec4(offset + position, 1);
+        vPosition = hPosition.xyz;
+        
+		gl_Position = perspective * hPosition;
+    }
+''','''
+    #version 130
+    in vec3 vPosition;
+    uniform vec4 color;
+    uniform vec3 light;
+    out vec4 fColor;
+
+    void main() {
+        vec3 dx = dFdy(vPosition);
+        vec3 dy = dFdx(vPosition);
+        vec3 triangle_norm = normalize(cross(dx, dy));
+        float factor = clamp(dot(triangle_norm, light), 0.3, 1);
+        
+        fColor = vec4(color.xyz * factor, color.w);
+    }
+''')
+shader.use_program()
+
+# Generate A Sphere With Radius 0.2 And 0 Extra Rings (Double Tetrahedron)
+sphere = RubyGL::ComplexShape.gen_sphere(0.2, 0)
+
+# Generate Positions For Multiple Copies Of Our Shape
+pos = []
+for x in 1..60
+    for y in 1..60
+        for z in 1..60
+            pos.push([x * 2, y * 2, -z * 2])
+        end
+    end
+end
+pos.flatten!
+puts pos.size / 3
+# Allocate Vertex Attribute Arrays
+vertices = RubyGL::VertexArray.new(sphere)
+positions = RubyGL::VertexArray.new(pos)
+
+persp_mat = RubyGL::Mat4.perspective(90, 500.0 / 500.0, -0.001, -500)
+
+# Associate in Values With Our Attribute Arrays
+vertices.vertex_attrib_ptr(shader.attrib_location("position"), 3)
+positions.vertex_attrib_ptr(shader.attrib_location("offset"), 3)
+
+# Increment Our Position Vector Once Every Instance
+positions.vertex_attrib_div(shader.attrib_location("offset"), 1)
+
+# Send Uniforms To Their Respective Shaders
+shader.send_uniform(:glUniformMatrix4fv, "perspective", persp_mat.to_a, 1, RubyGL::Native::GL_FALSE)
+shader.send_uniform(:glUniform3fv, "light", [-1.0, -1.0, -1.0], 1)
+shader.send_uniform(:glUniform4fv, "color", [1.0, 0.0, 0.0, 1.0], 1)
+
+# Standard Depth Test So That Z-Buffer Testing Is Used
+RubyGL::Native.glEnable(RubyGL::Native::GL_DEPTH_TEST)
+
+# Used To Reduce Graininess Between Clustered Fragments On The Screen
+RubyGL::Native.glEnable(RubyGL::Native::GL_BLEND)
+RubyGL::Native.glBlendFunc(RubyGL::Native::GL_ONE, RubyGL::Native::GL_ZERO)
+
+# Track The Frame Rate And Get A Counter For Rotation
+frames, counter = 0, 0
+time = Time.now.strftime("%s").to_i
+
+# Center Our Grid Of Shapes
+t1 = RubyGL::Mat4.translation(-61, -60, -40)
+focused, angle = false, 150
+
+# Callback Triggered When Application Is Closed
+RubyGL::Event.register(:quit) {
+    vertices.release
+    positions.release
+    config.teardown
+    abort("Application Closed")
+}
+
+# Main Program Loop
+loop {
+    RubyGL::Native.glClearColor(1.0, 1.0, 1.0, 1.0)
+    RubyGL::Native.glClear(RubyGL::Native::GL_COLOR_BUFFER_BIT | RubyGL::Native::GL_DEPTH_BUFFER_BIT)
+    
+    # Cube Is Rotated Into Place And Zoomed In To In A Spiral
+    r1 = nil
+    if !focused then
+        r1 = RubyGL::Mat4.rotation(0.0, 1.0, 0.0, angle)
+        angle -= 1.0
+        
+        if angle <= 0 then
+            focused = true
+        end
+        
+        r1 *= t1
+    else
+        r1 = RubyGL::Mat4.rotation(0.0, 0.0, 1.0, counter)
+        
+        r1 *= t1
+        
+        t1[3][2] += 0.28
+        counter += 0.3
+    end
+    
+    shader.send_uniform(:glUniformMatrix4fv, "modelview", r1.to_a, 1, RubyGL::Native::GL_FALSE)
+	
+    frames += 1
+    
+    # Draw Shapes (3 Components Per Vertex & (pos.size / 3) Number Of Instances)
+    vertices.draw_instanced(3, pos.size / 3)
+    
+    # Calculate Frame Rate
+    if (((Time.now.strftime("%s").to_i - time) * 1000.0).to_i > 1) then
+        puts frames
+        frames = 0
+        time = Time.now.strftime("%s").to_i
+    end
+    
+    # Updates Screen And Executes Input Callbacks
+    config.end_frame()
 }

data/examples/phong_example.rb

@@ -1,72 +1,81 @@
-require '../lib/rubygl'
-
-# Default Setup (Window + OpenGL Context), OpenGL Calls Are Valid After This Is Created
-config = RubyGL::DefaultSetup.new({:width => 400, :height => 400})
-puts RubyGL::Native::glGetString(RubyGL::Native::GL_VERSION)
-
-# Generate Indices, Vertices, And Vertex Normals For A Diamond
-(vertices, indices) = RubyGL::Util.gen_index_arrays(RubyGL::ComplexShape.gen_diamond(0.6, 0.6, 50), 3)
-normals = RubyGL::Util.gen_vertex_normals(indices, vertices)
-
-# Push All Of Our Data To The GPU
-index_buff = RubyGL::IndexArray.new(indices)
-vertex_buff = RubyGL::VertexArray.new(vertices)
-normal_buff = RubyGL::VertexArray.new(normals)
-
-# Set Up Our Perspective Matrix And Pre-Programmed Shader
-persp_mat = RubyGL::Mat4.perspective(90, 500.0 / 500.0, -0.001, -500)
-shader = RubyGL::ShaderGenerator.phong_shader()
-shader.use_program()
-
-# Get The Locations Of Our Input "Attribute" Variables To The Shader
-position_loc = shader.attrib_location("position")
-normal_loc = shader.attrib_location("normal")
-
-# Associate Our position Variable With Our Diamond GPU Buffer (3 Components Per Vertex)
-vertex_buff.vertex_attrib_ptr(position_loc, 3)
-normal_buff.vertex_attrib_ptr(normal_loc, 3)
-
-# Powerful Shorthand For Specifying An OpenGL Uniform Function, Uniform Variable 
-# Name, Input Data, And Any Extra Parameters Required By The Given Function Symbol 
-shader.send_uniform(:glUniformMatrix4fv, "perspective", persp_mat.to_a, 1, RubyGL::Native::GL_FALSE)
-shader.send_uniform(:glUniform3fv, "light", [-1.0, -1.0, -5.0], 1)
-shader.send_uniform(:glUniform4fv, "color", [1.0, 0.0, 0.0, 1.0], 1)
-
-# Standard Depth Test So That Z-Buffer Testing Is Used
-RubyGL::Native.glEnable(RubyGL::Native::GL_DEPTH_TEST)
-
-# Track The Frame Rate And Get A Counter For Rotation
-frames, counter = 0, 0
-time = Time.now.strftime("%s").to_i
-
-# Main Program Loop
-loop {
-    RubyGL::Native.glClearColor(1.0, 1.0, 1.0, 1.0)
-    RubyGL::Native.glClear(RubyGL::Native::GL_COLOR_BUFFER_BIT | RubyGL::Native::GL_DEPTH_BUFFER_BIT)
-    
-    # Matrix Operations Are Always Applied In Reverse Order They Were Multiplied
-    t1 = RubyGL::Mat4.translation(0.0, -0.25, -0.30) # 4: Translate
-    r1 = RubyGL::Mat4.rotation(0.0, 1.0, 0.0, counter)
-    r2 = RubyGL::Mat4.rotation(0.0, 0.0, 1.0, 45)
-    r3 = RubyGL::Mat4.rotation(0.0, 1.0, 0.0, -counter)
-    t1 *= r1 # 3: Spin Around New Y Axis
-    t1 *= r2 # 2: Tilt (45 Degrees)
-    t1 *= r3 # 1: Spin Around Initial Y Axis
-    shader.send_uniform(:glUniformMatrix4fv, "modelview", t1.to_a, 1, RubyGL::Native::GL_FALSE)
-    
-    frames += 1
-    counter += 0.8
-    
-    # Draw Our Diamond (3 Components Per Vertex)
-    index_buff.draw(3)
-    
-    # Calculate Frame Rate
-    if (((Time.now.strftime("%s").to_i - time) * 1000.0).to_i > 1) then
-        puts frames
-        frames = 0
-        time = Time.now.strftime("%s").to_i
-    end
-    
-    # Updates Screen And Executes Input Callbacks
-    config.end_frame()
+require '../lib/rubygl'
+
+# Default Setup (Window + OpenGL Context), OpenGL Calls Are Valid After This Is Created
+config = RubyGL::DefaultSetup.new({:width => 360, :height => 360})
+puts RubyGL::Native::glGetString(RubyGL::Native::GL_VERSION)
+
+# Generate Indices, Vertices, And Vertex Normals For A Diamond
+(vertices, indices) = RubyGL::Util.gen_index_arrays(RubyGL::ComplexShape.gen_diamond(0.6, 0.6, 50), 3)
+normals = RubyGL::Util.gen_vertex_normals(indices, vertices)
+
+# Push All Of Our Data To The GPU
+index_buff = RubyGL::IndexArray.new(indices)
+vertex_buff = RubyGL::VertexArray.new(vertices)
+normal_buff = RubyGL::VertexArray.new(normals)
+
+# Set Up Our Perspective Matrix And Pre-Programmed Shader
+persp_mat = RubyGL::Mat4.perspective(90, 500.0 / 500.0, -0.001, -500)
+shader = RubyGL::ShaderGenerator.phong_shader()
+shader.use_program()
+
+# Get The Locations Of Our Input "Attribute" Variables To The Shader
+position_loc = shader.attrib_location("position")
+normal_loc = shader.attrib_location("normal")
+
+# Associate Our position Variable With Our Diamond GPU Buffer (3 Components Per Vertex)
+vertex_buff.vertex_attrib_ptr(position_loc, 3)
+normal_buff.vertex_attrib_ptr(normal_loc, 3)
+
+# Powerful Shorthand For Specifying An OpenGL Uniform Function, Uniform Variable 
+# Name, Input Data, And Any Extra Parameters Required By The Given Function Symbol 
+shader.send_uniform(:glUniformMatrix4fv, "perspective", persp_mat.to_a, 1, RubyGL::Native::GL_FALSE)
+shader.send_uniform(:glUniform3fv, "light", [-1.0, -1.0, -5.0], 1)
+shader.send_uniform(:glUniform4fv, "color", [1.0, 0.0, 0.0, 1.0], 1)
+
+# Standard Depth Test So That Z-Buffer Testing Is Used
+RubyGL::Native.glEnable(RubyGL::Native::GL_DEPTH_TEST)
+
+# Track The Frame Rate And Get A Counter For Rotation
+frames, counter = 0, 0
+time = Time.now.strftime("%s").to_i
+
+# Callback Triggered When Application Is Closed
+RubyGL::Event.register(:quit) {
+    index_buff.release
+    vertex_buff.release
+    normal_buff.release
+    config.teardown
+    abort("Application Closed")
+}
+
+# Main Program Loop
+loop {
+    RubyGL::Native.glClearColor(1.0, 1.0, 1.0, 1.0)
+    RubyGL::Native.glClear(RubyGL::Native::GL_COLOR_BUFFER_BIT | RubyGL::Native::GL_DEPTH_BUFFER_BIT)
+    
+    # Matrix Operations Are Always Applied In Reverse Order They Were Multiplied
+    t1 = RubyGL::Mat4.translation(0.0, -0.25, -0.30) # 4: Translate
+    r1 = RubyGL::Mat4.rotation(0.0, 1.0, 0.0, counter)
+    r2 = RubyGL::Mat4.rotation(0.0, 0.0, 1.0, 45)
+    r3 = RubyGL::Mat4.rotation(0.0, 1.0, 0.0, -counter)
+    t1 *= r1 # 3: Spin Around New Y Axis
+    t1 *= r2 # 2: Tilt (45 Degrees)
+    t1 *= r3 # 1: Spin Around Initial Y Axis
+    shader.send_uniform(:glUniformMatrix4fv, "modelview", t1.to_a, 1, RubyGL::Native::GL_FALSE)
+    
+    frames += 1
+    counter += 0.8
+    
+    # Draw Our Diamond (3 Components Per Vertex)
+    index_buff.draw(3)
+    
+    # Calculate Frame Rate
+    if (((Time.now.strftime("%s").to_i - time) * 1000.0).to_i > 1) then
+        puts frames
+        frames = 0
+        time = Time.now.strftime("%s").to_i
+    end
+    
+    # Updates Screen And Executes Input Callbacks
+    config.end_frame()
 }

data/lib/rubygl/event.rb

@@ -0,0 +1,64 @@
+require_relative './native/all_enums'
+
+module RubyGL
+    
+    class Event
+        @@callbacks = {}
+        
+        # Accepts an event_type symbol (see native/all_enums.rb) and a block that
+        # will be passed a struct containing event information (see native/input.rb)
+        def self.register(event_type, &block)
+            callback = FFI::Function.new(:int, [:pointer, :pointer]) do |_, event_ptr|
+                event_union = Native::Event.new(event_ptr)
+                
+                # Makes Our Case Statement Less Verbose
+                events = Native::ALL_EVENTS
+                
+                # Map Multiple Events To The Same Struct
+                if (event_union[:common][:type] == events[event_type]) then
+                    case events[event_type]
+                    when events[:quit]
+                        block.call(event_union[:quit])
+                    when events[:window_event]
+                        block.call(event_union[:window])
+                    when events[:key_down], events[:key_up]
+                        block.call(event_union[:key])
+                    when events[:text_editing]
+                        block.call(event_union[:edit])
+                    when events[:text_input]
+                        block.call(event_union[:text])
+                    when events[:mouse_motion]
+                        block.call(event_union[:motion])
+                    when events[:mouse_button_down], events[:mouse_button_up]
+                        block.call(event_union[:button])
+                    when events[:mouse_wheel]
+                        block.call(event_union[:wheel])
+                    when events[:joy_axis_motion]
+                        block.call(event_union[:jaxis])
+                    when events[:joy_ball_motion]
+                        block.call(event_union[:jball])
+                    when events[:joy_hat_motion]
+                        block.call(event_union[:jhat])
+                    when events[:joy_button_down], events[:joy_button_up]
+                        block.call(event_union[:jbutton])
+                    when events[:joy_device_added], events[:joy_device_removed]
+                        block.call(event_union[:jdevice])
+                    when events[:controller_axis_motion]
+                        block.call(event_union[:caxis])
+                    when events[:controller_button_down], events[:controller_button_up]
+                        block.call(event_union[:cbutton])
+                    when events[:controller_device_added], events[:controller_device_removed], events[:controller_device_remapped]
+                        block.call(event_union[:cdevice])
+                    when events[:drop_file]
+                        block.call(event_union[:drop])
+                    end
+                end
+            end
+            @@callbacks[event_type] = callback
+            
+            Native.addEventWatch(callback, nil)
+        end
+        
+    end
+    
+end