rbglox 0.1.0

data/LICENSE

@@ -0,0 +1,21 @@
+THE MIT LICENSE
+
+Copyright (c) 2011, Mihail Szabolcs
+
+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,184 @@
+rbGLox
+======
+rbGLox is a small wrapper over the ruby-opengl, ruby-glfw family by abstracting 
+and providing some high-level interfaces for things like "Textures",
+"GLSL Shaders", basic "Geometry" and others.
+
+It's ideal for rapid prototyping new and interesting ideas.
+
+rbGLox is the sister project of [pyGLox](http://github.com/icebreaker/pyGLox).
+
+Dependencies
+------------
+* [ruby-opengl](https://rubygems.org/gems/ruby-opengl)
+* [ruby-glfw](https://rubygems.org/gems/ruby-glfw)
+* [directory-watcher](https://rubygems.org/gems/directory_watcher)
+
+Getting Started
+---------------
+
+### Install
+
+	gem install rbglox
+
+### Library
+
+Using rbGLox as a library is a very easy :)
+
+	```ruby
+	require 'rbglox'
+	class DemoApp < RBGLox::App
+  		def init
+    		@texture = RBGLox::Texture.new 'mosaic.tga'
+    		@r = 0.0 
+    		@cube = RBGLox::MeshCube.new
+  		end
+  		def update
+  			@r += 0.1
+  		end
+	  	def draw
+    		glTranslatef 0.0,0.0,-6.0
+    		glRotatef @r, 1.0, 1.0, 1.0
+    		
+    		@texture.bind
+	    	@cube.draw
+	  	  	@texture.release
+  	  	end
+	 	def shutdown
+    		@texture.free
+    		@cube.free
+  		end 
+	end
+	```
+	
+Now let's fire this up :)
+
+	```ruby
+	DemoApp.new do |app|
+  		app.title = 'DemoApp'
+  		app.exec
+	end
+	```
+	
+Additional methods you can override:
+
+	```ruby
+	resize(h, w)
+	begin_frame
+	end_frame
+	reload(event)
+	```
+	
+#### Semi-automatic resource re-loading
+
+	```ruby
+	DemoApp.new do |app|
+		app.watch = 'data/'
+  		app.title = 'DemoApp'
+  		app.exec
+	end
+	```
+If the `watch` variable is not `nil` then the given directory will be watched
+for any changes. (i.e file modified, file created, etc)
+
+Every time a change is detected, the `reload(event)` method is called and you can
+reload your resources.
+
+The included `RBGLox::Texture` and `RBGLox::Shader` classes have a `reload` method 
+which facilitates this as illustrated in the example below.
+
+	```ruby
+	...
+	def reload(event)
+		if event.type == :modified
+			texture1.reload if event.path =~ /myawesometexture.tga$/
+			shader.reload if event.path =~ /myshader.glsl$/
+			...
+		end
+		...
+	end
+	...
+	```
+	
+### Executable
+
+It is also possible to use rbGLox as a cheap & rudimentary "GLSL" shader editor.
+
+In order to create a new project do the following:
+
+	mkdir glsl-demo
+	cd glsl-demo
+	rbglox --init
+	
+This will create an empty project with one shader and one texture.
+
+To launch "editor" just type `rbglox` in the current directory and there you go.
+
+#### Watcher
+
+All the resources in the current directory are "watched" for changes and will be
+reloaded automatically when a change is detected.
+
+So, if you edit the shaders or the textures they will be reloaded for you without
+restarting the "editor".
+
+#### Shaders
+
+The shader file has the following format:
+
+	[vertex]
+	...
+	[end]
+	
+	[fragment]
+	...
+	[end]
+	
+	[uniforms]
+	...
+	[end]
+	
+Please consult the generated `default shader` when you start a "new project" for 
+more details.
+
+The shader must be named `shader.glsl` in order to be used and loaded.
+
+
+#### Textures
+
+Only textures in the TGA format are supported and they are going to be loaded
+in alphabetical order. If there are more than 4 textures, only the first 4
+will be loaded and assigned to the first 4 available texture units.
+
+The textures must be named in the following format: `textureN.tga` where `N`
+is a number ranging from 1 to 4.
+
+#### Models (a.k.a Meshes)
+
+You can choose between a Quad, a Cube (a.k.a Box) and a Teapot. The default is
+the Teapot.
+
+	rbglox --model teapot
+	
+#### Controls
+
+* Hold down the left mouse button and move the mouse in order to rotate the model.
+* Use the mouse wheel to zoom in / zoom out the model.
+
+rbMedia
+-------
+The bundled texture is from [lovetextures.com](http://lovetextures.com) .
+
+Contribute
+----------
+* Fork the project.
+* Make your feature addition or bug fix.
+* Send me a pull request. Bonus points for topic branches.
+* Do **not** bump the version number.
+
+License
+-------
+Copyright (c) 2011, Mihail Szabolcs
+
+rbGLox is provided as-is under the **MIT** license. For more information 
+see *LICENSE* .

data/bin/rbglox

@@ -0,0 +1,85 @@
+#!/usr/bin/env ruby
+
+$:.unshift File.join(File.dirname(__FILE__), *%w[.. lib])
+
+require 'rbglox'
+require 'optparse'
+require 'ftools'
+
+help = <<HELP
+RBGLox v#{RBGLox::VERSION}
+
+usage: rbglox [options]
+
+Examples:
+	rbglox --init
+	rbglox --model=teapot
+	rbglox --title="My GLSL Demo"
+
+Models:
+	quad, cube, teapot
+	
+Options:
+HELP
+
+options = 
+{
+	'model' => 'teapot',
+	'title' => "RBGLox v#{RBGLox::VERSION}"
+}
+opts = OptionParser.new do |opts|
+	opts.banner = help
+	
+	opts.on('--init', 'create an empty project in the current directory') do
+		options['init'] = true
+	end
+	
+	opts.on('--model [model]', 'specify sample model') do |model|
+		if ['quad', 'cube', 'box', 'teapot'].include? model
+			options['model'] = model
+		end
+	end
+
+	opts.on('--title [title]', 'specify window title') do |title|
+		options['title'] = title
+	end
+	
+	opts.on('--version', 'show version information') do
+		puts RBGLox::VERSION
+		exit 0
+	end
+end
+
+begin
+	opts.parse!
+rescue OptionParser::InvalidOption => e
+	puts e.message
+	exit 1
+end
+
+def init(src, dst)
+	puts 'Copying shader ...'
+	File.copy(File.join(src, 'res/shader.glsl'), File.join(dst, 'shader.glsl'))
+	puts 'Copying texture ...'
+	File.copy(File.join(src, 'res/texture.tga'), File.join(dst, 'texture1.tga'))
+	puts 'Now run `rbglox` and enjoy :)'
+	0
+end
+
+exit init(File.dirname(File.dirname(__FILE__)), Dir.getwd) unless options['init'].nil?
+
+unless File.exists?(File.join(Dir.getwd, 'shader.glsl'))
+	puts 'Error. No `shader.glsl` found in the current directory.'
+	exit 1
+end
+
+unless File.exists?(File.join(Dir.getwd, 'texture1.tga'))
+	puts 'Warning. No `texture1.tga` found in the current directory.'
+end
+
+ShaderApp.new do |app|
+  app.title = options['title']
+  app.model = options['model']
+  app.watch = Dir.getwd
+  app.exec
+end

data/lib/rbglox.rb

@@ -0,0 +1,126 @@
+require 'gl'
+require 'glu'
+require 'glut'
+require 'glfw'
+require 'directory_watcher'
+
+module RBGLox
+  class RBGLoxException < StandardError; end
+end
+
+require 'rbglox/version'
+require 'rbglox/window'
+require 'rbglox/resource'
+require 'rbglox/texture'
+require 'rbglox/shader'
+require 'rbglox/mesh'
+require 'rbglox/meshquad'
+require 'rbglox/meshcube'
+require 'rbglox/app'
+
+class ShaderApp < RBGLox::App
+  attr_accessor :model
+
+  def init
+    @textures = []
+    (1..4).each do |i|
+      filename = File.join watch, "texture#{i}.tga"
+      @textures << RBGLox::Texture.new(filename) if File.exists? filename
+    end
+    
+    @shader = RBGLox::Shader.new File.join watch, "shader.glsl"
+
+    @z = -6.0
+    if model == 'quad'
+      @model = RBGLox::MeshQuad.new
+    elsif ['cube', 'box'].include? model
+      @model = RBGLox::MeshCube.new
+    else
+      @model = nil
+      @z = -30.0
+    end
+
+    @lastX = 0
+    @lastY = 0
+    @lastM = 0
+
+    @rotX = 0.0
+    @rotY = 0.0
+    @rotZ = 0.0
+  end
+
+  def update
+    currM = mouse_wheel?
+
+    if currM != 0
+      @z -= (@lastM - currM)
+      @lastM = currM
+    end
+
+    if mouse_left?
+      currX, currY = mouse_pos?
+
+      if @lastX > 0 and @lastY > 0
+        @rotX += (currY - @lastY)
+        @rotY += (currX - @lastX)
+      end
+
+      @lastX = currX
+      @lastY = currY
+    else
+      @lastX = 0
+      @lastY = 0
+    end
+
+  end
+
+  def draw
+    glTranslatef(0,0, @z)
+    glRotatef(@rotX, 1.0, 0.0, 0.0)
+    glRotatef(@rotY, 0.0, 1.0, 0.0)
+    glRotatef(@rotZ, 0.0, 0.0, 1.0)
+
+    @textures.each_with_index do |texture, i|
+      texture.bind i
+    end
+    
+    @shader.bind
+    @shader['time'] = time.to_f
+    
+    if @model.nil?
+      glutSolidTeapot(8.0)
+    else
+      @model.draw
+    end
+
+    @shader.release
+
+    @textures.each_with_index do |texture, i|
+      texture.release i
+    end
+  end
+
+  def shutdown
+    @textures.each do |texture|
+      texture.free
+    end
+    @shader.free
+    @model.free unless @model.nil?
+  end
+
+  def reload(event)
+    if event.type == :modified
+      puts "reloading #{event.path} ..."
+      if event.path =~ /\.glsl$/i
+        @shader.reload
+      elsif event.path =~ /\.tga$/i
+        @textures.each_with_index do |texture, i|
+          if texture.filename == event.path
+            texture.reload i
+            break
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rbglox/app.rb

@@ -0,0 +1,9 @@
+# Semi-abstract Application Class
+class RBGLox::App < RBGLox::Window
+  # Constructor
+  def initialize
+    super
+    yield self
+  end
+end
+

data/lib/rbglox/mesh.rb

@@ -0,0 +1,36 @@
+# Semi-abstract Mesh Class
+class RBGLox::Mesh < RBGLox::Resource
+  include Gl
+ 
+  # Constructor
+  def initialize(verts, texs, norms, tris)
+    @id = glGenLists 1
+  
+    glNewList id, GL_COMPILE
+      glPushClientAttrib GL_CLIENT_VERTEX_ARRAY_BIT
+  		glEnableClientState GL_VERTEX_ARRAY
+	  	glEnableClientState GL_TEXTURE_COORD_ARRAY
+		  glEnableClientState GL_NORMAL_ARRAY
+		  glVertexPointer 3, GL_FLOAT, 0, verts
+		  glNormalPointer GL_FLOAT, 0, norms
+      glTexCoordPointer 2, GL_FLOAT, 0, texs
+  		glDrawElements GL_TRIANGLES, tris.size, GL_UNSIGNED_INT, tris
+      glPopClientAttrib
+    glEndList
+  end
+
+  # Draw the mesh by calling the internal display list
+  def draw
+    glCallList id
+  end
+
+  # Reload the mesh
+  def reload
+    # do nothing
+  end
+
+  # Free the mesh by destroying the internal display list
+  def free
+    glDeleteLists id, 1
+  end
+end

data/lib/rbglox/meshcube.rb

@@ -0,0 +1,99 @@
+# Cube Mesh Class
+class RBGLox::MeshCube < RBGLox::Mesh
+  # Constructor
+  def initialize(x=1.0, y=1.0, z=1.0, tx=0.0, ty=0.0, tz=0.0)
+		verts = [
+		-x + tx, -y + ty, -z + tz,
+		 x + tx, -y + ty, -z + tz,
+		 x + tx,  y + ty, -z + tz,
+		-x + tx,  y + ty, -z + tz,
+		-x + tx, -y + ty,  z + tz,
+		-x + tx,  y + ty,  z + tz,
+		 x + tx,  y + ty,  z + tz,
+		 x + tx, -y + ty,  z + tz,
+		-x + tx, -y + ty, -z + tz,
+		-x + tx,  y + ty, -z + tz,
+		-x + tx,  y + ty,  z + tz,
+		-x + tx, -y + ty,  z + tz,
+		 x + tx, -y + ty, -z + tz,
+		 x + tx, -y + ty,  z + tz,
+		 x + tx,  y + ty,  z + tz,
+		 x + tx,  y + ty, -z + tz,
+		-x + tx,  y + ty, -z + tz,
+		 x + tx,  y + ty, -z + tz,
+		 x + tx,  y + ty,  z + tz,
+		-x + tx,  y + ty,  z + tz,
+		-x + tx, -y + ty, -z + tz,
+		-x + tx, -y + ty,  z + tz,
+		 x + tx, -y + ty,  z + tz,
+		 x + tx, -y + ty, -z + tz]
+
+		norms = [
+		 0,  0, -1,
+		 0,  0, -1,
+		 0,  0, -1,
+		 0,  0, -1,
+		 0,  0,  1,
+		 0,  0,  1,
+		 0,  0,  1,
+		 0,  0,  1,
+		-1,  0,  0,
+		-1,  0,  0,
+		-1,  0,  0,
+		-1,  0,  0,
+		 1,  0,  0,
+		 1,  0,  0,
+		 1,  0,  0,
+		 1,  0,  0,
+		 0,  1,  0,
+		 0,  1,  0,
+		 0,  1,  0,
+		 0,  1,  0,
+		 0, -1,  0,
+		 0, -1,  0,
+		 0, -1,  0,
+		 0, -1,  0 ]
+
+		texs = [
+		0, 0,	# 0
+		1, 0,	# 1
+		1, 1,	# 2
+		0, 1,	# 3
+		1, 0,	# 4
+		1, 1,	# 5
+		0, 1,	# 6
+		0, 0,	# 7
+		1, 0,	# 8
+		1, 1,	# 9
+		0, 1,	# 10
+		0, 0,	# 11
+		0, 0,	# 12
+		1, 0,	# 13
+		1, 1,	# 14
+		0, 1,	# 15
+		0, 0,	# 16
+		1, 0,	# 17
+		1, 1,	# 18
+		0, 1,	# 19
+		0, 1,	# 20
+		0, 0,	# 21
+		1, 0,	# 22
+		1, 1 ]	# 23
+
+		tris = [
+		0,	 2,  1,
+		0,	 3,  2,
+		4,	 6,  5,
+		4,	 7,  6,
+		8,	10,  9,
+		8,	11, 10,
+		12, 14, 13,
+		12, 15, 14,
+		16, 18, 17,
+		16, 19, 18,
+		20, 22, 21,
+		20, 23, 22 ]
+
+    super verts, texs, norms, tris
+  end
+end

data/lib/rbglox/meshquad.rb

@@ -0,0 +1,29 @@
+# Quad Mesh Class
+class RBGLox::MeshQuad < RBGLox::Mesh
+  # Constructor
+  def initialize(x=1.0, y=1.0)
+		verts = [
+      -x, -y, 0.0,
+       x, -y, 0.0,
+       x,  y, 0.0,
+      -x,  y, 0.0 ]
+
+    texs = [
+      0.0, 0.0,
+      1.0, 0.0,
+      1.0, 1.0,
+      0.0, 1.0 ]
+    
+    norms = [
+      0.0, 0.0, 1.0,
+      0.0, 0.0, 1.0,
+      0.0, 0.0, 1.0,
+      0.0, 0.0, 1.0 ]
+
+		tris = [
+			3, 2, 1,
+			3, 1, 0 ]
+
+    super verts, texs, norms, tris
+  end
+end

data/lib/rbglox/resource.rb

@@ -0,0 +1,14 @@
+# Abstract Resource Class
+class RBGLox::Resource
+  attr_reader :id
+
+  # Reload resource
+  def reload
+    raise NotImplementedError
+  end
+
+  # Free resource
+  def free
+    raise NotImplementedError
+  end
+end

data/lib/rbglox/shader.rb

@@ -0,0 +1,115 @@
+# GLSL Shader Class
+class RBGLox::Shader < RBGLox::Resource
+  include Gl
+
+  attr_reader :filename, :vertex, :fragment, :uniforms
+
+  # Constructor
+  def initialize(filename)
+    @filename = filename
+    @id = glCreateProgram
+
+		@vertex = glCreateShader GL_VERTEX_SHADER
+    glAttachShader id, vertex
+
+    @fragment = glCreateShader GL_FRAGMENT_SHADER
+    glAttachShader id, fragment
+
+    @uniforms = []
+
+    reload
+  end
+
+  # Set internal GLSL uniforms
+  def []=(name, value)
+    loc = glGetUniformLocation id, name
+    if value.is_a? Float
+      glUniform1f loc, value
+    elsif value.is_a? Integer
+      glUniform1i loc, value
+    elsif value.is_a? Array
+      l = value.size
+    	if l == 2
+				glUniform2fv loc, value
+			elsif l == 3:
+				glUniform3fv loc, value
+			elsif l == 4:
+				glUniform4fv loc, value
+      end
+    else
+      raise TypeError.new('Uniform type not supported')
+    end
+  end
+
+  # Bind the Shader
+  def bind
+    glUseProgram id
+    
+    uniforms.each do |k, v|
+      self[k] = v
+    end
+  end
+
+  # Release the Shader
+  def release
+    glUseProgram 0
+  end
+
+  # Reload the Shader
+  def reload
+    content = File.read filename
+    vert, frag, unis = parse content
+
+    glShaderSource vertex, vert
+    glCompileShader vertex
+    log = glGetShaderInfoLog vertex
+    puts log
+
+    return if log =~ /error/i
+
+    glShaderSource fragment, frag
+    glCompileShader fragment
+    log = glGetShaderInfoLog fragment
+    puts log
+
+    return if log =~ /error/i
+
+		glLinkProgram id
+    log = glGetProgramInfoLog id
+    puts log
+
+    return if log =~ /error/i
+
+    @uniforms = unis
+  end
+
+  # Free the Shader
+  def free
+    glDetachShader id, vertex
+    glDeleteShader vertex
+
+    glDetachShader id, fragment
+    glDeleteShader fragment
+
+    glDeleteProgram id
+  end
+
+  protected
+
+  # Parse the Shader file and extract the Vertex and Fragment shaders
+  def parse(content)
+    source = []
+
+    matches = content.scan(/\[(vertex|fragment|uniforms)\]\s?(.*?\s?)\s?\[end\]/m)
+    matches.each do |m|
+      if ["vertex", "fragment"].include?(m[0])
+        source.push(m[1])
+      elsif m[0] == "uniforms"
+        source.push(YAML.load(m[1]))
+      end
+    end
+    
+    source
+  end
+
+end

data/lib/rbglox/texture.rb

@@ -0,0 +1,52 @@
+# Texture Class
+class RBGLox::Texture < RBGLox::Resource
+  include Glfw
+  include Gl
+
+  attr_accessor :filename, :mipmaps
+
+  # Constructor
+  def initialize(filename, mipmaps=false)
+    @filename = filename
+    @mipmaps = mipmaps
+    @id = glGenTextures(1)[0]
+
+    reload
+  end
+
+  # Bind the Texture
+  def bind(unit=0)
+    glActiveTexture(GL_TEXTURE0 + unit)
+    glBindTexture GL_TEXTURE_2D, id
+  end
+
+  # Release the Texture
+  def release(unit=0)
+    glActiveTexture(GL_TEXTURE0 + unit)
+    glBindTexture GL_TEXTURE_2D, 0
+  end
+
+  # Reload the Texture
+  def reload(unit=0)
+    bind unit
+
+    glTexParameteri GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE
+    glTexParameteri GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE
+    glTexParameteri GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR
+    glTexParameteri GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR
+
+    if mipmaps:
+      glTexParameteri GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST
+      glfwLoadTexture2D filename, GLFW_BUILD_MIPMAPS_BIT
+    else
+      glfwLoadTexture2D filename, 0
+    end
+
+    release unit
+  end
+
+  # Free the Texture
+  def free
+    glDeleteTextures [id]
+  end
+end

data/lib/rbglox/version.rb

@@ -0,0 +1,3 @@
+module RBGLox
+  VERSION = '0.1.0'
+end

data/lib/rbglox/window.rb

@@ -0,0 +1,172 @@
+# Semi-abstract Window class
+class RBGLox::Window
+  include Glfw
+  include Gl
+  include Glu
+  include Glut
+
+  attr_accessor :title, :width, :height, :multisample, :vsync, :watch
+
+  # Constructor
+  def initialize
+    @title = 'rbGLox'
+    @width = 640
+    @height= 480
+    @multisample = 0
+    @vsync = 0
+    @watch = nil
+  end
+
+  # Closes the currently active open window
+  def close
+    glfwCloseWindow
+  end
+
+  # Returns TRUE if the given key is PRESSED, otherwise FALSE
+  def key?(key)
+    glfwGetKey(key) == GLFW_PRESS
+  end
+
+  # Returns TRUE if the given mouse button is PRESSED, otherwise FALSE
+  def mouse?(button = GLFW_MOUSE_BUTTON_LEFT)
+    glfwGetMouseButton(button) == GLFW_PRESS
+  end
+
+  # Return TRUE if the left mouse button is PRESSED, otherwise FALSE
+  def mouse_left?
+    mouse?
+  end
+
+  # Return TRUE if the right mouse button is PRESSED, otherwise FALSE
+  def mouse_right?
+    mouse? GLFW_MOUSE_BUTTON_RIGHT
+  end
+
+  # Returns the current mouse position (tuple)
+  def mouse_pos?
+    glfwGetMousePos
+  end
+
+  # Returns the current mouse wheel delta position
+  def mouse_wheel?
+    glfwGetMouseWheel
+  end
+
+  # Returns the current tick count
+  def time
+    glfwGetTime
+  end
+
+  # Opens the window and fires up the event loop
+  def exec
+    glutInit
+
+    glfwOpenWindowHint GLFW_WINDOW_NO_RESIZE, true
+    #glfwOpenWindowHint GLFW_FSAA_SAMPLE, multisample
+ 
+    glfwOpenWindow width, height, 0, 0, 0, 0, 32, 0, GLFW_WINDOW
+
+    glfwSetWindowPos 0, 0
+    glfwSetWindowTitle title
+    glfwEnable GLFW_KEY_REPEAT
+    glfwSwapInterval vsync
+
+    glfwSetWindowSizeCallback lambda { |w, h| resize(w, h) }
+
+    trap('INT') do
+      glfwCloseWindow
+    end
+
+    unless watch.nil?
+      puts "Watching #{watch} for changes ..."
+      dw = DirectoryWatcher.new watch, :glob => "**/*", :pre_load => true, :interval => 1
+      dw.add_observer do |*args|
+        args.each do |event|
+          reload event
+        end
+      end
+      dw.start
+    end
+
+    glClearColor 0.2, 0.2, 0.2, 1
+		glClearDepth 1.0
+		
+    glEnable GL_DEPTH_TEST
+		glDepthFunc GL_LEQUAL 
+	
+    glShadeModel GL_SMOOTH
+    glHint GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST
+
+    glEnable GL_TEXTURE_2D
+		glEnable GL_COLOR_MATERIAL
+		glEnable GL_NORMALIZE
+
+    puts 'init'
+    init
+
+    while true
+      break unless glfwGetWindowParam GLFW_OPENED
+      break if key? GLFW_KEY_ESC
+      
+      update
+
+      begin_frame
+        draw
+      end_frame
+    end
+
+    unless watch.nil?
+      dw.stop
+    end
+
+    shutdown
+    puts 'shutdown'
+  end
+
+  # User defined initializations
+  def init
+  end
+
+  # User defined shutdown
+  def shutdown
+  end
+
+  # User defined window resize, sets up viewport and perspective projection
+  def resize(w, h)
+    glViewport 0, 0, w, h
+	
+		glMatrixMode GL_PROJECTION
+		glLoadIdentity
+	
+		gluPerspective 45.0, w.to_f/h.to_f, 0.1, 1000.0
+	
+		glMatrixMode GL_MODELVIEW
+		glLoadIdentity
+  end
+
+  # User defined method called when entering a frame
+  def begin_frame
+    glClear GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT
+    glLoadIdentity
+  end
+
+  # User defined method called when leaving the frame
+  def end_frame
+    glfwSwapBuffers
+  end
+
+  # User defined draw method
+  def draw
+     raise NotImplementedError
+  end
+
+  # User defined update method
+  def update
+    # empty
+  end
+
+  # User defined reload event method
+  def reload(event)
+    # empty
+  end
+end

data/res/shader.glsl

@@ -0,0 +1,35 @@
+[vertex]
+uniform float time;
+	
+void main()
+{
+	gl_FrontColor = gl_Color;
+	gl_TexCoord[0] = gl_MultiTexCoord0;
+	gl_Position = ftransform();
+}
+[end]
+
+[fragment]
+uniform float time;
+uniform float offset;
+uniform vec2 discardOffset;
+uniform sampler2D tex0;
+uniform sampler2D tex1;
+uniform sampler2D tex2;
+uniform sampler2D tex3;
+	
+void main()
+{
+	vec2 st = gl_TexCoord[0].st;
+
+	if(st.t < discardOffset[0] || st.s < discardOffset[1]) 
+		discard;
+
+	gl_FragColor = texture2D(tex0, st * offset);
+}
+[end]
+
+[uniforms]
+discardOffset: [0.1, 0.1]
+offset: 0.3
+[end]

data/test/test_rbglox.rb

@@ -0,0 +1,9 @@
+require 'rubygems'
+require 'test/unit'
+require 'rbglox'
+
+class RBGLoxTest < Test::Unit::TestCase
+  def test_version
+    assert_equal RBGLox::VERSION, '0.1.0'
+  end
+end

metadata

@@ -0,0 +1,131 @@
+--- !ruby/object:Gem::Specification 
+name: rbglox
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Mihail Szabolcs
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-06-19 00:00:00 +03:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: ruby-opengl
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 237
+        segments: 
+        - 0
+        - 60
+        - 1
+        version: 0.60.1
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: ruby-glfw
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 57
+        segments: 
+        - 0
+        - 9
+        - 1
+        version: 0.9.1
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: directory_watcher
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 1
+        - 4
+        - 0
+        version: 1.4.0
+  type: :runtime
+  version_requirements: *id003
+description: rbGLox is a small wrapper over the ruby-opengl, ruby-glfw.
+email: 
+- szaby@szabster.net
+executables: 
+- rbglox
+extensions: []
+
+extra_rdoc_files: 
+- README.md
+- LICENSE
+files: 
+- lib/rbglox/window.rb
+- lib/rbglox/texture.rb
+- lib/rbglox/resource.rb
+- lib/rbglox/app.rb
+- lib/rbglox/mesh.rb
+- lib/rbglox/meshcube.rb
+- lib/rbglox/meshquad.rb
+- lib/rbglox/shader.rb
+- lib/rbglox/version.rb
+- lib/rbglox.rb
+- res/shader.glsl
+- res/texture.tga
+- README.md
+- LICENSE
+- test/test_rbglox.rb
+- bin/rbglox
+has_rdoc: true
+homepage: http://github.com/icebreaker/rbglox
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: rbglox
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: rbGLox is a small wrapper over the ruby-opengl, ruby-glfw family by abstracting and providing some high-level interfaces for things like "Textures", "GLSL Shaders", basic "Geometry" and others.
+test_files: 
+- test/test_rbglox.rb