danabr75-ashton 0.1.5

data/spec/ashton/image_stub_spec.rb

@@ -0,0 +1,46 @@
+require_relative "../helper.rb"
+
+describe Ashton::ImageStub do
+  describe "#initialize" do
+    it "should fail if the blob data is not the expected size" do
+      lambda do
+        described_class.new "\0\0\0", 2, 3
+      end.should raise_error ArgumentError, /Expected blob to be 24 bytes/
+    end
+
+    it "should fail width <= 0" do
+      lambda do
+        described_class.new "\0\0\0\0", 0, 2
+      end.should raise_error ArgumentError, /Width must be >= 1 pixel/
+    end
+
+    it "should fail height <= 0" do
+      lambda do
+        described_class.new "\0\0\0\0", 2, 0
+      end.should raise_error ArgumentError, /Height must be >= 1 pixel/
+    end
+  end
+
+  context "instantiated" do
+    let(:two_by_three_blob) { 24.times.to_a.pack("C*") }
+    let(:subject) { described_class.new two_by_three_blob, 2, 3 }
+
+    describe "#to_blob" do
+      it "should return the blob given" do
+        subject.to_blob.should eq two_by_three_blob
+      end
+    end
+
+    describe "#columns" do
+      it "should equal the width of the blob" do
+        subject.columns.should eq 2
+      end
+    end
+
+    describe "#rows" do
+      it "should equal the height of the blob" do
+        subject.rows.should eq 3
+      end
+    end
+  end
+end

data/spec/ashton/particle_emitter_spec.rb

@@ -0,0 +1,123 @@
+require_relative "../helper.rb"
+
+# Values and their defaults. The deviations default to 0.
+FLOATS_WITH_RANGE = {
+    angular_velocity: 0.0..0.0,
+    center_x: 0.5..0.5,
+    center_y: 0.5..0.5,
+    fade: 0.0..0.0,
+    friction: 0.0..0.0,
+    interval: Float::INFINITY..Float::INFINITY,
+    scale: 1.0..1.0,
+    speed: 0.0..0.0,
+    time_to_live: Float::INFINITY..Float::INFINITY,
+    zoom: 0.0..0.0,
+}
+
+describe Ashton::ParticleEmitter do
+  before :all do
+    $window ||= Gosu::Window.new 16, 16, false
+    # Need not to create a large number of these.
+    @emitter = described_class.new 1, 2, 3
+  end
+
+  let(:default_max) { 1000 }
+  let(:subject) { @emitter }
+
+  describe "initialize" do
+    [:x, :y, :z].each.with_index(1) do |attr, value|
+      it "should set #{attr}" do
+        subject.send(attr).should be_kind_of Float
+        subject.send(attr).should eq value
+      end
+    end
+
+    FLOATS_WITH_RANGE.each_pair do |attr, expected|
+      it "should set #{attr}" do
+        subject.send(attr).should be_kind_of Range
+        subject.send(attr).should eq expected
+      end
+    end
+
+    it "should be set max_particles" do
+      subject.max_particles.should be_kind_of Fixnum
+      subject.max_particles.should eq default_max
+    end
+
+    it "should not have any particles" do
+      subject.count.should eq 0
+    end
+
+    it "should have color set to white" do
+      subject.color.should eq Gosu::Color::WHITE
+    end
+  end
+
+  [:x, :y, :z].each.with_index(1) do |attr, value|
+    describe "#{attr}=" do
+      it "should set the value of #{attr}" do
+        ->{ subject.send "#{attr}=", value + 5.0 }.should change(subject, attr).from(value).to(value + 5)
+      end
+    end
+  end
+
+  FLOATS_WITH_RANGE.keys.each do |attr|
+    describe "#{attr}=" do
+      it "should set #{attr} with a number" do
+        subject.send("#{attr}=", 42.0).should eq 42.0
+        subject.send("#{attr}").should eq 42.0..42.0
+      end
+
+      it "should set #{attr} with a range" do
+        subject.send("#{attr}=", 42.0..99.0).should eq 42.0..99.0
+        subject.send("#{attr}").should eq 42.0..99.0
+      end
+    end
+  end
+
+  describe "color=" do
+    it "should set color" do
+      (subject.color = Gosu::Color::BLACK).should eq Gosu::Color::BLACK
+      subject.color.should eq Gosu::Color::BLACK
+    end
+  end
+
+  describe "draw" do
+    it "should respond to #draw" do
+      subject.draw
+    end
+  end
+
+  describe "emit" do
+    it "should create one more particle" do
+      ->{ subject.emit }.should change(subject, :count).from(0).to(1)
+    end
+
+    it "should replace a particle if we are already at max particles" do
+      (default_max + 1).times { subject.emit }
+      subject.count.should eq default_max
+    end
+  end
+
+  describe "update" do
+    it "should an appropriate number of particles" do
+      subject = described_class.new 1, 2, 3, interval: 0.001
+      mock(subject).emit.times 16
+      subject.update 1.0 / 60.0 # 16.66667 ms
+    end
+
+    it "should not emit a particle if delta is less than interval" do
+      subject = described_class.new 1, 2, 3, interval: 0.020
+      dont_allow(subject).emit
+      subject.update 1.0 / 60.0 # 16.66667 ms
+    end
+
+    it "should fail given a negative delta" do
+      ->{ subject.update -1 }.should raise_error ArgumentError, "delta must be >= 0"
+    end
+
+    it "should fail for a bad delta type" do
+      ->{ subject.update "fred" }.should raise_error TypeError
+    end
+  end
+end

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