rubygl 0.1.0

data/lib/RubyGL/memory.rb

@@ -0,0 +1,122 @@
+require_relative './native/opengl'
+
+module RubyGL
+
+    class VertexArray
+        # Allocates a GPU buffer for vertex_array and transfers the data as a vertex
+        # attribute array. This allows you to access the given data from within any
+        # shader as long as it is bound beforehand.
+        def initialize(vertex_array)
+            buff_ptr = FFI::MemoryPointer.new(:uint)
+            Native.glGenBuffers(1, buff_ptr)
+            
+            @buffer_id = buff_ptr.get_int(0)
+            @buffer_elements = vertex_array.size
+            @buffer_valid = true
+            
+            if @buffer_id <= 0 then
+                raise "Could Not Allocate A GPU Buffer For The VertexArray Object"
+            end
+            
+            Native.glBindBuffer(Native::GL_ARRAY_BUFFER, @buffer_id)
+            
+            vertex_data = FFI::MemoryPointer.new(:float, vertex_array.size)
+            vertex_data.write_array_of_float(vertex_array)
+            
+            Native.glBufferData(Native::GL_ARRAY_BUFFER, vertex_data.size, vertex_data, Native::GL_STATIC_DRAW)
+            
+            Native.glBindBuffer(Native::GL_ARRAY_BUFFER, 0)
+        end
+        
+        def draw(components)
+            raise "Call To VertexArray#draw On Invalid Object" unless @buffer_valid
+        
+            Native.glDrawArrays(Native::GL_TRIANGLES, 0, @buffer_elements / components)
+        end
+        
+        def draw_instanced(components, iterations)
+            raise "Call To VertexArray#draw_instanced On Invalid Object" unless @buffer_valid
+            
+            Native.glDrawArraysInstanced(Native::GL_TRIANGLES, 0, @buffer_elements / components, iterations)
+        end
+        
+        def vertex_attrib_div(location, instances_per_change)
+            raise "Call To VertexArray#vertex_attrib_div On Invalid Object" unless @buffer_valid
+            
+            Native.glVertexAttribDivisor(location, instances_per_change)
+        end
+        
+        # Binds the VertexArray to the attribute at location within a shader.
+        def vertex_attrib_ptr(location, components)
+            raise "Call To VertexArray#vertex_attrib_ptr On Invalid Object" unless @buffer_valid
+        
+            # TODO: Move This To Constructor In The Future
+            Native.glEnableVertexAttribArray(location)
+            
+            Native.glBindBuffer(Native::GL_ARRAY_BUFFER, @buffer_id)
+            
+            Native.glVertexAttribPointer(location, components, Native::GL_FLOAT, Native::GL_FALSE, 0, FFI::MemoryPointer::NULL)
+        
+            Native.glBindBuffer(Native::GL_ARRAY_BUFFER, 0)
+        end
+        
+        # This frees the currently allocated GPU buffer for this VertexArray and
+        # invalidates this VertexArray object. Any calls to this object after calling
+        # this method will throw a runtime error.
+        def release()
+            buff_ptr = FFI::MemoryPointer.new(:uint)
+            buff_ptr.write_uint(@buffer_id)
+            
+            Native.glDeleteBuffers(1, buff_ptr)
+            
+            @buffer_valid = false
+        end
+    end
+    
+    class IndexArray
+        def initialize(index_array)
+            buff_ptr = FFI::MemoryPointer.new(:pointer)
+            Native.glGenBuffers(1, buff_ptr)
+            
+            @buffer_id = buff_ptr.get_int(0)
+            @buffer_elements = index_array.size
+            @buffer_valid = true
+            
+            if @buffer_id <= 0 then
+                raise "Could Not Allocate A GPU Buffer For The IndexArray Object"
+            end
+            
+            Native.glBindBuffer(Native::GL_ELEMENT_ARRAY_BUFFER, @buffer_id)
+            
+            index_data = FFI::MemoryPointer.new(:uint, index_array.size)
+            index_data.write_array_of_uint(index_array)
+            
+            Native.glBufferData(Native::GL_ELEMENT_ARRAY_BUFFER, index_data.size, index_data, Native::GL_STATIC_DRAW)
+            
+            Native.glBindBuffer(Native::GL_ELEMENT_ARRAY_BUFFER, 0)
+        end
+        
+        def draw(components)
+            raise "Call To IndexArray#draw On Frozen Object" unless @buffer_valid
+        
+            Native.glBindBuffer(Native::GL_ELEMENT_ARRAY_BUFFER, @buffer_id)
+        
+            Native.glDrawElements(Native::GL_TRIANGLES, @buffer_elements, Native::GL_UNSIGNED_INT, FFI::MemoryPointer::NULL)
+        
+            Native.glBindBuffer(Native::GL_ELEMENT_ARRAY_BUFFER, 0)
+        end
+        
+        # This frees the currently allocated GPU buffer for this IndexArray and
+        # invalidates this IndexArray object. Any calls to this object after calling
+        # this method will throw a runtime error.
+        def release()
+            buff_ptr = FFI::MemoryPointer.new(:uint)
+            buff_ptr.put_int(@buffer_id)
+            
+            Native.glDeleteBuffers(1, buff_ptr)
+            
+            @buffer_valid = false
+        end
+    end
+
+end

