gosling 1.0.0

data/lib/gosling/polygon.rb

@@ -0,0 +1,52 @@
+require_relative 'actor.rb'
+require_relative 'collision.rb'
+
+module Gosling
+  class Polygon < Actor
+    def initialize(window)
+      super(window)
+      @vertices = [
+        Vector[0, 0, 0],
+        Vector[1, 0, 0],
+        Vector[1, 1, 0],
+        Vector[0, 1, 0]
+      ]
+    end
+
+    def get_vertices
+      @vertices.dup
+    end
+
+    def set_vertices(vertices)
+      unless vertices.is_a?(Array) && vertices.length >= 3 && vertices.reject { |v| v.is_a?(Vector) && v.size == 3 }.empty?
+        raise ArgumentError.new("set_vertices() expects an array of at least three 3D Vectors")
+      end
+      @vertices.replace(vertices)
+    end
+
+    def get_global_vertices
+      tf = get_global_transform
+      @vertices.map { |v| Transform.transform_point(tf, v) }
+    end
+
+    def render(matrix)
+      global_vertices = @vertices.map { |v| Transform.transform_point(matrix, v) }
+      i = 2
+      while i < global_vertices.length
+        v0 = global_vertices[0]
+        v1 = global_vertices[i-1]
+        v2 = global_vertices[i]
+        @window.draw_triangle(
+          v0[0].to_f, v0[1].to_f, @color,
+          v1[0].to_f, v1[1].to_f, @color,
+          v2[0].to_f, v2[1].to_f, @color,
+        )
+        i += 1
+      end
+    end
+
+    def is_point_in_bounds(point)
+      Collision.is_point_in_shape?(point, self)
+    end
+  end
+end

data/lib/gosling/rect.rb

@@ -0,0 +1,38 @@
+require_relative 'polygon.rb'
+
+module Gosling
+  class Rect < Polygon
+    attr_reader :width, :height
+
+    def initialize(window)
+      super(window)
+      @width = 1
+      @height = 1
+      rebuild_vertices
+    end
+
+    def width=(val)
+      raise ArgumentError.new("set_width() expects a positive, non-zero number") if val <= 0
+      @width = val
+      rebuild_vertices
+    end
+
+    def height=(val)
+      raise ArgumentError.new("set_height() expects a positive, non-zero number") if val <= 0
+      @height = val
+      rebuild_vertices
+    end
+
+    def rebuild_vertices
+      vertices = [
+        Vector[     0,       0, 0],
+        Vector[@width,       0, 0],
+        Vector[@width, @height, 0],
+        Vector[     0, @height, 0],
+      ]
+      set_vertices(vertices)
+    end
+
+    private :set_vertices
+  end
+end

data/lib/gosling/sprite.rb

@@ -0,0 +1,35 @@
+require_relative 'rect.rb'
+
+module Gosling
+  class Sprite < Rect
+    def initialize(window)
+      super(window)
+      @image = nil
+      @color = Gosu::Color.rgba(255, 255, 255, 255)
+    end
+
+    def get_image
+      @image
+    end
+
+    def set_image(image)
+      raise ArgumentError.new("Expected Image, but received #{image.inspect}!") unless image.is_a?(Gosu::Image)
+      @image = image
+      self.width = @image.width
+      self.height = @image.height
+    end
+
+    def render(matrix)
+      global_vertices = @vertices.map { |v| Transform.transform_point(matrix, v) }
+      @image.draw_as_quad(
+        global_vertices[0][0].to_f, global_vertices[0][1].to_f, @color,
+        global_vertices[1][0].to_f, global_vertices[1][1].to_f, @color,
+        global_vertices[2][0].to_f, global_vertices[2][1].to_f, @color,
+        global_vertices[3][0].to_f, global_vertices[3][1].to_f, @color,
+        0
+      )
+    end
+
+    private :'width=', :'height='
+  end
+end

data/lib/gosling/transform.rb

