ashton 0.0.1alpha → 0.0.2alpha

data/spec/ashton/pixel_cache_spec.rb

@@ -0,0 +1,153 @@
+require_relative "../helper.rb"
+
+describe Ashton::PixelCache do
+  before :all do
+    $window ||= Gosu::Window.new 16, 16, false
+  end
+
+  let(:testcard_image) { @testcard_image ||= Gosu::Image.new $window, media_path("simple.png") }
+  let(:texture) { Ashton::Texture.new testcard_image }
+  let(:subject) { described_class.new texture }
+
+  describe "owner" do
+    it "should remember the owner it was created for" do
+      subject.owner.should eq texture
+    end
+  end
+
+  describe "refresh" do
+    it "should respond to refresh" do
+      subject.should respond_to :refresh
+    end
+  end
+
+  describe "initialize" do
+    it "should cache for a texture class" do
+      ->{ described_class.new texture }.should_not raise_error TypeError
+    end
+
+    it "should cache for an image class" do
+      pending "it not freezing :/"
+      ->{ described_class.new testcard_image }.should_not raise_error TypeError
+    end
+
+    it "should fail passed an unexpected class" do
+      ->{ described_class.new "frog" }.should raise_error TypeError
+    end
+  end
+
+  describe "[]" do
+    it "should return the color of the pixel" do
+      subject[0, 0].should eq Gosu::Color::WHITE
+      subject[0, 1].should eq Gosu::Color::RED
+      subject[0, 2].should eq Gosu::Color::GREEN
+      subject[0, 3].should eq Gosu::Color::BLUE
+      subject[0, 4].should eq Gosu::Color.rgba(255, 255, 255, 153)
+      subject[0, 8].should eq Gosu::Color.rgba(0, 0, 0, 0)
+    end
+
+    it "should return a null colour outside the texture" do
+      subject[0, -1].should eq Gosu::Color.new 0
+      subject[-1, 0].should eq Gosu::Color.new 0
+      subject[16, 0].should eq Gosu::Color.new 0
+      subject[0, 12].should eq Gosu::Color.new 0
+    end
+  end
+
+  describe "rgba" do
+    it "should return the appropriate array of values" do
+      subject.rgba(0, 0).should eq [255, 255, 255, 255]
+      subject.rgba(0, 1).should eq [255, 0, 0, 255]
+      subject.rgba(0, 2).should eq [0, 255, 0, 255]
+      subject.rgba(0, 3).should eq [0, 0, 255, 255]
+      subject.rgba(0, 4).should eq [255, 255, 255, 153]
+      subject.rgba(0, 8).should eq [0, 0, 0, 0]
+    end
+  end
+
+  describe "red" do
+    it "should return the appropriate value" do
+      subject.red(0, 0).should eq 255
+      subject.red(0, 1).should eq 255
+      subject.red(0, 2).should eq 0
+      subject.red(0, 3).should eq 0
+      subject.red(0, 8).should eq 0
+    end
+  end
+
+  describe "green" do
+    it "should return the appropriate value" do
+      subject.green(0, 0).should eq 255
+      subject.green(0, 1).should eq 0
+      subject.green(0, 2).should eq 255
+      subject.green(0, 3).should eq 0
+      subject.green(0, 8).should eq 0
+    end
+  end
+
+  describe "blue" do
+    it "should return the appropriate value" do
+      subject.blue(0, 0).should eq 255
+      subject.blue(0, 1).should eq 0
+      subject.blue(0, 2).should eq 0
+      subject.blue(0, 3).should eq 255
+      subject.blue(0, 8).should eq 0
+    end
+  end
+
+  describe "alpha" do
+    it "should return the appropriate value" do
+      subject.alpha(0, 0).should eq 255
+      subject.alpha(0, 1).should eq 255
+      subject.alpha(0, 2).should eq 255
+      subject.alpha(0, 3).should eq 255
+      subject.alpha(0, 8).should eq 0
+    end
+  end
+
+  describe "transparent?" do
+    it "should be false where the buffer is opaque or semi-transparent" do
+      subject.transparent?(0, 1).should eq false
+      subject.transparent?(0, 5).should eq false
+    end
+
+    it "should be true where the buffer is transparent" do
+      subject.transparent?(0, 8).should eq true
+    end
+  end
+
+  describe "width" do
+    it "should be initially set" do
+      subject.width.should eq testcard_image.width
+    end
+  end
+
+  describe "height" do
+    it "should be initially set" do
+      subject.height.should eq testcard_image.height
+    end
+  end
+
+  describe "to_blob" do
+    it "should create a blob identical to one an equivalent image would create" do
+      subject.to_blob.should eq testcard_image.to_blob
+    end
+  end
+
+  describe "to_image" do
+    let(:image) { subject.to_image }
+
+    it "should create a Gosu::Image" do
+      image.should be_kind_of Gosu::Image
+    end
+
+    it "should create an image of the appropriate size" do
+      image.width.should eq testcard_image.width
+      image.height.should eq testcard_image.height
+    end
+
+    it "should create an image identical to the one that was drawn into it originally" do
+      image.to_blob.should eq testcard_image.to_blob
+    end
+  end
+end