data/lib/RubyGL/setup.rb

@@ -0,0 +1,51 @@
+require_relative './native/glcontext'
+require_relative './native/window'
+
+module RubyGL
+
+    class DefaultSetup
+        # The args hash accepts position and size values to be applied to the window.
+        # :x, :y, :width, :height
+        def initialize(args = {})
+            RubyGL::Native.initWindow
+            RubyGL::Native.initInput
+            RubyGL::Native.loadLibrary(FFI::Pointer::NULL)
+            
+            RubyGL::Native.setAttribute(:context_major_version, 4)
+            RubyGL::Native.setAttribute(:context_minor_version, 2)
+            RubyGL::Native.setAttribute(:context_profile_mask, RubyGL::Native.CONTEXT_PROFILE_COMPATIBILITY)
+            
+            RubyGL::Native.setAttribute(:depth_size, 24)
+            RubyGL::Native.setAttribute(:doublebuffer, 1)
+            
+            @window = RubyGL::Native.createWindow("RubyGL Window", 
+                args[:x] || 50, args[:y] || 50, 
+                args[:width] || 500, args[:height] || 500, 
+                RubyGL::Native.OPENGL)
+            @context = RubyGL::Native.createContext(@window)
+            
+            RubyGL::Native.makeCurrent(@window, @context)
+            RubyGL::Native.setSwapInterval(1)
+        end
+        
+        def show_dialog(title, message)
+            RubyGL::Native.showSimpleMessageBox(0, title, message, @window)
+        end
+        
+        def end_frame()
+            RubyGL::Native.swapWindow(@window)
+            
+            RubyGL::Native.pumpEvents()
+        end
+        
+        def teardown()
+            RubyGL::Native.deleteContext(@context)
+            RubyGL::Native.destroyWindow(@window)
+        
+            RubyGL::Native.unloadLibrary()
+            RubyGL::Native.quitWindow()
+            RubyGL::Native.quitInput()
+        end
+    end
+
+end

data/lib/RubyGL/shader.rb

