opengl3 0.0.1.pre1

data/.gitignore

@@ -0,0 +1,21 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.DS_Store
+*~
+*.swp
+.rbx

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in opengl.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 David Lin
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,87 @@
+# 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)
+* Works on OS X 10.8 and Linux (Windows will be supported in the future)
+* Inspired by PyOpenGL
+
+## 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() -> String
+* glGen__Objects__(count) -> Array of Integer
+* glDelete__Objects__(Array of Integer) -> nil
+* glGet__Value__fv(\*args, count) -> Array of Float
+* glGet__Value__iv(\*args, count) -> Array of Integer
+* glGet__Value__uiv(\*args, count) -> Array of Integer
+* glShaderSource(shader, Array of String) -> nil
+* glGetShaderInfoLog(shader) / glGetProgramInfoLog(program) -> String
+* More will be added
+
+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 of Integer
+* glGetShadingLanguageVersion() -> Array of Integer
+* glGetAvailableExtensions() -> Array of String
+* glIsShaderCompiled?(shader) -> boolean
+* glIsProgramLinked?(program) -> boolean
+* More will be added
+
+## 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/Rakefile

@@ -0,0 +1,17 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new :spec do |t|
+  t.libs << "spec"
+  t.pattern = "spec/**/*_spec.rb"
+end
+
+Rake::TestTask.new :test do |t|
+  t.libs << "test"
+  t.pattern = "test/**/*_test.rb"
+end
+
+desc "Open an irb session preloaded with this library"
+task :console do
+  sh "irb -rubygems -I lib -r opengl"
+end

data/examples/math3d.rb

@@ -0,0 +1,65 @@
+require 'matrix'
+
+class Matrix
+  
+  def self.perspective(fovy, aspect, z_near, z_far)
+    f, z_diff = Math.tan(Math::PI * 0.5 - fovy * 0.5), (z_near-z_far)
+    return self[
+      [ f/aspect, 0.0, 0.0, 0.0 ],
+      [ 0.0, f, 0.0, 0.0 ],
+      [ 0.0, 0.0, (z_far+z_near)/z_diff, (2.0*z_far*z_near)/z_diff ],
+      [ 0.0, 0.0, -1.0, 0.0 ]
+    ]
+  end
+  
+  def self.translate(x, y, z)
+    x, y, z = Float(x), Float(y), Float(z)
+    return self[
+      [ 1.0, 0.0, 0.0,   x ],
+      [ 0.0, 1.0, 0.0,   y ],
+      [ 0.0, 0.0, 1.0,   z ],
+      [ 0.0, 0.0, 0.0, 1.0 ]
+    ]
+  end
+  
+  def self.scale(x, y, z)
+    x, y, z = Float(x), Float(y), Float(z)
+    return self[
+      [   x, 0.0, 0.0, 0.0 ],
+      [ 0.0,   y, 0.0, 0.0 ],
+      [ 0.0, 0.0,   z, 0.0 ],
+      [ 0.0, 0.0, 0.0, 1.0 ]
+    ]
+  end
+  
+  def self.rotate_x(angle)
+    c, s = Math.cos(angle), Math.sin(angle)
+    return self[
+      [ 1.0, 0.0, 0.0, 0.0 ],
+      [ 0.0,   c,  -s, 0.0 ],
+      [ 0.0,   s,   c, 0.0 ],
+      [ 0.0, 0.0, 0.0, 1.0 ]
+    ]
+  end
+  
+  def self.rotate_y(angle)
+    c, s = Math.cos(angle), Math.sin(angle)
+    return self[
+      [   c, 0.0,   s, 0.0 ],
+      [ 0.0, 1.0, 0.0, 0.0 ],
+      [  -s, 0.0,   c, 0.0 ],
+      [ 0.0, 0.0, 0.0, 1.0 ]
+    ]
+  end
+  
+  def self.rotate_z(angle)
+    c, s = Math.cos(angle), Math.sin(angle)
+    return self[
+      [   c,  -s, 0.0, 0.0 ],
+      [   s,   c, 0.0, 0.0 ],
+      [ 0.0, 0.0, 1.0, 0.0 ],
+      [ 0.0, 0.0, 0.0, 1.0 ]
+    ]
+  end
+  
+end

data/examples/ogl-2_1-basic.rb

@@ -0,0 +1,107 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'opengl'
+require 'glut'
+
+class TestApp
+  include GLUT
+  include OpenGL::Constants
+  
+  def initialize
+    caps = GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE
+    glutInitDisplayMode(caps)
+    glutInitWindowPosition(300, 200)
+    glutInitWindowSize(512, 512)
+    glutCreateWindow('test')
+    
+    glutDisplayFunc(@draw_method ||= method(:draw)) # prevent from being GCed
+  end
+  
+  def start
+    self.extend OpenGL::GL.entrypoints
+    puts glGetString(GL_VERSION)
+    puts glGetVersion().inspect
+    puts glGetShadingLanguageVersion().inspect
+    puts glGetAvailableExtensions().inspect
+    
+    @quad = begin
+      buffer = glGenBuffers(1)[0]
+      glBindBuffer(GL_ARRAY_BUFFER, buffer)
+      glBufferData(GL_ARRAY_BUFFER, 3 * 4 * 4, nil, GL_STATIC_DRAW)
+      glMapBuffer(GL_ARRAY_BUFFER, GL_WRITE_ONLY) do |ptr|
+        ptr.put_array_of_GLfloat( 0, [-0.5, 0.5, 0.0])
+        ptr.put_array_of_GLfloat(12, [-0.5,-0.5, 0.0])
+        ptr.put_array_of_GLfloat(24, [ 0.5, 0.5, 0.0])
+        ptr.put_array_of_GLfloat(36, [ 0.5,-0.5, 0.0])
+      end
+      
+      buffer
+    end
+    
+    @program = begin
+      vertex_shader = glCreateShader(:vertex)
+      glShaderSource(vertex_shader, VS_CODE)
+      glCompileShader(vertex_shader)
+      unless glIsShaderCompiled?(vertex_shader)
+        msg = glGetShaderInfoLog(vertex_shader)
+        raise RuntimeError, "vertex_shader:\n#{msg}"
+      end
+      
+      fragment_shader = glCreateShader(:fragment)
+      glShaderSource(fragment_shader, FS_CODE)
+      glCompileShader(fragment_shader)
+      unless glIsShaderCompiled?(fragment_shader)
+        msg = glGetShaderInfoLog(fragment_shader)
+        raise RuntimeError, "fragment_shader:\n#{msg}"
+      end
+      
+      program = glCreateProgram()
+      glAttachShader(program, vertex_shader)
+      glAttachShader(program, fragment_shader)
+      glBindAttribLocation(program, 0, "in_Position")
+      glLinkProgram(program)
+      unless glIsProgramLinked?(program)
+        msg = glGetProgramInfoLog(program)
+        raise RuntimeError, "program:\n#{msg}"
+      end
+      glDeleteShader(vertex_shader)
+      glDeleteShader(fragment_shader)
+      program
+    end
+    
+    glutMainLoop()
+  end
+  
+  def draw
+    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
+    
+    glUseProgram(@program)
+    glBindBuffer(GL_ARRAY_BUFFER, @quad)
+    glEnableVertexAttribArray(0)
+    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, nil)
+    glDrawArrays(GL_TRIANGLE_STRIP, 0, 4)
+    
+    glutSwapBuffers()
+  end
+  
+  VS_CODE =<<-GLSL
+attribute vec4 in_Position;
+varying vec2 vs_TexCoord;
+void main()
+{
+  gl_Position = in_Position;
+  vs_TexCoord = in_Position.xy + 0.5;
+}
+  GLSL
+  
+  FS_CODE =<<-GLSL
+varying vec2 vs_TexCoord;
+void main()
+{
+  gl_FragColor = vec4(vs_TexCoord, 0.0, 1.0);
+}
+  GLSL
+  
+end
+
+TestApp.new.start

data/examples/ogl-3_2-basic.rb

