rubygl 0.1.0

data/lib/RubyGL/Native/src/GLContext.c

@@ -0,0 +1,73 @@
+#include "GLContext.h"
+
+const SDL_GLattr RED_SIZE = SDL_GL_RED_SIZE,
+    GREEN_SIZE = SDL_GL_GREEN_SIZE,
+    BLUE_SIZE = SDL_GL_BLUE_SIZE,
+    ALPHA_SIZE = SDL_GL_ALPHA_SIZE,
+    BUFFER_SIZE = SDL_GL_BUFFER_SIZE,
+    DOUBLEBUFFER = SDL_GL_DOUBLEBUFFER,
+    DEPTH_SIZE = SDL_GL_DEPTH_SIZE,
+    STENCIL_SIZE = SDL_GL_STENCIL_SIZE,
+    ACCUM_RED_SIZE = SDL_GL_ACCUM_RED_SIZE,
+    ACCUM_GREEN_SIZE = SDL_GL_ACCUM_GREEN_SIZE,
+    ACCUM_BLUE_SIZE = SDL_GL_ACCUM_BLUE_SIZE,
+    ACCUM_ALPHA_SIZE = SDL_GL_ACCUM_ALPHA_SIZE,
+    STEREO = SDL_GL_STEREO,
+    MULTISAMPLEBUFFERS = SDL_GL_MULTISAMPLEBUFFERS,
+    MULTISAMPLESAMPLES = SDL_GL_MULTISAMPLESAMPLES,
+    ACCELERATED_VISUAL = SDL_GL_ACCELERATED_VISUAL,
+    CONTEXT_MAJOR_VERSION = SDL_GL_CONTEXT_MAJOR_VERSION,
+    CONTEXT_MINOR_VERSION = SDL_GL_CONTEXT_MINOR_VERSION,
+    CONTEXT_FLAGS = SDL_GL_CONTEXT_FLAGS,
+    CONTEXT_PROFILE_MASK = SDL_GL_CONTEXT_PROFILE_MASK,
+    SHARE_WITH_CURRENT_CONTEXT = SDL_GL_SHARE_WITH_CURRENT_CONTEXT,
+    FRAMEBUFFER_SRGB_CAPABLE = SDL_GL_FRAMEBUFFER_SRGB_CAPABLE;
+
+const SDL_GLcontextFlag CONTEXT_DEBUG_FLAG = SDL_GL_CONTEXT_DEBUG_FLAG,
+    CONTEXT_FORWARD_COMPATIBLE_FLAG = SDL_GL_CONTEXT_FORWARD_COMPATIBLE_FLAG,
+    CONTEXT_ROBUST_ACCESS_FLAG = SDL_GL_CONTEXT_ROBUST_ACCESS_FLAG,
+    CONTEXT_RESET_ISOLATION_FLAG = SDL_GL_CONTEXT_RESET_ISOLATION_FLAG;
+
+const SDL_GLprofile CONTEXT_PROFILE_CORE = SDL_GL_CONTEXT_PROFILE_CORE,
+    CONTEXT_PROFILE_COMPATIBILITY = SDL_GL_CONTEXT_PROFILE_COMPATIBILITY,
+    CONTEXT_PROFILE_ES = SDL_GL_CONTEXT_PROFILE_ES;
+
+int loadLibrary(const char* path)
+{
+    return SDL_GL_LoadLibrary(path);
+}
+
+void unloadLibrary(void)
+{
+    SDL_GL_UnloadLibrary();
+}
+
+SDL_GLContext createContext(SDL_Window* window)
+{
+    return SDL_GL_CreateContext(window);
+}
+
+void deleteContext(SDL_GLContext context)
+{
+    SDL_GL_DeleteContext(context);
+}
+
+int setAttribute(SDL_GLattr attr, int value)
+{
+    return SDL_GL_SetAttribute(attr, value);
+}
+
+int makeCurrent(SDL_Window* window, SDL_GLContext context)
+{
+    return SDL_GL_MakeCurrent(window, context);
+}
+
+int setSwapInterval(int interval)
+{
+    return SDL_GL_SetSwapInterval(interval);
+}
+
+void swapWindow(SDL_Window* window)
+{
+    SDL_GL_SwapWindow(window);
+}

