ruby2d-rpeck-windows 0.11.1

data/lib/ruby2d/sprite.rb

@@ -0,0 +1,232 @@
+# Ruby2D::Sprite
+
+module Ruby2D
+  class Sprite
+    include Renderable
+
+    attr_reader :path
+    attr_accessor :rotate, :loop, :clip_x, :clip_y, :clip_width, :clip_height, :data, :x, :y, :width, :height
+
+    def initialize(path, opts = {})
+      # Sprite image file path
+      @path = path
+
+      # Initialize the sprite texture
+      @texture = Texture.new(*Image.load_image(@path))
+      @img_width = @texture.width
+      @img_height = @texture.height
+
+      # Coordinates, size, and rotation of the sprite
+      @x = opts[:x] || 0
+      @y = opts[:y] || 0
+      @z = opts[:z] || 0
+      @rotate = opts[:rotate] || 0
+      self.color = opts[:color] || 'white'
+      self.color.opacity = opts[:opacity] if opts[:opacity]
+
+      # Flipping status
+      @flip = nil
+
+      # Animation attributes
+      @start_time = 0.0
+      @loop = opts[:loop] || false
+      @frame_time = opts[:time] || 300
+      @animations = opts[:animations] || {}
+      @playing = false
+      @current_frame = opts[:default] || 0
+      @last_frame = 0
+      @done_proc = nil
+
+      # The clipping rectangle
+      @clip_x = opts[:clip_x] || 0
+      @clip_y = opts[:clip_y] || 0
+      @clip_width  = opts[:clip_width]  || @img_width
+      @clip_height = opts[:clip_height] || @img_height
+
+      # Dimensions
+      @width  = opts[:width]  || nil
+      @height = opts[:height] || nil
+
+      # Set the default animation
+      @animations[:default] = 0..(@img_width / @clip_width) - 1
+
+      # Set the sprite defaults
+      @defaults = {
+        animation:   @animations.first[0],
+        frame:       @current_frame,
+        frame_time:  @frame_time,
+        clip_x:      @clip_x,
+        clip_y:      @clip_y,
+        clip_width:  @clip_width,
+        clip_height: @clip_height,
+        loop:        @loop
+      }
+
+      # Add the sprite to the window
+      unless opts[:show] == false then add end
+    end
+
+    # Play an animation
+    def play(opts = {}, &done_proc)
+
+      animation = opts[:animation]
+      loop = opts[:loop]
+      flip = opts[:flip]
+
+      if !@playing || (animation != @playing_animation && animation != nil) || flip != @flip
+
+        @playing = true
+        @playing_animation = animation || :default
+        frames = @animations[@playing_animation]
+        flip_sprite(flip)
+        @done_proc = done_proc
+
+        case frames
+        # When animation is a range, play through frames horizontally
+        when Range
+          @first_frame   = frames.first || @defaults[:frame]
+          @current_frame = frames.first || @defaults[:frame]
+          @last_frame    = frames.last
+        # When array...
+        when Array
+          @first_frame   = 0
+          @current_frame = 0
+          @last_frame    = frames.length - 1
+        end
+
+        # Set looping
+        @loop = loop == true || @defaults[:loop] ? true : false
+
+        set_frame
+        restart_time
+      end
+      self
+    end
+
+    # Stop the current animation and set to the default frame
+    def stop(animation = nil)
+      if !animation || animation == @playing_animation
+        @playing = false
+        @playing_animation = @defaults[:animation]
+        @current_frame = @defaults[:frame]
+        set_frame
+      end
+    end
+
+    # Flip the sprite
+    def flip_sprite(flip)
+
+      # The sprite width and height must be set for it to be flipped correctly
+      if (!@width || !@height) && flip
+        raise Error,
+         "Sprite width and height must be set in order to flip; " +
+         "occured playing animation `:#{@playing_animation}` with image `#{@path}`"
+      end
+
+      @flip = flip
+    end
+
+    # Reset frame to defaults
+    def reset_clipping_rect
+      @clip_x      = @defaults[:clip_x]
+      @clip_y      = @defaults[:clip_y]
+      @clip_width  = @defaults[:clip_width]
+      @clip_height = @defaults[:clip_height]
+    end
+
+    # Set the position of the clipping retangle based on the current frame
+    def set_frame
+      frames = @animations[@playing_animation]
+      case frames
+      when Range
+        reset_clipping_rect
+        @clip_x = @current_frame * @clip_width
+      when Array
+        f = frames[@current_frame]
+        @clip_x      = f[:x]      || @defaults[:clip_x]
+        @clip_y      = f[:y]      || @defaults[:clip_y]
+        @clip_width  = f[:width]  || @defaults[:clip_width]
+        @clip_height = f[:height] || @defaults[:clip_height]
+        @frame_time  = f[:time]   || @defaults[:frame_time]
+      end
+    end
+
+    # Calculate the time in ms
+    def elapsed_time
+      (Time.now.to_f - @start_time) * 1000
+    end
+
+    # Restart the timer
+    def restart_time
+      @start_time = Time.now.to_f
+    end
+
+    # Update the sprite animation, called by `render`
+    def update
+      if @playing
+
+        # Advance the frame
+        unless elapsed_time <= (@frame_time || @defaults[:frame_time])
+          @current_frame += 1
+          restart_time
+        end
+
+        # Reset to the starting frame if all frames played
+        if @current_frame > @last_frame
+          @current_frame = @first_frame
+          unless @loop
+            # Stop animation and play block, if provided
+            stop
+            if @done_proc then @done_proc.call end
+            @done_proc = nil
+          end
+        end
+
+        set_frame
+      end
+    end
+
+    def draw(opts = {})
+      Window.render_ready_check
+
+      opts[:width] = opts[:width] || (@width || @clip_width)
+      opts[:height] = opts[:height] || (@height || @clip_height)
+      opts[:rotate] = opts[:rotate] || @rotate
+      opts[:clip_x] = opts[:clip_x] || @clip_x
+      opts[:clip_y] = opts[:clip_y] || @clip_y
+      opts[:clip_width] = opts[:clip_width] || @clip_width
+      opts[:clip_height] = opts[:clip_height] || @clip_height
+      unless opts[:color]
+        opts[:color] = [1.0, 1.0, 1.0, 1.0]
+      end
+
+      render(x: opts[:x], y: opts[:y], width: opts[:width], height: opts[:height], color: Color.new(color), rotate: opts[:rotate], crop: {
+        x: opts[:clip_x],
+        y: opts[:clip_y],
+        width: opts[:clip_width],
+        height: opts[:clip_height],
+        image_width: @img_width,
+        image_height: @img_height,
+      })
+    end
+
+    private
+
+    def render(x: @x, y: @y, width: (@width || @clip_width), height: (@height || @clip_height) , color: @color, rotate: @rotate, flip: @flip, crop: {
+      x: @clip_x,
+      y: @clip_y,
+      width: @clip_width,
+      height: @clip_height,
+      image_width: @img_width,
+      image_height: @img_height,
+    })
+      update
+
+      vertices = Vertices.new(x, y, width, height, rotate, crop: crop, flip: flip)
+
+      @texture.draw(
+        vertices.coordinates, vertices.texture_coordinates, color
+      )
+    end
+  end
+end

data/lib/ruby2d/square.rb

@@ -0,0 +1,37 @@
+# Ruby2D::Square
+
+module Ruby2D
+  class Square < Rectangle
+
+    attr_reader :size
+
+    def initialize(opts = {})
+      @x = opts[:x] || 0
+      @y = opts[:y] || 0
+      @z = opts[:z] || 0
+      @width = @height = @size = opts[:size] || 100
+      self.color = opts[:color] || 'white'
+      self.color.opacity = opts[:opacity] if opts[:opacity]
+      update_coords(@x, @y, @size, @size)
+      add
+    end
+
+    # Set the size of the square
+    def size=(s)
+      self.width = self.height = @size = s
+    end
+
+    def self.draw(opts = {})
+      ext_draw([
+        opts[:x]              , opts[:y]              , opts[:color][0][0], opts[:color][0][1], opts[:color][0][2], opts[:color][0][3],
+        opts[:x] + opts[:size], opts[:y]              , opts[:color][1][0], opts[:color][1][1], opts[:color][1][2], opts[:color][1][3],
+        opts[:x] + opts[:size], opts[:y] + opts[:size], opts[:color][2][0], opts[:color][2][1], opts[:color][2][2], opts[:color][2][3],
+        opts[:x]              , opts[:y] + opts[:size], opts[:color][3][0], opts[:color][3][1], opts[:color][3][2], opts[:color][3][3]
+      ])
+    end
+
+    # Make the inherited width and height attribute accessors private
+    private :width=, :height=
+
+  end
+end

data/lib/ruby2d/text.rb

@@ -0,0 +1,76 @@
+# Ruby2D::Text
+
+module Ruby2D
+  class Text
+    include Renderable
+
+    attr_reader :text, :size
+    attr_accessor :x, :y, :rotate, :data
+
+    def initialize(text, opts = {})
+      @x = opts[:x] || 0
+      @y = opts[:y] || 0
+      @z = opts[:z] || 0
+      @text = text.to_s
+      @size = opts[:size] || 20
+      @rotate = opts[:rotate] || 0
+      @style = opts[:style]
+      self.color = opts[:color] || 'white'
+      self.color.opacity = opts[:opacity] if opts[:opacity]
+      @font_path = opts[:font] || Font.default # error because of path
+      create_font
+      create_texture
+
+      unless opts[:show] == false then add end
+    end
+
+    # Returns the path of the font as a string
+    def font
+      @font_path
+    end
+
+    def text=(msg)
+      @text = msg.to_s
+      create_texture
+    end
+
+    def size=(size)
+      @size = size
+      create_font
+      create_texture
+    end
+
+    def draw(opts = {})
+      Window.render_ready_check
+
+      opts[:rotate] = opts[:rotate] || @rotate
+      unless opts[:color]
+        opts[:color] = [1.0, 1.0, 1.0, 1.0]
+      end
+      
+      render(x: opts[:x], y: opts[:y], color: Color.new(opts[:color]), rotate: opts[:rotate])
+    end
+
+    private
+
+    def render(x: @x, y: @y, color: @color, rotate: @rotate)
+      vertices = Vertices.new(x, y, @width, @height, rotate)
+
+      @texture.draw(
+        vertices.coordinates, vertices.texture_coordinates, color # <- this is causing the error
+      )
+    end
+
+    def create_font
+      @font = Font.load(@font_path, @size, @style)
+    end
+
+    def create_texture
+      @texture.delete if @texture
+
+      @texture = Texture.new(*Text.ext_load_text(@font.ttf_font, @text))
+      @width = @texture.width
+      @height = @texture.height
+    end
+  end
+end

data/lib/ruby2d/texture.rb

@@ -0,0 +1,28 @@
+# Ruby2D::Text
+
+module Ruby2D
+    class Texture
+      attr_reader :width, :height, :texture_id
+
+      def initialize(pixel_data, width, height)
+        @pixel_data = pixel_data
+        @width = width
+        @height = height
+        @texture_id = 0
+      end
+
+      def draw(coordinates, texture_coordinates, color)
+        if @texture_id == 0
+          @texture_id = ext_create(@pixel_data, @width, @height)
+          @pixel_data = nil
+        end
+
+        color = [color.r, color.g, color.b, color.a]
+        ext_draw(coordinates, texture_coordinates, color, @texture_id)
+      end
+
+      def delete
+        ext_delete(@texture_id)
+      end
+    end
+end

data/lib/ruby2d/tileset.rb

@@ -0,0 +1,87 @@
+# Ruby2D::Tileset
+
+module Ruby2D
+  class Tileset
+    include Renderable
+
+    def initialize(path, opts = {})
+      @path = path
+
+      # Initialize the tileset texture
+      @texture = Texture.new(*Image.load_image(@path))
+      @width = opts[:width] || @texture.width
+      @height = opts[:height] || @texture.height
+      @z = opts[:z] || 0
+
+      @tiles = []
+      @defined_tiles = {}
+      @padding = opts[:padding] || 0
+      @spacing = opts[:spacing] || 0
+      @tile_width = opts[:tile_width]
+      @tile_height = opts[:tile_height]
+      @scale = opts[:scale] || 1
+
+      unless opts[:show] == false then add end
+    end
+
+    def define_tile(name, x, y, rotate: 0, flip: nil)
+      @defined_tiles[name] = { x: x, y: y , rotate: rotate, flip: flip }
+    end
+
+    def set_tile(name, coordinates)
+      tile = @defined_tiles.fetch(name)
+
+      coordinates.each do |coordinate|
+        @tiles.push({
+          tile_x: tile.fetch(:x), 
+          tile_y: tile.fetch(:y), 
+          tile_rotate: tile.fetch(:rotate),
+          tile_flip: tile.fetch(:flip),
+          x: coordinate.fetch(:x),
+          y: coordinate.fetch(:y)
+        })
+      end
+    end
+
+    def clear_tiles
+      @tiles = []
+    end
+  end
+
+  def draw
+    Window.render_ready_check
+
+    render
+  end
+
+  private
+
+
+  def render
+    scaled_padding = @padding * @scale
+    scaled_spacing = @spacing * @scale
+    scaled_tile_width = @tile_width * @scale
+    scaled_tile_height = @tile_height * @scale
+    scaled_width = @width * @scale
+    scaled_height = @height * @scale
+
+    @tiles.each do |tile|
+      crop = {
+        x: scaled_padding + (tile.fetch(:tile_x) * (scaled_spacing + scaled_tile_width)),
+        y: scaled_padding + (tile.fetch(:tile_y) * (scaled_spacing + scaled_tile_height)),
+        width: scaled_tile_width,
+        height: scaled_tile_height,
+        image_width: scaled_width,
+        image_height: scaled_height,
+      }
+
+      color = defined?(@color) ? @color : Color.new([1.0, 1.0, 1.0, 1.0])
+
+      vertices = Vertices.new(tile.fetch(:x), tile.fetch(:y), scaled_tile_width, scaled_tile_height, tile.fetch(:tile_rotate), crop: crop, flip: tile.fetch(:tile_flip))
+
+      @texture.draw(
+        vertices.coordinates, vertices.texture_coordinates, color
+      )
+    end
+  end
+end

data/lib/ruby2d/triangle.rb

@@ -0,0 +1,82 @@
+# Ruby2D::Triangle
+
+module Ruby2D
+  class Triangle
+    include Renderable
+
+    attr_accessor :x1, :y1, :c1,
+                  :x2, :y2, :c2,
+                  :x3, :y3, :c3
+
+    def initialize(opts= {})
+      @x1 = opts[:x1] || 50
+      @y1 = opts[:y1] || 0
+      @x2 = opts[:x2] || 100
+      @y2 = opts[:y2] || 100
+      @x3 = opts[:x3] || 0
+      @y3 = opts[:y3] || 100
+      @z  = opts[:z]  || 0
+      self.color = opts[:color] || 'white'
+      self.color.opacity = opts[:opacity] if opts[:opacity]
+      add
+    end
+
+    def color=(c)
+      @color = Color.set(c)
+      update_color(@color)
+    end
+
+    # A point is inside a triangle if the area of 3 triangles, constructed from
+    # triangle sides and the given point, is equal to the area of triangle.
+    def contains?(x, y)
+      self_area = triangle_area(@x1, @y1, @x2, @y2, @x3, @y3)
+      questioned_area =
+        triangle_area(@x1, @y1, @x2, @y2, x, y) +
+        triangle_area(@x2, @y2, @x3, @y3, x, y) +
+        triangle_area(@x3, @y3, @x1, @y1, x, y)
+
+      questioned_area <= self_area
+    end
+
+    def self.draw(opts = {})
+      Window.render_ready_check
+
+      ext_draw([
+        opts[:x1], opts[:y1], opts[:color][0][0], opts[:color][0][1], opts[:color][0][2], opts[:color][0][3],
+        opts[:x2], opts[:y2], opts[:color][1][0], opts[:color][1][1], opts[:color][1][2], opts[:color][1][3],
+        opts[:x3], opts[:y3], opts[:color][2][0], opts[:color][2][1], opts[:color][2][2], opts[:color][2][3]
+      ])
+    end
+
+    private
+
+    def render
+      self.class.ext_draw([
+        @x1, @y1, @c1.r, @c1.g, @c1.b, @c1.a,
+        @x2, @y2, @c2.r, @c2.g, @c2.b, @c2.a,
+        @x3, @y3, @c3.r, @c3.g, @c3.b, @c3.a
+      ])
+    end
+
+    def triangle_area(x1, y1, x2, y2, x3, y3)
+      (x1*y2 + x2*y3 + x3*y1 - x3*y2 - x1*y3 - x2*y1).abs / 2
+    end
+
+    def update_color(c)
+      if c.is_a? Color::Set
+        if c.length == 3
+          @c1 = c[0]
+          @c2 = c[1]
+          @c3 = c[2]
+        else
+          raise ArgumentError, "`#{self.class}` requires 3 colors, one for each vertex. #{c.length} were given."
+        end
+      else
+        @c1 = c
+        @c2 = c
+        @c3 = c
+      end
+    end
+
+  end
+end

data/lib/ruby2d/version.rb

@@ -0,0 +1,5 @@
+# Ruby2D::VERSION
+
+module Ruby2D
+  VERSION = '0.11.1'
+end

data/lib/ruby2d/vertices.rb

@@ -0,0 +1,84 @@
+# Ruby2D::Vertices
+
+# This class generates a vertices array which are passed to the openGL rendering code.
+# The vertices array is split up into 4 groups (1 - top left, 2 - top right, 3 - bottom right, 4 - bottom left)
+# This class is responsible for transforming textures, it can scale / crop / rotate and flip textures
+
+module Ruby2D
+  class Vertices
+    def initialize(x, y, width, height, rotate, crop: nil, flip: nil)
+      @flip = flip
+      @x = x
+      @y = y
+      @width = width.to_f
+      @height = height.to_f
+
+      if @flip == :horizontal || @flip == :both
+        @x = @x + @width
+        @width = -@width
+      end
+
+      if @flip == :vertical || @flip == :both
+        @y = y + @height
+        @height = -@height
+      end
+
+      @rotate = rotate
+      @rx = @x + (@width / 2.0)
+      @ry = @y + (@height / 2.0)
+      @crop = crop
+    end
+
+    def coordinates
+      x1, y1 = rotate(@x,          @y);           # Top left
+      x2, y2 = rotate(@x + @width, @y);           # Top right
+      x3, y3 = rotate(@x + @width, @y + @height); # Bottom right
+      x4, y4 = rotate(@x,          @y + @height); # Bottom left
+
+      [ x1, y1, x2, y2, x3, y3, x4, y4 ]
+    end
+
+    def texture_coordinates
+      if @crop.nil?
+        tx1 = 0.0; ty1 = 0.0 # Top left
+        tx2 = 1.0; ty2 = 0.0 # Top right
+        tx3 = 1.0; ty3 = 1.0 # Bottom right
+        tx4 = 0.0; ty4 = 1.0 # Bottom left
+      else
+        tx1 = @crop[:x] / @crop[:image_width].to_f; ty1 = @crop[:y] / @crop[:image_height].to_f # Top left
+        tx2 = tx1 + (@crop[:width] / @crop[:image_width].to_f); ty2 = ty1                       # Top right
+        tx3 = tx2; ty3 = ty1 + (@crop[:height] / @crop[:image_height].to_f)                     # Botttom right
+        tx4 = tx1; ty4 = ty3                                                                    # Bottom left
+      end
+
+      [ tx1, ty1, tx2, ty2, tx3, ty3, tx4, ty4 ]
+    end
+
+    private
+
+    def rotate(x, y)
+      return [x, y] if @rotate == 0
+
+      # Convert from degrees to radians
+      angle = @rotate * Math::PI / 180.0
+
+      # Get the sine and cosine of the angle
+      sa = Math.sin(angle)
+      ca = Math.cos(angle)
+
+      # Translate point to origin
+      x -= @rx
+      y -= @ry
+
+      # Rotate point
+      xnew = x * ca - y * sa;
+      ynew = x * sa + y * ca;
+
+      # Translate point back
+      x = xnew + @rx;
+      y = ynew + @ry;
+
+      [x, y]
+    end
+  end
+end