opengl3 0.0.1.pre4 → 0.0.1.pre5

data/README.md

@@ -0,0 +1,115 @@
+# OpenGL (opengl3)
+
+OpenGL wrapper library for Ruby
+
+* Pure Ruby, no C/C++/Java extension included (thanks to ffi gem)
+* OpenGL 2.1 ~ 4.2
+* automatic error checking each function call
+* Ruby-style wrapper (not complete)
+* Inspired by PyOpenGL
+
+Tested on
+
+* Mac OS X 10.8 (MRI 1.9.3, Rubinius)
+* Linux (MRI 1.9.3, JRuby 1.7, Rubinius)
+* Windows (JRuby 1.7)
+
+## Notice
+
+Since the project is not complete, many functions are still C-style.
+But don't worry, the gem makes use of `ffi` gem to import functions, and 
+therefore you can use ffi objects like `FFI::MemoryPointer` to work 
+with C-style OpenGL entrypoints.
+
+## Ruby-Style OpenGL APIs
+
+Please take a look at `lib/opengl/wrapper/**/*.rb`
+to see if entrypoints are wrapped.
+
+
+
+* `glGetString(pname)` -> `String`
+* `glGen...`-like functions
+  - `glGenTextures(count)` -> `Array<Integer>`
+  - `glGenBuffers(count)` -> `Array<Integer>`
+  - and more ...
+* `glDelete...`-like functions
+  - `glDeleteTextures(Array<Integer>)`
+  - `glDeleteBuffers(Array<Integer>)`
+  - and more ...
+* `glGet...`-like functions
+  - `glGetIntegerv(pname, count)` -> `Array<Integer>`
+  - `glGetFloatv(pname, count)` -> `Array<Float>`
+  - `glGetTexParameteriv(target, pname, count)` -> `Array<Integer>`
+  - `glGetTexParameterfv(target, pname, count)` -> `Array<Float>`
+  - `glGetShaderiv(shader, pname, count)` -> `Array<Integer>`
+  - and more ...
+* `glShaderSource(shader, Array<String>)`
+* `glGetShaderInfoLog(shader)` -> `String`
+* `glGetProgramInfoLog(program)` -> `String`
+* More Ruby-style functions coming soon
+
+block-style glMapBuffer / glMapBufferRange:
+
+```ruby
+glMapBuffer(GL_ARRAY_BUFFER, GL_WRITE_ONLY) do |ptr|
+  ptr.put_array_of_GLfloat(offset_in_bytes, [ 1.0, 2.0, 3.0 ])
+end
+```
+
+And helper functions
+
+* `glGetVersion()` -> `Array<Integer>`
+* `glGetShadingLanguageVersion()` -> `Array<Integer>`
+* `glGetAvailableExtensions()` -> `Array<String>`
+* `glIsShaderCompiled?(shader)` -> `Boolean`
+* `glIsProgramLinked?(program)` -> `Boolean`
+* `glUniformMatrixf(location, Matrix, transpose = true)` (Experimental)
+* More helper functions coming soon
+
+Note for functions has a offset with GLvoid* type
+(ex: `glDrawElements`, `glVertexAttribPointer`)
+
+```ruby
+offset_in_bytes = 0
+glVertexAttribPointer 0, 3, GL_FLOAT, GL_FALSE, 0,
+                      OpenGL::Type.pointer_offset(offset_in_bytes)
+```
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'opengl3', :require => 'opengl'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install opengl3
+
+## Usage
+
+```ruby
+require 'opengl'
+class App
+  include OpenGL::Constants
+  
+  def initialize
+    # ... (window created)
+    self.extend OpenGL::GL.entrypoints
+    # OK, you can use OpenGL now
+  end
+  
+end
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/lib/opengl/version.rb

@@ -1,3 +1,3 @@
 module OpenGL
-  VERSION = "0.0.1.pre4"
+  VERSION = "0.0.1.pre5"
 end

data/lib/opengl/wrapper/core/2_x/GL_VERSION_2_0.rb

@@ -77,7 +77,9 @@ module OpenGL
     # @param [String, Array<String>] codes
     #
     def glShaderSource(shader, codes)
-      pointers = Array(codes).map{|s| FFI::MemoryPointer.from_string(s) }
+      pointers = Array(codes).map{|s|
+        s.is_a?(FFI::Pointer) ? s : FFI::MemoryPointer.from_string(s)
+      }
       ptr = FFI::MemoryPointer.new(:pointer, pointers.count)
       ptr.write_array_of_pointer(pointers)
       super(shader, pointers.count, ptr, nil)
@@ -101,5 +103,25 @@ module OpenGL
       glGetProgramiv(program, Constants::GL_LINK_STATUS, 1)[0] != 0
     end
     
+    # a variant of glUniformMatrix*fv
+    #
+    # @param [GLint] location
+    # @param [Matrix] matrix
+    # @param [Boolean] transpose
+    #
+    def glUniformMatrixf(location, mat, transpose = true)
+      transpose = (transpose ? Constants::GL_TRUE : Constants::GL_FALSE)
+      
+      # TODO: refactor it
+      if defined?(::Matrix) && mat.is_a?(::Matrix)
+        m, n = mat.row_size, mat.column_size
+        dim = (m == n ? "#{m}" : "#{n}x#{m}")
+        
+        ptr = Type.GLfloat(m*n).write_array_of_GLfloat(mat.to_a.flatten)
+      end
+      
+      send(:"glUniformMatrix#{dim}fv", location, 1, transpose, ptr)
+    end
+    
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: opengl3
 version: !ruby/object:Gem::Version
-  version: 0.0.1.pre4
+  version: 0.0.1.pre5
   prerelease: 6
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-01-12 00:00:00.000000000 Z
+date: 2013-01-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -248,6 +248,7 @@ files:
 - lib/opengl/wrapper/core/4_2/GL_VERSION_4_2.rb
 - lib/opengl/wrapper.rb
 - lib/opengl.rb
+- README.md
 homepage: https://github.com/davll/ruby-opengl
 licenses: []
 post_install_message: