ruby2d 0.9.4 → 0.11.1

data/lib/ruby2d/text.rb

@@ -4,8 +4,8 @@ module Ruby2D
   class Text
     include Renderable
 
-    attr_reader :text, :font
-    attr_accessor :x, :y, :size, :rotate, :data
+    attr_reader :text, :size
+    attr_accessor :x, :y, :rotate, :data
 
     def initialize(text, opts = {})
       @x = opts[:x] || 0
@@ -14,22 +14,65 @@ module Ruby2D
       @text = text.to_s
       @size = opts[:size] || 20
       @rotate = opts[:rotate] || 0
+      @style = opts[:style]
       self.color = opts[:color] || 'white'
-      self.opacity = opts[:opacity] if opts[:opacity]
-      @font = opts[:font] || Font.default
-      unless File.exist? @font
-        raise Error, "Cannot find font file `#{@font}`"
-      end
-      unless ext_init
-        raise Error, "Text `#{@text}` cannot be created"
-      end
-      add
+      self.color.opacity = opts[:opacity] if opts[:opacity]
+      @font_path = opts[:font] || Font.default
+      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
-      ext_set(@text)
+      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
+      )
+    end
+
+    def create_font
+      @font = Font.load(@font_path, @size, @style)
+    end
+
+    def create_texture
+      if defined?(@texture)
+        @texture.delete
+      end
+
+      @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

@@ -17,7 +17,7 @@ module Ruby2D
       @y3 = opts[:y3] || 100
       @z  = opts[:z]  || 0
       self.color = opts[:color] || 'white'
-      self.opacity = opts[:opacity] if opts[:opacity]
+      self.color.opacity = opts[:opacity] if opts[:opacity]
       add
     end
 
@@ -38,8 +38,26 @@ module Ruby2D
       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

data/lib/ruby2d/version.rb

@@ -1,5 +1,5 @@
 # Ruby2D::VERSION
 
 module Ruby2D
-  VERSION = '0.9.4'
+  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