ray 0.1.0.pre1 → 0.1.0

data/samples/pong/pong.rb

@@ -7,33 +7,38 @@ end
 
 require 'ray'
 
+# NB: this tests Ray::ImageTarget, there's no other reason to use it.
+
 module Pong
   class Scene < Ray::Scene
     scene_name :pong_scene
 
     def setup
-      @font = Ray::Font.default
-
-      player_img = Ray::Image.new(:w => 20, :h => 50)
-      player_img.draw_filled_rect(Ray::Rect.new(0, 0, 20, 50), Ray::Color.blue)
-      player_img.update
+      player_img = Ray::Image.new [20, 50]
+      image_target(player_img) do |target|
+        target.draw Ray::Polygon.rectangle([0, 0, 20, 50], Ray::Color.blue)
+        target.update
+      end
 
-      adv_img = Ray::Image.new(:w => 20, :h => 50)
-      adv_img.draw_filled_rect(Ray::Rect.new(0, 0, 20, 50), Ray::Color.red)
-      adv_img.update
+      adv_img = Ray::Image.new [20, 50]
+      image_target(adv_img) do |target|
+        target.clear Ray::Color.red
+        target.update
+      end
 
-      ball_img = Ray::Image.new(:w => 10, :h => 10)
-      ball_img.draw_filled_circle([5, 5], 5, Ray::Color.white)
-      ball_img.update
+      ball_img = Ray::Image.new [10, 10]
+      image_target(ball_img) do |target|
+        target.draw Ray::Polygon.circle([5, 5], 5, Ray::Color.white)
+        target.update
+      end
 
-      @player = sprite(player_img)
-      @adv    = sprite(adv_img)
-      @ball   = sprite(ball_img)
+      @player = sprite player_img
+      @adv    = sprite adv_img
+      @ball   = sprite ball_img
 
-      screen = Ray.screen
-      width, height = screen.w, screen.h
+      width, height = window.size.to_a
 
-      @screen_rect = Ray::Rect.new(0, 0, width, height)
+      @screen_rect = Ray::Rect[0, 0, width, height]
 
       @player.y = (height / 2) - 25
       @adv.y    = (height / 2) - 25
@@ -44,13 +49,15 @@ module Pong
       reset_ball
 
       @scores = {:player => 0, :adv => 0}
+
+      @score = text "0 - 0", :size => 12
     end
 
     def reset_ball
       @ball.y = (@screen_rect.h / 2) - 5
       @ball.x = (@screen_rect.w / 2) - 5
 
-      @ball_movement = [6, 6]
+      @ball_movement = Ray::Vector2[6, 6]
     end
 
     def register
@@ -58,6 +65,7 @@ module Pong
 
       on :point_gained do |by|
         @scores[by] += 1
+        @score.string = "#{@scores[:player]} - #{@scores[:adv]}"
         reset_ball
       end
 
@@ -78,40 +86,34 @@ module Pong
 
         if @ball.collide?(@player) || @ball.collide?(@adv) ||
             @ball.y >= @screen_rect.h || @ball.y <= 0
-          @ball_movement[-1] *= -1
-          @ball.y += @ball_movement.last
+          @ball_movement.y *= -1
         end
 
         if @ball.collide?(@player) || @ball.collide?(@adv)
-          @ball_movement[0] *= -1
-          @ball.x += @ball_movement.first
+          @ball_movement.x *= -1
         end
 
-        adv_center = @adv.y + (@adv.image.h / 2)
-        if @ball.y > adv_center
-          @adv.y += 4
-        elsif @ball.y < adv_center
-          @adv.y -= 4
+        if @ball_movement.x > 0
+          adv_center = @adv.y + (@adv.image.h / 2)
+          if @ball.y > adv_center
+            @adv.y += 4
+          elsif @ball.y < adv_center
+            @adv.y -= 4
+          end
         end
 
-        @ball.x += @ball_movement.first
-        @ball.y += @ball_movement.last
-
-        need_render!
+        @ball.pos += @ball_movement
       end
     end
 
     def render(win)
-      win.fill(Ray::Color.black)
+      win.clear Ray::Color.black
 
-      @player.draw_on win
-      @adv.draw_on win
-      @ball.draw_on win
+      win.draw @player
+      win.draw @adv
+      win.draw @ball
 
-      @font.draw("#{@scores[:player]} - #{@scores[:adv]}",
-                 :at => [0, 0], :on => win,
-                 :color => Ray::Color.white,
-                 :size => 12)
+      win.draw @score
     end
   end
 

data/samples/{run_scene.rb → scenes/run_scene.rb}

@@ -1,9 +1,25 @@
-$:.unshift File.expand_path(File.dirname(__FILE__) + "/../lib")
-$:.unshift File.expand_path(File.dirname(__FILE__) + "/../ext")
+$:.unshift File.expand_path(File.dirname(__FILE__) + "/../../lib")
+$:.unshift File.expand_path(File.dirname(__FILE__) + "/../../ext")
 
 require 'ray'
 