@@ -0,0 +1,223 @@
+require 'matrix'
+
+module Gosling
+  class FastMatrix
+    @@multiply_buffer = []
+    @@cache = []
+
+    attr_reader :array
+    attr_accessor :row_count, :column_count
+
+    private
+
+    def initialize
+      @array = nil
+      reset
+    end
+
+    public
+
+    def self.create
+      if @@cache.empty?
+        FastMatrix.new
+      else
+        @@cache.pop.reset
+      end
+    end
+
+    def destroy
+      reset
+      @@cache.push(self)
+      nil
+    end
+
+    def reset
+      if @array
+        @array.clear
+      else
+        @array = []
+      end
+      @row_count = 0
+      @column_count = 0
+      self
+    end
+
+    def copy_from(matrix)
+      if matrix.is_a?(Matrix)
+        @array = matrix.to_a.flatten
+        @row_count = matrix.row_size
+        @column_count = matrix.column_size
+      elsif matrix.is_a?(FastMatrix)
+        @array = matrix.array
+        @row_count = matrix.row_count
+        @column_count = matrix.column_count
+      else
+        raise ArgumentError.new("Cannot copy from #{matrix.inspect}!")
+      end
+      self
+    end
+
+    def to_matrix
+      rows = (0...@row_count).map do |i|
+        @array[(@column_count * i)...(@column_count * (i + 1))]
+      end
+      Matrix.rows(rows)
+    end
+
+    def fast_multiply(mat2, result = nil)
+      raise ArgumentError.new() unless mat2.is_a?(FastMatrix) && result.is_a?(FastMatrix)
+      Matrix.Raise ErrDimensionMismatch if @column_count != mat2.row_count
+
+      i = 0
+      while i < @row_count do
+        j = 0
+        while j < mat2.column_count do
+          k = 0
+          sum = 0
+          while k < @column_count do
+            sum += @array[i * @column_count + k] * mat2.array[k * mat2.column_count + j]
+            k += 1
+          end
+          @@multiply_buffer[i * @column_count + j] = sum
+          j += 1
+        end
+        i += 1
+      end
+
+      result ||= FastMatrix.create
+      result.array.replace(@@multiply_buffer)
+      result.row_count = @row_count
+      result.column_count = mat2.column_count
+      result
+    end
+
+    def self.combine_matrices(*matrices)
+      raise ArgumentError.new("Transform.combine_matrices expects one or more matrices") unless matrices.reject { |m| m.is_a?(Matrix) }.empty?
+
+      fast_matrices = matrices.map { |mat| FastMatrix.create.copy_from(mat) }
+      result = nil
+      fast_matrices.each do |fast_matrix|
+        if result
+          result.fast_multiply(fast_matrix, result)
+        else
+          result = fast_matrix
+        end
+      end
+      result
+    end
+  end
+
+  class Transform
+    def self.rational_sin(r)
+      r = r % (2 * Math::PI)
+      return case r
+      when 0.0
+        0.to_r
+      when Math::PI / 2
+        1.to_r
+      when Math::PI
+        0.to_r
+      when Math::PI * 3 / 2
+        -1.to_r
+      else
+        Math.sin(r).to_r
+      end
+    end
+
+    def self.rational_cos(r)
+      r = r % (2 * Math::PI)
+      return case r
+      when 0.0
+        1.to_r
+      when Math::PI / 2
+        0.to_r
+      when Math::PI
+        -1.to_r
+      when Math::PI * 3 / 2
+        0.to_r
+      else
+        Math.cos(r).to_r
+      end
+    end
+
+    attr_reader :center, :scale, :rotation, :translation
+
+    def initialize
+      set_center(Vector[0.to_r, 0.to_r, 0.to_r])
+      set_scale(Vector[1.to_r, 1.to_r])
+      set_rotation(0)
+      set_translation(Vector[0.to_r, 0.to_r, 0.to_r])
+    end
+
+    def set_center(v)
+      raise ArgumentError.new("Transform.set_center() requires a length 3 vector") unless v.is_a?(Vector) && v.size == 3
+      @center = Vector[v[0], v[1], 0.to_r]
+      @center_mat = Matrix[
+        [1.to_r, 0.to_r, -@center[0].to_r],
+        [0.to_r, 1.to_r, -@center[1].to_r],
+        [0.to_r, 0.to_r, 1.to_r]
+      ]
+      @is_dirty = true
+    end
+
+    def set_scale(v)
+      raise ArgumentError.new("Transform.set_scale() requires a length 2 vector") unless v.is_a?(Vector) && v.size == 2
+      @scale = v
+      @scale_mat = Matrix[
+        [@scale[0].to_r, 0.to_r, 0.to_r],
+        [0.to_r, @scale[1].to_r, 0.to_r],
+        [0.to_r, 0.to_r, 1.to_r]
+      ]
+      @is_dirty = true
+    end
+
+    def set_rotation(radians)
+      @rotation = radians
+      @rotate_mat = Matrix[
+        [Transform.rational_cos(@rotation), Transform.rational_sin(@rotation), 0.to_r],
+        [-Transform.rational_sin(@rotation), Transform.rational_cos(@rotation), 0.to_r],
+        [0.to_r, 0.to_r, 1.to_r]
+      ]
+      @is_dirty = true
+    end
+
+    def set_translation(v)
+      raise ArgumentError.new("Transform.set_translation() requires a length 3 vector") unless v.is_a?(Vector) && v.size == 3
+      @translation = Vector[v[0], v[1], 0.to_r]
+      @translate_mat = Matrix[
+        [1.to_r, 0.to_r, @translation[0].to_r],
+        [0.to_r, 1.to_r, @translation[1].to_r],
+        [0.to_r, 0.to_r, 1.to_r]
+      ]
+      @is_dirty = true
+    end
+
+    def to_matrix
+      return @matrix unless @is_dirty
+      #~ @matrix = @translate_mat * @rotate_mat * @scale_mat * @center_mat
+      @matrix = FastMatrix.combine_matrices(@translate_mat, @rotate_mat, @scale_mat, @center_mat).to_matrix
+      @is_dirty = false
+      @matrix
+    end
+
+    def self.transform_point(mat, v)
+      raise ArgumentError.new("Transform.transform_point() requires a length 3 vector") unless v.is_a?(Vector) && v.size == 3
+      result = mat * Vector[v[0], v[1], 1.to_r]
+      Vector[result[0], result[1], 0.to_r]
+    end
+
+    def transform_point(v)
+      Transform.transform_point(to_matrix, v)
+    end
+
+    def self.untransform_point(mat, v)
+      raise ArgumentError.new("Transform.transform_point() requires a length 3 vector") unless v.is_a?(Vector) && v.size == 3
+      result = mat.inverse * Vector[v[0], v[1], 1.to_r]
+      Vector[result[0], result[1], 0.to_r]
+    end
+
+    def untransform_point(v)
+      Transform.untransform_point(to_matrix, v)
+    end
+  end
+end

data/lib/gosling/version.rb

@@ -0,0 +1,3 @@
+module Gosling
+  VERSION = '1.0.0'
+end

data/spec/actor_spec.rb

@@ -0,0 +1,670 @@
+describe Gosling::Actor do
+  before(:all) do
+    @window = Gosu::Window.new(640, 480, false)
+    @read_only_actor = Gosling::Actor.new(@window)
+    @parent = Gosling::Actor.new(@window)
+    @child = Gosling::Actor.new(@window)
+  end
+
+  describe '#new' do
+    it 'requires a Gosu::Window' do
+      expect { Gosling::Actor.new(@window) }.not_to raise_error
+      expect { Gosling::Actor.new() }.to raise_error(ArgumentError)
+    end
+  end
+
+  it 'has a transform' do
+    expect(@read_only_actor.transform).to be_instance_of(Gosling::Transform)
+  end
+
+  it 'can have a parent' do
+    expect { @read_only_actor.parent }.not_to raise_error
+  end
+
+  it "does not initialize with a parent" do
+    expect(@read_only_actor.parent).to be == nil
+  end
+
+  describe '#add_child' do
+    it "creates a two-way parent/child link" do
+      @parent.add_child(@child)
+      expect(@parent.has_child?(@child)).to be true
+      expect(@child.parent).to be == @parent
+    end
+  end
+
+  describe '#remove_child' do
+    it "severs the two-way parent/child link" do
+      @parent.add_child(@child)
+      @parent.remove_child(@child)
+      expect(@parent.has_child?(@child)).to be false
+      expect(@child.parent).to be == nil
+    end
+  end
+
+  it 'has a list of children' do
+    expect(@read_only_actor.children).to be_instance_of(Array)
+  end
+
+  it "starts with no children" do
+    expect(@read_only_actor.children.empty?).to be true
+  end
+
+  it "knows if it has a particular child or not" do
+    expect(@read_only_actor.has_child?(Gosling::Actor.new(@window))).to be false
+  end
+
+  it "will never add any of its ancestors as children" do
+    @parent.add_child(@child)
+    expect { @child.add_child(@parent) }.to raise_error(Gosling::InheritanceError)
+  end
+
+  it "will not add itself as its own child" do
+    expect { @child.add_child(@child) }.to raise_error(Gosling::InheritanceError)
+  end
+
+  context "when given a child" do
+    before do
+      @parent.add_child(@child)
+    end
+
+    it "it forms a two-way link with that child" do
+      expect(@parent.has_child?(@child)).to be true
+      expect(@child.parent).to be == @parent
+    end
+
+    it "cannot be given the same child more than once" do
+      @parent.add_child(@child)
+      expect(@parent.children.length).to be == 1
+    end
+
+    context "and then the child is removed" do
+      before do
+        @parent.remove_child(@child)
+      end
+
+      it "the parent/child link is broken" do
+        expect(@parent.has_child?(@child)).to be false
+        expect(@child.parent).to be == nil
+      end
+    end
+
+    context 'and then adopted by another actor' do
+      it 'automatically breaks the old child/parent link' do
+        parent2 = Gosling::Actor.new(@window)
+        parent2.add_child(@child)
+        expect(@parent.has_child?(@child)).to be false
+        expect(@child.parent).to be == parent2
+      end
+    end
+  end
+
+  it 'has shortcut methods for getting its x/y position' do
+    expect(@read_only_actor.x).to be_kind_of(Numeric)
+    expect(@read_only_actor.y).to be_kind_of(Numeric)
+  end
+
+  it 'has shortcut methods for setting its x/y position' do
+    @read_only_actor.x = 13
+    @read_only_actor.y = -7
+    expect(@read_only_actor.x).to be == 13
+    expect(@read_only_actor.y).to be == -7
+  end
+
+  it 'has shortcut methods for getting its x/y centerpoint' do
+    expect(@read_only_actor.center_x).to be_kind_of(Numeric)
+    expect(@read_only_actor.center_y).to be_kind_of(Numeric)
+  end
+
+  it 'has shortcut methods for setting its x/y centerpoint' do
+    @read_only_actor.center_x = 5
+    @read_only_actor.center_y = 15
+    expect(@read_only_actor.center_x).to be == 5
+    expect(@read_only_actor.center_y).to be == 15
+  end
+
+  it 'has shortcut methods for getting its x/y scaling' do
+    expect(@read_only_actor.scale_x).to be_kind_of(Numeric)
+    expect(@read_only_actor.scale_y).to be_kind_of(Numeric)
+  end
+
+  it 'has shortcut methods for setting its x/y scaling' do
+    @read_only_actor.scale_x = 2
+    @read_only_actor.scale_y = 3
+    expect(@read_only_actor.scale_x).to be == 2
+    expect(@read_only_actor.scale_y).to be == 3
+  end
+
+  it 'has a shortcut method for getting its rotation' do
+    expect(@read_only_actor.rotation).to be_kind_of(Numeric)
+  end
+
+  it 'has a shortcut method for setting its rotation' do
+    @read_only_actor.rotation = Math::PI
+    expect(@read_only_actor.rotation).to be == Math::PI
+  end
+
+  it 'has a visibility flag' do
+    actor = Gosling::Actor.new(@window)
+    actor.is_visible = true
+    expect(actor.is_visible).to be true
+    actor.is_visible = false
+    expect(actor.is_visible).to be false
+  end
+
+  it 'has a children visibility flag' do
+    actor = Gosling::Actor.new(@window)
+    actor.are_children_visible = true
+    expect(actor.are_children_visible).to be true
+    actor.are_children_visible = false
+    expect(actor.are_children_visible).to be false
+  end
+
+  it 'has a tangible flag' do
+    actor = Gosling::Actor.new(@window)
+    actor.is_tangible = true
+    expect(actor.is_tangible).to be true
+    actor.is_tangible = false
+    expect(actor.is_tangible).to be false
+  end
+
+  it 'has a children tangibile flag' do
+    actor = Gosling::Actor.new(@window)
+    actor.are_children_tangible = true
+    expect(actor.are_children_tangible).to be true
+    actor.are_children_tangible = false
+    expect(actor.are_children_tangible).to be false
+  end
+
+  it 'has a mask flag' do
+    actor = Gosling::Actor.new(@window)
+    actor.is_mask = true
+    expect(actor.is_mask).to be true
+    actor.is_mask = false
+    expect(actor.is_mask).to be false
+  end
+
+  describe '#render' do
+    it 'the method exists' do
+      expect { @read_only_actor.render(Matrix.identity(3)) }.not_to raise_error
+    end
+  end
+
+  describe '#draw' do
+    before(:all) do
+      @draw_actor = Gosling::Actor.new(@window)
+      @mat = Matrix.identity(3)
+    end
+
+    context 'when visible' do
+      it 'calls render on itself' do
+        @draw_actor.is_visible = true
+        expect(@draw_actor).to receive(:render).with(@mat).once
+        @draw_actor.draw(@mat)
+      end
+    end
+
+    context 'when not visible' do
+      it 'does not call render on itself' do
+        @draw_actor.is_visible = false
+        expect(@draw_actor).not_to receive(:render)
+        @draw_actor.draw(@mat)
+      end
+    end
+
+    context 'with children' do
+      before(:all) do
+        @child1 = Gosling::Actor.new(@window)
+        @child2 = Gosling::Actor.new(@window)
+        @draw_actor.add_child(@child1)
+        @draw_actor.add_child(@child2)
+      end
+
+      context 'when are_children_visible is false' do
+        it 'draws itself, but not its children' do
+          @draw_actor.are_children_visible = false
+          expect(@child1).not_to receive(:draw)
+          expect(@child2).not_to receive(:draw)
+          @draw_actor.draw(@mat)
+          @draw_actor.are_children_visible = true
+        end
+      end
+
+      it 'calls draw on each of its children' do
+        expect(@child1).to receive(:draw).with(@mat).once
+        expect(@child2).to receive(:draw).with(@mat).once
+        @draw_actor.draw(@mat)
+      end
+
+      it 'passes its children a comprehensive transformation matrix' do
+        parameter_mat = Matrix[
+          [1, 0, 10],
+          [0, 1, 20],
+          [0, 0,  1]
+        ]
+        self_mat = Matrix[
+          [2, 0, 0],
+          [0, 3, 0],
+          [0, 0, 1]
+        ]
+        result_mat = parameter_mat * self_mat
+
+        allow(@draw_actor.transform).to receive(:to_matrix).and_return(self_mat)
+
+        expect(@child1).to receive(:draw).with(result_mat).once
+        expect(@child2).to receive(:draw).with(result_mat).once
+        @draw_actor.draw(parameter_mat)
+      end
+
+      after(:all) do
+        @draw_actor.children.each { |child| @draw_actor.remove_child(@child) }
+      end
+    end
+  end
+
+  describe '#is_point_in_bounds' do
+    it 'returns false' do
+      expect(@read_only_actor.is_point_in_bounds(Vector[0,0,1])).to be false
+    end
+  end
+
+  describe '#get_actor_at' do
+    before(:all) do
+      @parent = Gosling::Actor.new(@window)
+    end
+
+    context 'when tangible is false' do
+      it 'returns nil even if hit' do
+        @parent.is_tangible = false
+        allow(@parent).to receive(:is_point_in_bounds).and_return(true)
+        expect(@parent.get_actor_at(Vector[0,0,1])).to be == nil
+        @parent.is_tangible = true
+      end
+    end
+
+    context 'with no children' do
+      it 'returns itself if the point is within its bounds' do
+        allow(@parent).to receive(:is_point_in_bounds).and_return(true)
+        expect(@parent.get_actor_at(Vector[0,0,1])).to be == @parent
+      end
+
+      it 'returns nil if point is not within its bounds' do
+        allow(@parent).to receive(:is_point_in_bounds).and_return(false)
+        expect(@parent.get_actor_at(Vector[0,0,1])).to be == nil
+      end
+    end
+
+    context 'with two children' do
+      before(:all) do
+        @child1 = Gosling::Actor.new(@window)
+        @child2 = Gosling::Actor.new(@window)
+        @parent.add_child(@child1)
+        @parent.add_child(@child2)
+      end
+
+      context 'when the children are not tangible' do
+        it 'does not hit test any children' do
+          @parent.are_children_tangible = false
+          allow(@parent).to receive(:is_point_in_bounds).and_return(false, true)
+          allow(@child1).to receive(:is_point_in_bounds).and_return(true)
+          allow(@child2).to receive(:is_point_in_bounds).and_return(true)
+
+          expect(@parent.get_actor_at(Vector[0,0,1])).to be == nil
+          expect(@parent.get_actor_at(Vector[0,0,1])).to be == @parent
+          @parent.are_children_tangible = true
+        end
+      end
+
+      it "returns the second child if such is hit" do
+        allow(@parent).to receive(:is_point_in_bounds).and_return(false, true,  false, true)
+        allow(@child1).to receive(:is_point_in_bounds).and_return(false, false, true,  true)
+        allow(@child2).to receive(:is_point_in_bounds).and_return(true)
+
+        4.times { expect(@parent.get_actor_at(Vector[0,0,1])).to be == @child2 }
+      end
+
+      it "returns the first child if the second was not hit" do
+        allow(@parent).to receive(:is_point_in_bounds).and_return(false, true)
+        allow(@child1).to receive(:is_point_in_bounds).and_return(true)
+        allow(@child2).to receive(:is_point_in_bounds).and_return(false)
+
+        2.times { expect(@parent.get_actor_at(Vector[0,0,1])).to be == @child1 }
+      end
+
+      it "returns itself if neither child was hit" do
+        allow(@parent).to receive(:is_point_in_bounds).and_return(true)
+        allow(@child1).to receive(:is_point_in_bounds).and_return(false)
+        allow(@child2).to receive(:is_point_in_bounds).and_return(false)
+
+        expect(@parent.get_actor_at(Vector[0,0,1])).to be == @parent
+      end
+
+      it 'returns nil if point is not within it or its children' do
+        allow(@parent).to receive(:is_point_in_bounds).and_return(false)
+        allow(@child1).to receive(:is_point_in_bounds).and_return(false)
+        allow(@child2).to receive(:is_point_in_bounds).and_return(false)
+
+        expect(@parent.get_actor_at(Vector[0,0,1])).to be == nil
+      end
+
+      context 'with a mask child' do
+        it 'returns the parent if the child is hit' do
+          @child1.is_mask = true
+          allow(@parent).to receive(:is_point_in_bounds).and_return(false)
+          allow(@child1).to receive(:is_point_in_bounds).and_return(true)
+          allow(@child2).to receive(:is_point_in_bounds).and_return(false)
+
+          expect(@parent.get_actor_at(Vector[0,0,1])).to be == @parent
+          @child1.is_mask = false
+        end
+      end
+
+      after(:all) do
+        @parent.children.each { |child| @parent.remove_child(child) }
+      end
+    end
+  end
+
+  describe '#get_actors_at' do
+    before(:all) do
+      @parent = Gosling::Actor.new(@window)
+    end
+
+    context 'when tangible is false' do
+      it 'returns an empty array even if hit' do
+        @parent.is_tangible = false
+        allow(@parent).to receive(:is_point_in_bounds).and_return(true)
+        expect(@parent.get_actors_at(Vector[0,0,1])).to be_empty
+        @parent.is_tangible = true
+      end
+    end
+
+    context 'with no children' do
+      it 'returns an array containing itself if the point is within its bounds' do
+        allow(@parent).to receive(:is_point_in_bounds).and_return(true)
+        expect(@parent.get_actors_at(Vector[0,0,1])).to be == [@parent]
+      end
+
+      it 'returns an empty array if point is not within its bounds' do
+        allow(@parent).to receive(:is_point_in_bounds).and_return(false)
+        expect(@parent.get_actors_at(Vector[0,0,1])).to be_empty
+      end
+    end
+
+    context 'with two children' do
+      before(:all) do
+        @child1 = Gosling::Actor.new(@window)
+        @child2 = Gosling::Actor.new(@window)
+        @parent.add_child(@child1)
+        @parent.add_child(@child2)
+      end
+
+      context 'when the children are not tangible' do
+        it 'ignores the children' do
+          @parent.are_children_tangible = false
+          allow(@parent).to receive(:is_point_in_bounds).and_return(false, true)
+          allow(@child1).to receive(:is_point_in_bounds).and_return(true)
+          allow(@child2).to receive(:is_point_in_bounds).and_return(true, false)
+
+          expect(@parent.get_actors_at(Vector[0,0,1])).to be == []
+          expect(@parent.get_actors_at(Vector[0,0,1])).to be == [@parent]
+          @parent.are_children_tangible = true
+        end
+      end
+
+      it "returns an array containing all actors hit" do
+        allow(@parent).to receive(:is_point_in_bounds).and_return(false, true,  false, true, false, true,  false, true)
+        allow(@child1).to receive(:is_point_in_bounds).and_return(false, false, true,  true, false, false, true,  true)
+        allow(@child2).to receive(:is_point_in_bounds).and_return(false, false, false, false, true,  true, true,  true)
+
+        expect(@parent.get_actors_at(Vector[0,0,1])).to be == []
+        expect(@parent.get_actors_at(Vector[0,0,1])).to be == [@parent]
+        expect(@parent.get_actors_at(Vector[0,0,1])).to be == [@child1]
+        expect(@parent.get_actors_at(Vector[0,0,1])).to be == [@child1, @parent]
+        expect(@parent.get_actors_at(Vector[0,0,1])).to be == [@child2]
+        expect(@parent.get_actors_at(Vector[0,0,1])).to be == [@child2, @parent]
+        expect(@parent.get_actors_at(Vector[0,0,1])).to be == [@child2, @child1]
+        expect(@parent.get_actors_at(Vector[0,0,1])).to be == [@child2, @child1, @parent]
+      end
+
+      context 'with a mask child' do
+        before(:all) do
+          @child1.is_mask = true
+        end
+
+        it 'returns the parent if the child is hit' do
+          allow(@parent).to receive(:is_point_in_bounds).and_return(false)
+          allow(@child1).to receive(:is_point_in_bounds).and_return(true)
+          allow(@child2).to receive(:is_point_in_bounds).and_return(false)
+
+          expect(@parent.get_actors_at(Vector[0,0,1])).to be == [@parent]
+        end
+
+        it 'returns the parent only once if both children are masks and are hit' do
+          @child2.is_mask = true
+          allow(@parent).to receive(:is_point_in_bounds).and_return(false)
+          allow(@child1).to receive(:is_point_in_bounds).and_return(true)
+          allow(@child2).to receive(:is_point_in_bounds).and_return(true)
+
+          expect(@parent.get_actors_at(Vector[0,0,1])).to be == [@parent]
+          @child2.is_mask = false
+        end
+
+        it 'returns the parent only once if both parent and child are hit' do
+          allow(@parent).to receive(:is_point_in_bounds).and_return(true)
+          allow(@child1).to receive(:is_point_in_bounds).and_return(true)
+          allow(@child2).to receive(:is_point_in_bounds).and_return(false)
+
+          expect(@parent.get_actors_at(Vector[0,0,1])).to be == [@parent]
+        end
+
+        after(:all) do
+          @child1.is_mask = false
+        end
+      end
+
+      after(:all) do
+        @parent.children.each { |child| @parent.remove_child(child) }
+      end
+    end
+  end
+
+  describe '#get_global_transform' do
+    it 'returns a 3x3 matrix' do
+      result = @parent.get_global_transform
+      expect(result).to be_instance_of(Matrix)
+      expect(result.row_size).to be == 3
+      expect(result.column_size).to be == 3
+    end
+
+    it 'is a composite of its own transform plus all of its ancestors' do
+      centered_view = Gosling::Actor.new(@window)
+      centered_view.center_x = 10
+      centered_view.center_y = 2
+
+      scaled_view = Gosling::Actor.new(@window)
+      scaled_view.scale_x = 3
+      scaled_view.scale_y = 2
+
+      rotated_view = Gosling::Actor.new(@window)
+      rotated_view.rotation = Math::PI / 4
+
+      translated_view = Gosling::Actor.new(@window)
+      translated_view.x = -50
+      translated_view.y = 10
+
+      centered_view.add_child(scaled_view)
+      scaled_view.add_child(rotated_view)
+      rotated_view.add_child(translated_view)
+      translated_view.add_child(@parent)
+
+      expected = Matrix.identity(3) * centered_view.transform.to_matrix * scaled_view.transform.to_matrix * rotated_view.transform.to_matrix * translated_view.transform.to_matrix * @parent.transform.to_matrix
+
+      result = @parent.get_global_transform
+      expect(result).to be == expected
+
+      translated_view.remove_child(@parent)
+    end
+  end
+
+  describe '#get_global_position' do
+    it 'returns a 3d vector' do
+      result = @parent.get_global_position
+      expect(result).to be_instance_of(Vector)
+      expect(result.size).to be == 3
+    end
+
+    context 'with a long ancestry' do
+      before do
+        @parent.x = 0
+        @parent.y = 0
+        @parent.center_x = 0
+        @parent.center_y = 0
+        @parent.scale_x = 1
+        @parent.scale_y = 1
+        @parent.rotation = 0
+
+        centered_view = Gosling::Actor.new(@window)
+        centered_view.center_x = 10
+        centered_view.center_y = 2
+
+        scaled_view = Gosling::Actor.new(@window)
+        scaled_view.scale_x = 3
+        scaled_view.scale_y = 2
+
+        rotated_view = Gosling::Actor.new(@window)
+        rotated_view.rotation = Math::PI / 2
+
+        translated_view = Gosling::Actor.new(@window)
+        translated_view.x = -50
+        translated_view.y = 10
+
+        centered_view.add_child(scaled_view)
+        scaled_view.add_child(rotated_view)
+        rotated_view.add_child(translated_view)
+        translated_view.add_child(@parent)
+
+        @ancestry = [
+          centered_view,
+          scaled_view,
+          rotated_view,
+          translated_view,
+          @parent
+        ]
+      end
+
+      it 'respects all ancestors' do
+        result = @parent.get_global_position
+        expect(result).to be == Vector[(0 + 10) * 3 - 10, (0 - 50) * -2 - 2, 0]
+      end
+
+      after do
+        @ancestry.each { |actor| actor.parent.remove_child(actor) if actor.parent }
+      end
+    end
+  end
+
+  describe '#alpha' do
+    it 'returns the alpha (transparency) value' do
+      expect(@parent.alpha).to be_kind_of(Numeric)
+    end
+
+    it 'sets the alpha (transparency) value' do
+      actor = Gosling::Actor.new(@window)
+
+      actor.alpha = 128
+      expect(actor.alpha).to be == 128
+    end
+
+    it 'forces numeric values to be between 0 and 255' do
+      actor = Gosling::Actor.new(@window)
+
+      actor.alpha = -128
+      expect(actor.alpha).to be == 0
+      actor.alpha = -1
+      expect(actor.alpha).to be == 0
+      actor.alpha = 256
+      expect(actor.alpha).to be == 255
+      actor.alpha = 1024
+      expect(actor.alpha).to be == 255
+    end
+  end
+
+  describe '#red' do
+    it 'returns the red value' do
+      expect(@parent.red).to be_kind_of(Numeric)
+    end
+
+    it 'sets the red value' do
+      actor = Gosling::Actor.new(@window)
+
+      actor.red = 128
+      expect(actor.red).to be == 128
+    end
+
+    it 'forces numeric values to be between 0 and 255' do
+      actor = Gosling::Actor.new(@window)
+
+      actor.red = -128
+      expect(actor.red).to be == 0
+      actor.red = -1
+      expect(actor.red).to be == 0
+      actor.red = 256
+      expect(actor.red).to be == 255
+      actor.red = 1024
+      expect(actor.red).to be == 255
+    end
+  end
+
+  describe '#green' do
+    it 'returns the green value' do
+      expect(@parent.green).to be_kind_of(Numeric)
+    end
+
+    it 'sets the green value' do
+      actor = Gosling::Actor.new(@window)
+
+      actor.green = 128
+      expect(actor.green).to be == 128
+    end
+
+    it 'forces numeric values to be between 0 and 255' do
+      actor = Gosling::Actor.new(@window)
+
+      actor.green = -128
+      expect(actor.green).to be == 0
+      actor.green = -1
+      expect(actor.green).to be == 0
+      actor.green = 256
+      expect(actor.green).to be == 255
+      actor.green = 1024
+      expect(actor.green).to be == 255
+    end
+  end
+
+  describe '#blue' do
+    it 'returns the blue value' do
+      expect(@parent.blue).to be_kind_of(Numeric)
+    end
+
+    it 'sets the blue value' do
+      actor = Gosling::Actor.new(@window)
+
+      actor.blue = 128
+      expect(actor.blue).to be == 128
+    end
+
+    it 'forces numeric values to be between 0 and 255' do
+      actor = Gosling::Actor.new(@window)
+
+      actor.blue = -128
+      expect(actor.blue).to be == 0
+      actor.blue = -1
+      expect(actor.blue).to be == 0
+      actor.blue = 256
+      expect(actor.blue).to be == 255
+      actor.blue = 1024
+      expect(actor.blue).to be == 255
+    end
+  end
+end