@@ -0,0 +1,203 @@
+require_relative './native/opengl'
+
+module RubyGL
+
+    class Shader
+        def initialize(vert_src, frag_src)
+            @v_shader_id = Native.glCreateShader(Native::GL_VERTEX_SHADER)
+            @f_shader_id = Native.glCreateShader(Native::GL_FRAGMENT_SHADER)
+            @attrib_locs, @uniform_locs = {}, {}
+            
+            # Pointer Used To Point To The String Of Our Source Code
+            shader_src_ptr = FFI::MemoryPointer.new(:pointer)
+            shader_src_len = FFI::MemoryPointer.new(:int)
+            
+            v_shader_ptr = FFI::MemoryPointer.from_string(vert_src)
+            f_shader_ptr = FFI::MemoryPointer.from_string(frag_src)
+            
+            shader_src_ptr.write_pointer(v_shader_ptr.address)
+            shader_src_len.write_int(vert_src.size)
+            Native.glShaderSource(@v_shader_id, 1, shader_src_ptr, shader_src_len)
+            
+            shader_src_ptr.write_pointer(f_shader_ptr.address)
+            shader_src_len.write_int(frag_src.size)
+            Native.glShaderSource(@f_shader_id, 1, shader_src_ptr, shader_src_len)
+            
+            Native.glCompileShader(@v_shader_id)
+            Native.glCompileShader(@f_shader_id)
+            
+            # Throw Exception With Compile Error If Compilation Failed
+            Shader.compile_status(@v_shader_id)
+            Shader.compile_status(@f_shader_id)
+            
+            @program_id = Native.glCreateProgram()
+            
+            Native.glAttachShader(@program_id, @v_shader_id)
+            Native.glAttachShader(@program_id, @f_shader_id)
+            
+            Native.glLinkProgram(@program_id)
+            
+            Shader.link_status(@program_id)
+        end
+        
+        def use_program()
+            Native.glUseProgram(@program_id)
+        end
+        
+        # Splat Operator Aggregates Incoming Parameters And Expands Outgoing Parameters
+        # If method_sym Does Not Accept A Pointer To The Data, Pass nil For data And
+        # Pass In The Normal Parameters Required For The Specific Method.
+        def send_uniform(method_sym, var_name, data = nil, *args)
+            loc = @uniform_locs[var_name] ||= uniform_location(var_name)
+            
+            if data != nil then
+                data_ptr = FFI::MemoryPointer.new(:float, data.size)
+                data_ptr.write_array_of_float(data)
+                
+                RubyGL::Native.send(method_sym, loc, *args, data_ptr)
+            else
+                RubyGL::Native.send(method_sym, loc, *args)
+            end
+        end
+        
+        def attrib_location(var_name)
+            Native.glGetAttribLocation(@program_id, var_name)
+        end
+
+        private
+        def uniform_location(var_name)
+            Native.glGetUniformLocation(@program_id, var_name)
+        end
+        
+        def self.compile_status(shader_id)
+            result = FFI::MemoryPointer.new(:int)
+            Native.glGetShaderiv(shader_id, Native::GL_COMPILE_STATUS, result)
+            
+            if (result.get_int(0) != Native::GL_TRUE) then
+                Native.glGetShaderiv(shader_id, Native::GL_INFO_LOG_LENGTH, result)
+                
+                compile_log = FFI::MemoryPointer.new(:char, result.get_int(0))
+                
+                Native.glGetShaderInfoLog(shader_id, compile_log.total, FFI::MemoryPointer::NULL, compile_log)
+                
+                raise compile_log.read_string_to_null()
+            end
+        end
+        
+        def self.link_status(program_id)
+            result = FFI::MemoryPointer.new(:int)
+            Native.glGetProgramiv(program_id, Native::GL_LINK_STATUS, result)
+            
+            if (result.get_int(0) != Native::GL_TRUE) then
+                Native.glGetProgramiv(program_id, Native::GL_INFO_LOG_LENGTH, result)
+                
+                link_log = FFI::MemoryPointer.new(:char, result.get_int(0))
+                
+                Native.glGetShaderInfoLog(program_id, link_log.total, FFI::MemoryPointer::NULL, link_log)
+
+                raise link_log.read_string_to_null()
+            end
+        end
+    end
+    
+    class ShaderGenerator
+        def self.faceted_shader()
+            Shader.new('''
+                #version 130
+                in vec3 position;
+                out vec3 vPosition;
+                uniform mat4 modelview;
+                uniform mat4 perspective;
+                
+                void main() {
+                    vec4 hPosition = modelview * vec4(position, 1);
+                    vPosition = hPosition.xyz;
+                    
+                    gl_Position = perspective * hPosition;
+                }
+            ''','''
+                #version 130
+                in vec3 vPosition;
+                out vec4 fColor;
+                uniform vec4 color;
+                uniform vec3 light;
+                
+                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);
+                }
+            ''')
+        end
+        
+        def self.color_shader()
+            Shader.new('''
+                #version 130
+                in vec3 position;
+                uniform mat4 modelview;
+                uniform mat4 perspective;
+                
+                void main() {
+                    gl_Position = perspective * modelView * vec4(position, 1);
+                }
+            ''','''
+                #version 130
+                out vec4 fColor;
+                uniform vec4 color;
+                
+                void main() {
+                    fColor = color;
+                }
+            ''')
+        end
+        
+        def self.phong_shader()
+            Shader.new('''
+                #version 130
+                in vec3 position;
+                in vec3 normal;
+                out vec3 vPosition;
+                out vec3 vNormal;
+                uniform mat4 modelview;
+                uniform mat4 perspective;
+                
+                void main() {
+                    vec4 hPosition = modelview * vec4(position, 1);
+                    vPosition = hPosition.xyz;
+                    vNormal = (modelview * vec4(normal, 1)).xyz;
+                    
+                    gl_Position = perspective * hPosition;
+                }
+            ''','''
+                #version 130
+                in vec3 vPosition;
+                in vec3 vNormal;
+                out vec4 fColor;
+                uniform vec4 color;
+                uniform vec3 light;
+                
+                float PhongIntensity(vec3 pos, vec3 norm) {
+                    vec3 N = normalize(norm);
+                    vec3 L = normalize(light - pos);
+                    vec3 E = normalize(pos);
+                    vec3 R = reflect(L, N);
+                    
+                    float diffuse = abs(dot(N, L));
+                    float specular = abs(dot(R, E));
+                    
+                    return clamp(pow(specular, 10) + diffuse, 0, 1);
+                }
+                
+                void main() {
+                    float intensity = PhongIntensity(vPosition, vNormal);
+                    
+                    fColor = vec4(intensity * color.xyz, color.w);
+                }
+            ''')
+        end
+    end
+
+end