-$stdout = StringIO.new
+class FakeOutput
+  def initialize
+    @text = Ray::Text.new "", :size => 12
+  end
+
+  def puts(string)
+    @text.string = @text.string << "#{string}\n"
+  end
+
+  def write(string)
+    @text.string = @text.string << string
+  end
+
+  attr_reader :text
+end
+
+$stdout = FakeOutput.new
 
 Ray.game "run_scene" do
   register do
@@ -14,8 +30,6 @@ Ray.game "run_scene" do
     end
   end
 
-  font = Ray::Font.default
-
   scene :sec do
     on :key_press, key(:down) do
       puts "#{self} knows you pressed down"
@@ -28,7 +42,7 @@ Ray.game "run_scene" do
     puts "In scene :sec"
 
     render do |win|
-      font.draw($stdout.string, :on => win, :size => 12)
+      win.draw $stdout.text
     end
   end
 
@@ -45,7 +59,7 @@ Ray.game "run_scene" do
     puts "In scene :first"
 
     render do |win|
-      font.draw($stdout.string, :on => win, :size => 12)
+      win.draw $stdout.text
     end
   end
 

data/samples/shaders/geometry.rb

@@ -0,0 +1,98 @@
+$:.unshift File.expand_path(File.dirname(__FILE__) + "/../../lib")
+$:.unshift File.expand_path(File.dirname(__FILE__) + "/../../ext")
+
+require 'ray'
+
+class Triangles < Ray::Drawable
+  def initialize
+    super
+    self.vertex_count = 3
+  end
+
+  def fill_vertices
+    [
+     Ray::Vertex.new([0, 0], Ray::Color.red),
+     Ray::Vertex.new([100, 0], Ray::Color.green),
+     Ray::Vertex.new([100, 200], Ray::Color.blue),
+    ]
+  end
+
+  def render(first, index)
+    Ray::GL.draw_arrays :triangles, first, 3
+  end
+end
+
+Ray.game "Geometry shader" do
+  register { add_hook :quit, method(:exit!) }
+
+  scene :shader do
+    @triangles = Triangles.new
+
+    geometry = <<-geometry
+#version 150
+
+layout(triangles) in;
+layout(triangle_strip, max_vertices = 6) out;
+
+void main() {
+  for(int i = 0; i < gl_in.length(); i++) {
+    gl_Position = gl_in[i].gl_Position;
+    EmitVertex();
+  }
+  EndPrimitive();
+
+  for(int i = 0; i < gl_in.length(); i++) {
+    gl_Position = gl_in[i].gl_Position + vec4(0.3, 0, 0, 0);
+    EmitVertex();
+  }
+  EndPrimitive();
+}
+geometry
+
+    vertex = <<-vertex
+#version 150
+
+in vec2 in_Vertex;
+in vec4 in_Color;
+in vec2 in_TexCoord;
+
+uniform mat4 in_ModelView;
+uniform mat4 in_Projection;
+
+out vec4 var_Color;
+out vec2 var_TexCoord;
+
+void main() {
+  gl_Position  = vec4(in_Vertex, 0, 1) * (in_ModelView * in_Projection);
+  var_Color    = in_Color;
+  var_TexCoord = in_TexCoord;
+}
+vertex
+
+    frag = <<-frag
+#version 150
+
+uniform sampler2D in_Texture;
+uniform bool in_TextureEnabled;
+
+in vec4 var_Color;
+in vec2 var_TexCoord;
+
+out vec4 out_FragColor;
+
+void main() {
+  out_FragColor = vec4(0, 1, 1, 1);
+}
+frag
+
+    window.shader.compile(:frag     => StringIO.new(frag),
+                          :vertex   => StringIO.new(vertex),
+                          :geometry => StringIO.new(geometry))
+
+    render do |win|
+      win.draw @triangles
+    end
+  end
+
+  scenes << :shader
+end

data/samples/shaders/scene.rb

@@ -9,30 +9,37 @@ Ray::Game.new("Shaders test") do
   end
 
   scene :shader do
-    self.lazy_rendering = true
-
-    shape = Ray::Shape.rectangle([0, 0, 100, 100], Ray::Color.black)
-    shape.each do |point|
+    @poly = Ray::Polygon.rectangle([0, 0, 100, 100], Ray::Color.black)
+    @poly.each do |point|
       point.color = Ray::Color.new(rand(256), rand(256), rand(256))
     end
 