data/lib/RubyGL/Native/src/Input.c

@@ -0,0 +1,26 @@
+#include "Input.h"
+
+int initInput()
+{
+    return SDL_InitSubSystem(SDL_INIT_EVENTS);
+}
+
+void quitInput()
+{
+    SDL_QuitSubSystem(SDL_INIT_EVENTS);
+}
+
+void addEventWatch(SDL_EventFilter filter, void* userdata)
+{
+    SDL_AddEventWatch(filter, userdata);
+}
+
+void deleteEventWatch(SDL_EventFilter filter, void* userdata)
+{
+    SDL_DelEventWatch(filter, userdata);
+}
+
+void pumpEvents(void)
+{
+    SDL_PumpEvents();
+}

data/lib/RubyGL/Native/src/Window.c

@@ -0,0 +1,58 @@
+#include "Window.h"
+
+const SDL_WindowFlags FULLSCREEN = SDL_WINDOW_FULLSCREEN,
+    OPENGL = SDL_WINDOW_OPENGL,
+    SHOWN = SDL_WINDOW_SHOWN, 
+    HIDDEN = SDL_WINDOW_HIDDEN,
+    BORDERLESS = SDL_WINDOW_BORDERLESS, 
+    RESIZABLE = SDL_WINDOW_RESIZABLE, 
+    MINIMIZED = SDL_WINDOW_MINIMIZED,
+    MAXIMIZED = SDL_WINDOW_MAXIMIZED, 
+    INPUT_GRABBED = SDL_WINDOW_INPUT_GRABBED, 
+    INPUT_FOCUS = SDL_WINDOW_INPUT_FOCUS,
+    MOUSE_FOCUS = SDL_WINDOW_MOUSE_FOCUS, 
+    FULLSCREEN_DESKTOP = SDL_WINDOW_FULLSCREEN_DESKTOP, 
+    FOREIGN = SDL_WINDOW_FOREIGN,
+    ALLOW_HIGHDPI = SDL_WINDOW_ALLOW_HIGHDPI;
+
+int initWindow()
+{
+    return SDL_InitSubSystem(SDL_INIT_VIDEO);
+}
+
+void quitWindow()
+{
+    SDL_QuitSubSystem(SDL_INIT_VIDEO);
+}
+    
+SDL_Window* createWindow(const char* title, int x, int y, int w, int h, 
+                         Uint32 flags)
+{
+    return SDL_CreateWindow(title, x, y, w, h, flags);
+}
+
+void destroyWindow(SDL_Window* window)
+{
+    SDL_DestroyWindow(window);
+}
+                         
+void hideWindow(SDL_Window* window)
+{
+    SDL_HideWindow(window);
+}
+
+void showWindow(SDL_Window* window)
+{
+    SDL_ShowWindow(window);
+}
+
+int setWindowBrightness(SDL_Window* window, float brightness)
+{
+    return SDL_SetWindowBrightness(window, brightness);
+}
+
+int showSimpleMessageBox(Uint32 flags, const char* title, const char* message,
+                         SDL_Window* window)
+{
+    return SDL_ShowSimpleMessageBox(flags, title, message, window);
+}

data/lib/RubyGL/Native/window.rb

@@ -0,0 +1,25 @@
+require 'ffi'
+
+module RubyGL::Native
+    attach_function :initWindow, [], :int
+    attach_function :quitWindow, [], :void
+    attach_function :createWindow, [:string, :int, :int, :int, :int, :uint32], :pointer
+    attach_function :destroyWindow, [:pointer], :void
+    attach_function :hideWindow, [:pointer], :void
+    attach_function :showWindow, [:pointer], :void
+    attach_function :setWindowBrightness, [:pointer, :float], :int
+    attach_function :showSimpleMessageBox, [:uint32, :string, :string, :pointer], :int
+    
+    attach_variable :FULLSCREEN, :int
+    attach_variable :OPENGL, :int
+    attach_variable :SHOWN, :int
+    attach_variable :HIDDEN, :int
+    attach_variable :BORDERLESS, :int
+    attach_variable :RESIZABLE, :int
+    attach_variable :MINIMIZED, :int
+    attach_variable :MAXIMIZED, :int
+    attach_variable :INPUT_FOCUS, :int
+    attach_variable :MOUSE_FOCUS, :int
+    attach_variable :FULLSCREEN_DESKTOP, :int
+    attach_variable :ALLOW_HIGHDPI, :int
+end