data/spec/ashton/shader_spec.rb

@@ -0,0 +1,152 @@
+require_relative "../helper.rb"
+
+describe Ashton::Shader do
+  before :all do
+    $window = Gosu::Window.new 16, 16, false
+  end
+
+  let(:subject) { described_class.new}
+  let(:program) { subject.instance_variable_get :@program }
+
+  after :each do
+    glUseProgram 0
+  end
+
+  describe "initialize" do
+    it "should fail if the built-in fragment shader doesn't exist" do
+      ->{ described_class.new fragment: :fish }.should raise_error Ashton::ShaderLoadError
+    end
+
+    it "should fail if the built-in vertex shader doesn't exist" do
+      ->{ described_class.new vertex: :fish }.should raise_error Ashton::ShaderLoadError
+    end
+
+    it "should fail if the file-based fragment shader doesn't exist or is bad source" do
+      ->{ described_class.new fragment: "/fish.frag" }.should raise_error Ashton::ShaderCompileError
+    end
+
+    it "should fail if the file-based fragment shader doesn't exist or is bad source" do
+      ->{ described_class.new vertex: "/fish.vert" }.should raise_error Ashton::ShaderCompileError
+    end
+
+    it "should set uniform values from the options hash" do
+      any_instance_of described_class do |shader|
+        mock(shader, :[]=).with :frog, 12
+        mock(shader, :[]=).with :fish_paste, 15.0
+      end
+
+      described_class.new uniforms: { frog: 12, fish_paste: 15.0 }
+    end
+
+    it "should fail if requested to set nonexistent uniform values in the options hash" do
+      ->{ described_class.new uniforms: { frog: 12 }} .should raise_error Ashton::ShaderUniformError
+    end
+  end
+
+  describe "dup" do
+    it "should create a new object containing the same source" do
+      new_shader = subject.dup
+      new_shader.vertex_source.should eq subject.vertex_source
+      new_shader.fragment_source.should eq subject.fragment_source
+    end
+  end
+
+  describe "enable" do
+    context "with a block" do
+      it "should fail if the shader is already active" do
+        glUseProgram program
+
+        ->{ subject.enable {} }.should raise_error Ashton::ShaderError
+      end
+
+      it "should pass itself into the block" do
+        shader = nil
+        subject.enable do |s|
+          shader = s
+        end
+
+        shader.should eq subject
+      end
+
+      it "should be current within the block?" do
+        subject.enable do
+          subject.should be_current
+        end
+      end
+
+      it "should be not current after the block" do
+        subject.enable do
+        end
+
+        subject.should_not be_current
+      end
+    end
+
+    context "without a block" do
+      it "should fail if the shader is already active" do
+        glUseProgram program
+
+        ->{ subject.enable }.should raise_error Ashton::ShaderError
+      end
+
+      it "should toggle current?" do
+        ->{ subject.enable }.should change(subject, :current?).from(false).to true
+      end
+    end
+  end
+
+  describe "disable" do
+    it "should fail if the shader is not active" do
+      -> { subject.disable }.should raise_error Ashton::ShaderError
+    end
+
+    it "should toggle current?" do
+      subject.enable
+      ->{ subject.disable }.should change(subject, :current?).from(true).to false
+    end
+  end
+
+  describe "current?" do
+    it "should be true if the program is current" do
+      glUseProgram program
+      subject.should be_current
+    end
+
+    it "should be false if the program isn't current" do
+      glUseProgram 0
+      subject.should_not be_current
+    end
+  end
+
+  describe "image=" do
+    pending
+  end
+
+  describe "color=" do
+    pending
+  end
+
+  describe "[]=" do
+    pending
+  end
+
+  describe "[]" do
+    pending "implementation"
+  end
+
+  describe "uniform_location" do
+    pending
+  end
+
+  describe "attribute_location" do
+    pending
+  end
+
+  describe "compile" do
+    pending
+  end
+
+  describe "link" do
+    pending
+  end
+end

data/spec/ashton/signed_distance_field_spec.rb