@@ -0,0 +1,128 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'opengl'
+require 'glut'
+
+class TestApp
+  include GLUT
+  include OpenGL::Constants
+  
+  def initialize
+    caps = GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE
+    if FFI::Platform.mac?
+      caps |= GLUT_3_2_CORE_PROFILE
+    else
+      glutInitContextVersion(3, 2)
+      glutInitContextProfile(:core)
+    end
+    glutInitDisplayMode(caps)
+    glutInitWindowPosition(300, 200)
+    glutInitWindowSize(512, 512)
+    glutCreateWindow('test')
+    
+    glutDisplayFunc(@draw_method ||= method(:draw)) # prevent from being GCed
+  end
+  
+  def start
+    self.extend OpenGL::GL.entrypoints
+    puts glGetString(GL_VERSION)
+    puts glGetBooleanv(GL_DEPTH_TEST).inspect
+    puts glGetDoublev(GL_COLOR_CLEAR_VALUE, 4).inspect
+    puts glGetFloatv(GL_LINE_WIDTH).inspect
+    puts glGetIntegerv(GL_VIEWPORT, 4).inspect
+    puts glGetVersion().inspect
+    puts glGetShadingLanguageVersion().inspect
+    puts glGetAvailableExtensions().inspect
+    
+    @quad = begin
+      buffer = glGenBuffers(1)[0]
+      glBindBuffer(GL_ARRAY_BUFFER, buffer)
+      glBufferData(GL_ARRAY_BUFFER, 3 * 4 * 4, nil, GL_STATIC_DRAW)
+      glMapBuffer(GL_ARRAY_BUFFER, GL_WRITE_ONLY) do |ptr|
+        ptr.put_array_of_GLfloat( 0, [-0.5, 0.5, 0.0])
+        ptr.put_array_of_GLfloat(12, [-0.5,-0.5, 0.0])
+        ptr.put_array_of_GLfloat(24, [ 0.5, 0.5, 0.0])
+        ptr.put_array_of_GLfloat(36, [ 0.5,-0.5, 0.0])
+      end
+      
+      array = glGenVertexArrays(1)[0]
+      glBindVertexArray(array)
+      glBindBuffer(GL_ARRAY_BUFFER, buffer)
+      glEnableVertexAttribArray(0)
+      glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, nil)
+      
+      glBindVertexArray(0)
+      glBindBuffer(GL_ARRAY_BUFFER, 0)
+      
+      array
+    end
+    
+    @program = begin
+      vertex_shader = glCreateShader(:vertex)
+      glShaderSource(vertex_shader, VS_CODE)
+      glCompileShader(vertex_shader)
+      unless glIsShaderCompiled?(vertex_shader)
+        msg = glGetShaderInfoLog(vertex_shader)
+        raise RuntimeError, "vertex_shader:\n#{msg}"
+      end
+      
+      fragment_shader = glCreateShader(:fragment)
+      glShaderSource(fragment_shader, FS_CODE)
+      glCompileShader(fragment_shader)
+      unless glIsShaderCompiled?(fragment_shader)
+        msg = glGetShaderInfoLog(fragment_shader)
+        raise RuntimeError, "fragment_shader:\n#{msg}"
+      end
+      
+      program = glCreateProgram()
+      glAttachShader(program, vertex_shader)
+      glAttachShader(program, fragment_shader)
+      glBindAttribLocation(program, 0, "in_Position")
+      glBindFragDataLocation(program, 0, "fs_FragColor")
+      glLinkProgram(program)
+      unless glIsProgramLinked?(program)
+        msg = glGetProgramInfoLog(program)
+        raise RuntimeError, "program:\n#{msg}"
+      end
+      glDeleteShader(vertex_shader)
+      glDeleteShader(fragment_shader)
+      program
+    end
+    
+    glutMainLoop()
+  end
+  
+  def draw
+    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
+    
+    glUseProgram(@program)
+    glBindVertexArray(@quad)
+    glDrawArrays(GL_TRIANGLE_STRIP, 0, 4)
+    
+    glutSwapBuffers()
+  end
+  
+  VS_CODE =<<-GLSL
+#version 150 core
+in vec4 in_Position;
+out vec2 vs_TexCoord;
+void main()
+{
+  gl_Position = in_Position;
+  vs_TexCoord = in_Position.xy + 0.5;
+}
+  GLSL
+  
+  FS_CODE =<<-GLSL
+#version 150 core
+in vec2 vs_TexCoord;
+out vec4 fs_FragColor;
+void main()
+{
+  fs_FragColor = vec4(vs_TexCoord, 0.0, 1.0);
+}
+  GLSL
+  
+end
+
+TestApp.new.start