data/lib/RubyGL/callback.rb

@@ -0,0 +1,10 @@
+
+module RubyGL
+    
+    class InputCallback
+        def self.register()
+            
+        end
+    end
+    
+end

data/lib/RubyGL/geometry.rb

@@ -0,0 +1,212 @@
+require_relative './math'
+require_relative './util'
+
+module RubyGL
+
+    # All Point Operations Return New Points
+    class Point
+        attr_accessor :x, :y, :z
+        
+        def initialize(x, y, z = 0)
+            @x = x
+            @y = y
+            @z = z
+        end
+        
+        def +(point)
+            Point.new(@x + point.x, @y + point.y, @z + point.z)
+        end
+        
+        def -(point)
+            Point.new(@x - point.x, @y - point.y, @z - point.z)
+        end
+        
+        def scale(value)
+            Point.new(@x * value, @y * value, @z * value)
+        end
+        
+        def distance(point)
+            temp = self - point
+            
+            Math::sqrt(temp.x * temp.x + temp.y * temp.y + temp.z * temp.z)
+        end
+        
+        def midpoint(point)
+            Point.new((@x + point.x) * 0.5, (@y + point.y) * 0.5, (@z + point.z) * 0.5)
+        end
+        
+        def to_ary
+            [@x, @y, @z]
+        end
+        
+        def to_a
+            self.to_ary
+        end
+    end
+
+    # Class For Generating 2-D Shapes
+    class SimpleShape
+    
+    end
+    
+    # Class For Generating 3-D Shapes
+    class ComplexShape
+        # Generates an array of 3 component vertices in counter-clockwise triangle
+        # configuration. This is the vertex data for a 3 dimensional sphere. The 
+        # num_rings parameter should always be 0 or a positive even number.
+        def self.gen_sphere(radius, num_rings)
+            points_per_ring = num_rings * 2 + 4
+            rings_per_half = num_rings / 2 + 1 # Count The Center Ring For Both Sides
+
+            # Generate Points From Bottom Of Sphere To The Top
+            points = []
+            for i in 1..num_rings + 1
+                ring_y_factor = (i - rings_per_half).to_f / rings_per_half
+                ring_y_value = ring_y_factor * radius
+                ring_radius = Math::cos(Math::asin(ring_y_value / radius)) * radius
+                
+                for i in 0..points_per_ring
+                    radians = Conversion.deg_to_rad(i.to_f / points_per_ring * 360)
+                    
+                    x = Math::cos(radians) * ring_radius
+                    z = Math::sin(radians) * ring_radius
+                    
+                    points.push(Point.new(x, ring_y_value, z))
+                end
+            end
+            
+            vertex_array, previous_points = [], []
+            
+            # Build Bottom End-Cap
+            bottom_point = [0, -radius, 0]
+            for i in 0...points_per_ring
+                curr_vert = points[i]
+                next_vert = Util.overflow_wrap(points, i + 1)
+                
+                vertex_array.push([next_vert.to_a, curr_vert.to_a, bottom_point])
+                previous_points.push(curr_vert)
+            end
+            
+            # Build Intermediate Mesh
+            for i in points_per_ring...points.size
+                curr_vert = points[i]
+                next_vert = Util.overflow_wrap(points, i + 1)
+                
+                last_curr_vert = previous_points[i % points_per_ring]
+                last_next_vert = Util.overflow_wrap(previous_points, (i % points_per_ring) + 1)
+                
+                vertex_array.push([next_vert.to_a, curr_vert.to_a, last_curr_vert.to_a])
+                vertex_array.push([last_next_vert.to_a, next_vert.to_a, last_curr_vert.to_a])
+                previous_points[i % points_per_ring] = curr_vert
+            end
+            
+            # Build Top End-Cap
+            top_point = [0, radius, 0]
+            for i in 0...previous_points.size()
+                curr_vert = previous_points[i]
+                next_vert = Util.overflow_wrap(previous_points, i + 1)
+                
+                vertex_array.push([curr_vert.to_a, next_vert.to_a, top_point.to_a])
+            end
+            
+            vertex_array.flatten!
+            
+            vertex_array
+        end
+    
+        # Generates an array of 3 component vertices in counter-clockwise triangle
+        # configuration. This is the vertex data for a 3 dimensional diamond. The 
+        # girdle_facets parameters should always be an even number.
+        def self.gen_diamond(diamond_height, girdle_radius, girdle_facets)
+            # Table Y Value Is Equal To diamond_height
+            girdle_y_value = diamond_height * 2.5 / 3.0 # Girdle Upper Ring
+            crown_y_midpoint = 2.0 / 3.0
+            
+            girdle_thickness = diamond_height / 10.0
+            
+            table_radius = girdle_radius / 1.8
+            table_facets = girdle_facets / 2.0
+            
+            girdle_points = []
+            girdle_point_factor = 360.0 / girdle_facets # Multiply With Point Index To Get Degree
+            # Generate x And z Values For Diamond Girdle
+            for i in 0...girdle_facets
+                curr_degree = i.to_f * girdle_point_factor
+                curr_rad = Conversion::deg_to_rad(curr_degree)
+                
+                x = Math::cos(curr_rad) * girdle_radius
+                z = Math::sin(curr_rad) * girdle_radius
+                
+                girdle_points.push(Point.new(x, girdle_y_value, z))
+            end
+            
+            table_points = []
+            table_point_factor = 360.0 / table_facets # Multiply With Point Index To Get Degree
+            # Generate x And z Values For Diamond Table
+            for i in 0...table_facets
+                curr_degree = i.to_f * table_point_factor
+                curr_rad = Conversion::deg_to_rad(curr_degree)
+                
+                x = Math::cos(curr_rad) * table_radius
+                z = Math::sin(curr_rad) * table_radius
+                
+                table_points.push(Point.new(x, diamond_height, z))
+            end
+            
+            vertex_array = []
+            # Traverse Every Other Point On The Girdle
+            for i in 0...girdle_points.size / 2
+                center_girdle_index = (i * 2) + 1
+                left_girdle_index = center_girdle_index - 1
+                right_girdle_index = center_girdle_index + 1
+                
+                gird_center = girdle_points[center_girdle_index]
+                gird_left = girdle_points[left_girdle_index]
+                gird_right = Util.overflow_wrap(girdle_points, right_girdle_index)
+                
+                tab_left = table_points[left_girdle_index / 2]
+                tab_right = Util.overflow_wrap(table_points, right_girdle_index / 2)
+                
+                # Crown Triangles
+                # Using 3D Equation Of A Line To Get Central Connection Point For Crown
+                slope = tab_left.midpoint(tab_right) - gird_center
+                crown_midpoint = slope.scale(crown_y_midpoint) + gird_center
+                
+                vertex_array.push([crown_midpoint.to_a, gird_left.to_a, gird_center.to_a])
+                vertex_array.push([crown_midpoint.to_a, gird_center.to_a, gird_right.to_a])
+                
+                vertex_array.push([crown_midpoint.to_a, tab_left.to_a, gird_left.to_a])
+                vertex_array.push([crown_midpoint.to_a, gird_right.to_a, tab_right.to_a])
+                
+                vertex_array.push([crown_midpoint.to_a, tab_right.to_a, tab_left.to_a])
+                
+                # Girdle Triangles
+                lower_gird_center = Point.new(gird_center.x, gird_center.y - girdle_thickness, gird_center.z)
+                lower_gird_left = Point.new(gird_left.x, gird_left.y - girdle_thickness, gird_left.z)
+                lower_gird_right = Point.new(gird_right.x, gird_right.y - girdle_thickness, gird_right.z)
+                
+                vertex_array.push([gird_center.to_a, gird_left.to_a, lower_gird_left.to_a])
+                vertex_array.push([gird_center.to_a, lower_gird_left.to_a, lower_gird_center.to_a])
+                
+                vertex_array.push([gird_center.to_a, lower_gird_center.to_a, gird_right.to_a])
+                vertex_array.push([gird_right.to_a, lower_gird_center.to_a, lower_gird_right.to_a])
+                
+                # Pavilion Triangles
+                pavil_bottom = Point.new(0, 0, 0)
+                
+                vertex_array.push([lower_gird_center.to_a, lower_gird_left.to_a, pavil_bottom.to_a])
+                vertex_array.push([lower_gird_center.to_a, pavil_bottom.to_a, lower_gird_right.to_a])
+                
+                # Table Triangles
+                table_mid = Point.new(0, diamond_height, 0)
+                
+                vertex_array.push([table_mid.to_a, tab_left.to_a, tab_right.to_a])
+            end
+            
+            vertex_array.flatten!
+            
+            vertex_array
+        end
+    end
+    
+end