@@ -0,0 +1,163 @@
+require_relative "../helper.rb"
+
+
+describe Ashton::SignedDistanceField do
+  before :all do
+    Gosu::enable_undocumented_retrofication
+
+    $window ||= Gosu::Window.new 16, 16, false
+  end
+
+  let(:max_distance) { 3 }
+  let(:width) { 9 }
+  let(:height) { 10 }
+
+  let(:subject) do
+    described_class.new width, height, max_distance do
+      # ---------
+      # -XXX-----
+      # -XXXX----
+      # -XXXX----
+      # ---------
+      # ---------
+      # ---------
+      # ---------
+      # ---------
+      # ---------
+      $window.pixel.draw 1, 1, 0, 3, 3
+      $window.pixel.draw 4, 2, 0, 1, 2
+    end
+  end
+
+  describe "initialize" do
+    it "should accept a block and yield itself" do
+      yielded = nil
+      field = described_class.new width, height, max_distance do |value|
+        yielded = value
+      end
+
+      yielded.should eq field
+    end
+
+    it "should initialize itself to max_distance if not given a block" do
+      field = described_class.new width, height, max_distance
+      field.to_a.flatten.uniq.should eq [max_distance]
+    end
+  end
+
+  describe "width" do
+    it "should give the width" do
+      subject.width.should eq width
+    end
+  end
+
+  describe "height" do
+    it "should give the height" do
+      subject.height.should eq height
+    end
+  end
+
+  describe "position_clear?" do
+    it "should be true if there is room" do
+      subject.position_clear?(8, 4, 2).should be_true
+    end
+
+    it "should be false if there is no room" do
+      subject.position_clear?(8, 4, 4).should be_false
+    end
+
+    it "should be false inside a solid" do
+      subject.position_clear?(2, 2, 1).should be_false
+    end
+  end
+
+  describe "sample_distance" do
+    it "should give the appropriate distance" do
+      subject.sample_distance(1, 0).should eq 1
+      subject.sample_distance(7, 4).should eq 3
+      subject.sample_distance(1, 1).should eq 0
+      subject.sample_distance(2, 2).should eq -1
+    end
+
+    it "should max out at the specified limit" do
+      subject.sample_distance(8, 9).should eq max_distance
+    end
+  end
+
+  describe "line_of_sight?" do
+    it "should be false if the sight line is blocked" do
+      subject.line_of_sight?(2, 0, 2, 9).should be_false
+    end
+
+    it "should be true if the sight line is uninterrupted" do
+      subject.line_of_sight?(0, 0, 0, 9).should be_true
+    end
+  end
+
+  describe "line_of_sight_blocked_at" do
+    it "should be false if the sight line is blocked" do
+      subject.line_of_sight_blocked_at(2, 0, 2, 9).should eq [2, 1]
+    end
+
+    it "should be nil if the sight line is uninterrupted" do
+      subject.line_of_sight_blocked_at(0, 0, 0, 9).should be_nil
+    end
+  end
+
+  describe "sample_gradient" do
+    it "should give expected values" do
+      subject.sample_gradient(1, 0).should eq [0, -1]
+      subject.sample_gradient(0, 1).should eq [-1, 0]
+
+      subject.sample_gradient(5, 3).should eq [2, 0]
+      subject.sample_gradient(1, 4).should eq [0, 2]
+    end
+  end
+
+  describe "sample_normal" do
+    it "should give expected values" do
+      subject.sample_normal(1, 0).should eq [0.0, -1.0]
+      subject.sample_normal(0, 1).should eq [-1.0, 0.0]
+
+      subject.sample_normal(5, 3).should eq [1.0, 0.0]
+      subject.sample_normal(1, 4).should eq [0.0, 1.0]
+    end
+  end
+
+  describe "render_field" do
+    it "should yield the field" do
+      field = nil
+      subject.render_field do |value|
+        field = value
+      end
+      field.should eq subject
+    end
+
+    it "should fail without a block" do
+      ->{ subject.render_field }.should raise_error ArgumentError
+    end
+
+    pending
+  end
+
+  describe "draw" do
+    pending
+  end
+
+  describe "to_a" do
+    it "should generate the expected array" do
+      # Remember this is rotated so array[x][y] works.
+      subject.to_a.should eq [
+          [1, 1,  1, 1, 1, 2, 3, 3, 3, 3],
+          [1, 0,  0, 0, 1, 2, 3, 3, 3, 3],
+          [1, 0, -1, 0, 1, 2, 3, 3, 3, 3],
+          [1, 0,  0, 0, 1, 2, 3, 3, 3, 3],
+          [1, 1,  0, 0, 1, 2, 3, 3, 3, 3],
+          [2, 1,  1, 1, 1, 2, 3, 3, 3, 3],
+          [3, 2,  2, 2, 2, 3, 3, 3, 3, 3],
+          [3, 3,  3, 3, 3, 3, 3, 3, 3, 3],
+          [3, 3,  3, 3, 3, 3, 3, 3, 3, 3],
+      ]
+    end
+  end
+end