-    self.shader = Ray::Shader.new StringIO.new(<<-SHADER)
-      uniform sampler2D texture;
-      uniform vec3      ratio;
+    window.shader.compile :frag => StringIO.new(<<-SHADER)
+      #version 110
+
+      uniform sampler2D in_Texture;
+      uniform bool in_TextureEnabled;
+
+      uniform vec3 ratio;
+
+      varying vec4 var_Color;
+      varying vec2 var_TexCoord;
 
       void main() {
-        vec4 color = texture2D(texture, gl_TexCoord[0].xy);
-        float gray = dot(color.xyz, ratio);
+        if (in_TextureEnabled)
+         gl_FragColor = texture2D(in_Texture, var_TexCoord) * var_Color;
+        else
+          gl_FragColor = var_Color;
 
+        float gray = dot(gl_FragColor.rgb, ratio);
         gl_FragColor = vec4(gray, gray, gray, 1.0);
       }
     SHADER
 
-    shader["texture"] = :current
-    shader["ratio"]   = [0.299, 0.587, 0.114]
+    window.shader[:ratio] = [0.299, 0.587, 0.114]
 
     render do |win|
-      shape.draw_on win
+      win.draw @poly
     end
   end
 

data/samples/shaders/shaders.rb

@@ -9,34 +9,51 @@ Ray::Game.new("Shaders test") do
   end
 
   scene :shader do
-    img = Ray::Image.new(:w => 100, :h => 100).fill(Ray::Color.green)
-    img.draw_line([0, 0], [100, 100], Ray::Color.black, 2)
-    img.draw_line([0, 100], [100, 0], Ray::Color.white, 2)
-    img.draw_filled_circle([50, 50], 10, Ray::Color.cyan)
-    img.update
+    img = Ray::Image.new [100, 100]
 
-    shader = Ray::Shader.new StringIO.new(<<-SHADER)
-      uniform sampler2D texture;
-      uniform vec3      ratio;
+    image_target img do |target|
+      target.clear Ray::Color.green
+
+      target.draw Ray::Polygon.line([0, 0], [100, 100], 2, Ray::Color.black)
+      target.draw Ray::Polygon.line([0, 100], [100, 0], 2, Ray::Color.white)
+
+      target.draw Ray::Polygon.circle([50, 50], 10, Ray::Color.cyan)
+
+      target.update
+    end
+
+    shader = Ray::Shader.new :frag => StringIO.new(<<-SHADER)
+      #version 110
+
+      uniform sampler2D in_Texture;
+      uniform bool in_TextureEnabled;
+
+      uniform vec3 ratio;
+
+      varying vec4 var_Color;
+      varying vec2 var_TexCoord;
 
       void main() {
-        vec4 color = texture2D(texture, gl_TexCoord[0].xy);
-        float gray = dot(color.xyz, ratio);
+        if (in_TextureEnabled)
+         gl_FragColor = texture2D(in_Texture, var_TexCoord) * var_Color;
+        else
+          gl_FragColor = var_Color;
 
+        float gray = dot(gl_FragColor.rgb, ratio);
         gl_FragColor = vec4(gray, gray, gray, 1.0);
       }
     SHADER
 
-    shader["texture"] = :current
-    shader["ratio"]   = [0.299, 0.587, 0.114]
+    shader[:ratio] = [0.299, 0.587, 0.114]
 
-    render do |win|
-      win.fill(Ray::Color.black)
+    @normal_sprite = sprite img, :at => [100, 100]
+    @shaded_sprite = sprite img, :shader => shader
 
-      img.draw(:on => win, :at => [0, 0],     :shader => shader)
-      img.draw(:on => win, :at => [100, 100], :shader => nil)
+    render do |win|
+      win.draw @shaded_sprite
+      win.draw @normal_sprite
     end
   end
 
-  push_scene :shader
+  scenes << :shader
 end

data/samples/shaders/shape.rb

@@ -3,30 +3,35 @@ $:.unshift File.expand_path(File.dirname(__FILE__) + "/../../ext")
 
 require 'ray'
 
+Ray::Shader.use_old!
+
 Ray::Game.new("Shaders test") do
   register do
     add_hook :quit, method(:exit!)
   end
 
   scene :shader do
-    shape = Ray::Shape.rectangle([0, 0, 100, 100], Ray::Color.black)
-    shape.each do |point|
+    @shape = Ray::Polygon.circle([200, 200], 100, Ray::Color.black)
+    @shape.each do |point|
       point.color = Ray::Color.new(rand(256), rand(256), rand(256))
     end
 
-    shader = Ray::Shader.new StringIO.new(<<-SHADER)
-      uniform vec3 ratio;
+    @shape.shader = Ray::Shader.new :frag => StringIO.new(<<-SHADER)
+      #version 110
+
+      uniform vec3 ratio[2];
+      varying vec4 var_Color;
 
       void main() {
-        float gray   = dot(gl_Color.xyz, ratio);
+        float gray   = dot(var_Color.rgb, ratio[0]);
         gl_FragColor = vec4(gray, gray, gray, 1.0);
       }
     SHADER
 
-    shader["ratio"] = [0.299, 0.587, 0.114]
+    @shape.shader[:ratio] = [0.299, 0.587, 0.114]
 
     render do |win|
-      shape.draw(:on => win, :shader => shader)
+      win.draw @shape
     end
   end