rubygl 0.1.0 → 0.2.1

data/lib/{RubyGL → rubygl}/shader.rb

@@ -1,203 +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
+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 → rubygl}/util.rb

@@ -1,77 +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
+
+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

data/lib/rubygl.rb

@@ -1,48 +1,49 @@
-require 'ffi'
-require 'rbconfig'
-
-# 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
-
-def relative_path(resource_path)
-    File.join(File.dirname(File.expand_path(__FILE__)), resource_path)
-end
-
-# Initialize All Modules
-module RubyGL
-    module Native
-        extend FFI::Library
-        ffi_lib relative_path("../ext/#{os.to_s}/SDL2.dll")
-        ffi_lib relative_path("../ext/#{os.to_s}/RubyGL.so")
-    end
-end
-
-# Load Module Code
-require_relative './rubygl/geometry'
-require_relative './rubygl/math'
-require_relative './rubygl/memory'
-require_relative './rubygl/setup'
-require_relative './rubygl/shader'
-require_relative './rubygl/util'
-
-require_relative './rubygl/native/window'
-require_relative './rubygl/native/glcontext'
-require_relative './rubygl/native/input'
-require_relative './rubygl/native/opengl'
+require 'ffi'
+require 'rbconfig'
+
+# 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
+
+def relative_path(resource_path)
+    File.join(File.dirname(File.expand_path(__FILE__)), resource_path)
+end
+
+# Initialize All Modules
+module RubyGL
+    module Native
+        extend FFI::Library
+        ffi_lib relative_path("../ext/#{os.to_s}/SDL2.dll")
+        ffi_lib relative_path("../ext/#{os.to_s}/RubyGL.so")
+    end
+end
+
+# Load Module Code
+require_relative './rubygl/event'
+require_relative './rubygl/geometry'
+require_relative './rubygl/math'
+require_relative './rubygl/memory'
+require_relative './rubygl/setup'
+require_relative './rubygl/shader'
+require_relative './rubygl/util'
+
+require_relative './rubygl/native/window'
+require_relative './rubygl/native/glcontext'
+require_relative './rubygl/native/input'
+require_relative './rubygl/native/opengl'