data/lib/RubyGL/util.rb

@@ -0,0 +1,77 @@
+
+module RubyGL
+    
+    class Util
+        # Returns the value of the array at the overflow wrapped index value.
+        def self.overflow_wrap(array, index)
+            array[index % array.size]
+        end
+        
+        # Returns [vertices, indices] where vertices is an array of unique vertices
+        # corresponding to the vertices in vertex_array and indices is the zero based
+        # index array that references the unqiue vertices stored in vertices.
+        def self.gen_index_arrays(vertex_array, components)
+            unique_points, point_indices, index_hash = [], [], {}
+            
+            curr_index = 0
+            vertex_array.each_slice(components) { |point|
+                index = index_hash[point]
+                
+                if index then
+                    point_indices.push(index)
+                else
+                    unique_points.push(point)
+                    point_indices.push(curr_index)
+                    
+                    index_hash[point] = curr_index
+                    curr_index += 1
+                end
+            }
+            unique_points.flatten!
+            
+            [unique_points, point_indices]
+        end
+        
+        
+        # Returns an array of vertex normals which is indexable by the indices array.
+        # The components parameter should be the number of components per vertex for
+        # each triangle. 
+        # 
+        # The vertices parameters must contain 3 component vertices or this function 
+        # will not be able to compute appropriate normals.
+        def self.gen_vertex_normals(indices, vertices)
+            normals = Array.new(vertices.size, Vec3.new)
+            
+            indices.each_slice(3) { |i1, i2, i3|
+                # 3 Components Per Vertex (Index References 3 Components)
+                adj_i1, adj_i2, adj_i3 = i1 * 3, i2 * 3, i3 * 3
+                
+                # Construct Triangle Vertices
+                v1 = Vec3.new(vertices[adj_i1..adj_i1 + 2])
+                v2 = Vec3.new(vertices[adj_i2..adj_i2 + 2])
+                v3 = Vec3.new(vertices[adj_i3..adj_i3 + 2])
+                
+                d1 = v2 - v1
+                d2 = v3 - v2
+                
+                normal = d1.cross(d2)
+                normal.norm!
+                
+                normals[i1] += normal
+                normals[i2] += normal
+                normals[i3] += normal
+            }
+            
+            # Normalize All Vectors And Convert From Vec3 To Flat Array
+            normals.map! { |normal_vector|
+                normal_vector.norm!
+                
+                normal_vector.to_a
+            }
+            normals.flatten!
+            
+            normals
+        end
+    end
+    
+end