data/lib/RubyGL/math.rb

@@ -0,0 +1,301 @@
+
+module RubyGL
+
+    class Conversion
+        @@PI_DIV = Math::PI / 180.0
+        @@DIV_PI = 180.0 / Math::PI
+        
+        def self.deg_to_rad(degrees)
+            degrees * @@PI_DIV
+        end
+        
+        def self.rad_to_deg(radians)
+            radians * @@DIV_PI
+        end
+    end
+    
+    class Vec3
+        def initialize(array = nil)
+            @data = Array.new(3, 0)
+            
+            if array then
+                for i in 0...@data.size
+                    @data[i] = array[i]
+                end
+            end
+        end
+        
+        def +(other_vector)
+            new_vector = Vec3.new()
+            
+            for i in 0...@data.size
+                new_vector[i] = @data[i] + other_vector[i]
+            end
+            
+            new_vector
+        end
+        
+        def -(other_vector)
+            new_vector = Vec3.new()
+            
+            for i in 0...@data.size
+                new_vector[i] = @data[i] - other_vector[i]
+            end
+            
+            new_vector
+        end
+        
+        def cross(other_vector)
+            new_vector = Vec3.new()
+            
+            new_vector[0] = (@data[1] * other_vector[2]) - (@data[2] * other_vector[1])
+            new_vector[1] = (@data[0] * other_vector[2]) - (@data[2] * other_vector[0])
+            new_vector[2] = (@data[0] * other_vector[1]) - (@data[1] * other_vector[0])
+            
+            new_vector
+        end
+        
+        def norm!()
+            curr_len = self.len().abs()
+            
+            for i in 0...@data.size
+                @data[i] /= curr_len
+            end
+        end
+        
+        def norm()
+            new_vector = Vec2.new()
+            
+            for i in 0...@data.size
+                new_vector[i] = @data[i]
+            end
+            new_vector.norm!
+            
+            new_vector
+        end
+        
+        def len()
+            sum = 0
+            
+            for i in 0...@data.size
+                sum += @data[i] * @data[i]
+            end
+            
+            Math::sqrt(sum)
+        end
+        
+        def [](index)
+            @data[index]
+        end
+        
+        def []=(index, value)
+            @data[index] = value
+        end
+        
+        def to_ary()
+            Array.new(@data)
+        end
+        
+        def to_a()
+            self.to_ary
+        end
+    end
+    
+    class Vec4
+        def initialize()
+            @data = Array.new(4, 0)
+        end
+        
+        def +(other_vector)
+            new_vector = Vec4.new()
+            
+            for i in 0..@data.size
+                new_vector[i] = @data[i] + other_vector[i]
+            end
+            
+            new_vector
+        end
+        
+        def -(other_vector)
+            new_vector = Vec4.new()
+            
+            for i in 0..@data.size
+                new_vector[i] = @data[i] - other_vector[i]
+            end
+            
+            new_vector
+        end
+        
+        def norm!()
+            curr_len = self.len()
+            
+            for i in 0...@data.size
+                @data /= curr_len
+            end
+        end
+        
+        def norm()
+            new_vector = Vec2.new()
+            
+            for i in 0...@data.size
+                new_vector[i] = @data[i]
+            end
+            new_vector.norm!
+            
+            new_vector
+        end
+        
+        def len()
+            sum = 0
+            
+            for i in 0...@data.size
+                sum += @data[i] * @data[i]
+            end
+            
+            Math::sqrt(sum)
+        end
+        
+        def [](index)
+            @data[index]
+        end
+        
+        def []=(index, value)
+            @data[index] = value
+        end
+        
+        def to_ary()
+            Array.new(@data)
+        end
+        
+        def to_a()
+            self.to_ary
+        end
+    end
+    
+    # Stored In Column Order For Interoperability With OpenGL. Subscript Operator
+    # Will Return A Vector That Represents A Column Within The Matrix. This Matrix
+    # Class Only Supports Matrices Where The Number Of Rows Equals The Number Of
+    # Columns; Operations Are Constrained As Such.
+    class Mat4
+        def initialize(diagonal = 1.0)
+            @data = Array.new(4) { |index|
+                column = Vec4.new()
+                column[index] = diagonal
+                
+                column
+            }
+        end
+        
+        def self.translation(x, y, z)
+            matrix = Mat4.new(1.0)
+            
+            matrix[3][0] = x
+            matrix[3][1] = y
+            matrix[3][2] = z
+            
+            matrix
+        end
+        
+        # The axis value should be 0 if that axis should not be rotated around;
+        # any other value indicates its priority (higher priority axis is rotated
+        # around before the lower priority axis).
+        def self.rotation(x_axis, y_axis, z_axis, theta)
+            rad_angle = Conversion::deg_to_rad(theta)
+            sin_angle = Math::sin(rad_angle)
+            cos_angle = Math::cos(rad_angle)
+            
+            # Multiply Lower -> Higher To Get Ordering Correct
+            axis_priority = [[:x, x_axis], [:y, y_axis], [:z, z_axis]]
+            axis_priority.delete_if { |(_, val)| 
+                val == 0 
+            }.sort!.reverse!
+            
+            rot_matrix = Mat4.new(1.0)
+            axis_priority.each { |(axis, _)|
+                mat = Mat4.new(1.0)
+            
+                if axis == :x then
+                    mat[1][1] = mat[2][2] = cos_angle
+                    mat[1][2] = sin_angle
+                    mat[2][1] = -sin_angle
+                elsif axis == :y then
+                    mat[0][0] = mat[2][2] = cos_angle
+                    mat[0][2] = -sin_angle
+                    mat[2][0] = sin_angle
+                else
+                    mat[0][0] = mat[1][1] = cos_angle
+                    mat[0][1] = sin_angle
+                    mat[1][0] = -sin_angle
+                end
+                
+                rot_matrix *= mat
+            }
+            
+            rot_matrix
+        end
+        
+        def self.perspective(fov, aspect, z_near, z_far)
+            top = Math::tan(Conversion::deg_to_rad(fov) / 2) * z_near
+            right = top * aspect
+            
+            mat = Mat4.new(1.0)
+            mat[0][0] = z_near / right
+            mat[1][1] = z_near / top
+            mat[2][2] = -(z_far + z_near) / (z_far - z_near)
+            mat[3][2] = -2.0 * z_far * z_near / (z_far - z_near)
+            mat[2][3] = -1.0
+            
+            mat
+        end
+        
+        def self.orthogonal(left, right, bottom, top, z_near = -1.0, z_far = 1.0)
+            mat = Mat4.new(1.0)
+            mat[0][0] = 2.0 / (right - left)
+            mat[1][1] = 2.0 / (top - bottom)
+            mat[2][2] = 2.0 / (z_near - z_far)
+            mat[3][3] = 1.0
+            mat[3][0] = -(right + left) / (right - left)
+            mat[3][1] = -(top + bottom) / (top - bottom)
+            mat[3][2] = -(z_far + z_near) / (z_far - z_near)
+            
+            mat
+        end
+        
+        def *(other_matrix)
+            new_matrix = Mat4.new(0)
+            
+            for i in 0...self.dim
+                for j in 0...self.dim
+                    for k in 0...self.dim
+                        new_matrix[j][i] += self[k][i] * other_matrix[j][k]
+                    end
+                end
+            end
+            
+            new_matrix
+        end
+        
+        def dim()
+            @data.size()
+        end
+        
+        def [](index)
+            @data[index]
+        end
+        
+        def []=(index, value)
+            @data[index] = value
+        end
+        
+        def to_ary()
+            @data.collect { |vec|
+                vec.to_ary
+            }.flatten!
+        end
+        
+        def to_a()
+            self.to_ary
+        end
+    end
+    
+end