cyberarm_engine 0.13.1 → 0.17.1

data/lib/cyberarm_engine/opengl/texture.rb

@@ -0,0 +1,69 @@
+module CyberarmEngine
+  class Texture
+    DEFAULT_TEXTURE = "#{CYBERARM_ENGINE_ROOT_PATH}/assets/textures/default.png".freeze
+
+    CACHE = {}
+
+    def self.release_textures
+      CACHE.values.each do |id|
+        glDeleteTextures(id)
+      end
+    end
+
+    def self.from_cache(path, retro)
+      CACHE.dig("#{path}?retro=#{retro}")
+    end
+
+    attr_reader :id
+
+    def initialize(path: nil, image: nil, retro: false)
+      raise "keyword :path or :image must be provided!" if path.nil? && image.nil?
+
+      @retro = retro
+      @path = path
+
+      if @path
+        unless File.exist?(@path)
+          warn "Missing texture at: #{@path}"
+          @retro = true # override retro setting
+          @path = DEFAULT_TEXTURE
+        end
+
+        if texture = Texture.from_cache(@path, @retro)
+          @id = texture.id
+          return
+        end
+
+        image = load_image(@path)
+        @id = create_from_image(image)
+      else
+        @id = create_from_image(image)
+      end
+    end
+
+    def load_image(path)
+      CACHE["#{path}?retro=#{@retro}"] = self
+      Gosu::Image.new(path, retro: @retro)
+    end
+
+    def create_from_image(image)
+      array_of_pixels = image.to_blob
+
+      tex_names_buf = " " * 4
+      glGenTextures(1, tex_names_buf)
+      texture_id = tex_names_buf.unpack1("L2")
+
+      glBindTexture(GL_TEXTURE_2D, texture_id)
+      glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, image.width, image.height, 0, GL_RGBA, GL_UNSIGNED_BYTE, array_of_pixels)
+      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT)
+      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT)
+      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST) if @retro
+      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR) unless @retro
+      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR)
+      glGenerateMipmap(GL_TEXTURE_2D)
+      gl_error?
+
+      texture_id
+    end
+  end
+end

data/lib/cyberarm_engine/ray.rb

@@ -4,7 +4,7 @@ module CyberarmEngine
       raise "Origin must be a Vector!" unless origin.is_a?(Vector)
       raise "Direction must be a Vector!" unless direction.is_a?(Vector)
 
-      @origin  = origin
+      @origin = origin
       @direction = direction
       @range = range
 
@@ -42,15 +42,15 @@ module CyberarmEngine
       tmin = max(tmin, min(tz1, tz2))
       tmax = min(tmax, max(tz1, tz2))
 
-      return tmax >= max(tmin, 0.0);
+      tmax >= max(tmin, 0.0)
     end
 
     def min(x, y)
-      ((x) < (y) ? (x) : (y))
+      ((x) < (y) ? x : y)
     end
 
     def max(x, y)
-      ((x) > (y) ? (x) : (y))
+      ((x) > (y) ? x : y)
     end
   end
-end
+end

data/lib/cyberarm_engine/stats.rb

@@ -0,0 +1,21 @@
+module CyberarmEngine
+  class Stats
+    @@hash = {
+      gui_recalculations_last_frame: 0
+    }
+
+    def self.get(key)
+      @@hash.dig(key)
+    end
+
+    def self.increment(key, n)
+      @@hash[key] += n
+    end
+
+    def self.clear
+      @@hash.each do |key, _value|
+        @@hash[key] = 0
+      end
+    end
+  end
+end

data/lib/cyberarm_engine/text.rb

@@ -5,39 +5,40 @@ module CyberarmEngine
     attr_accessor :x, :y, :z, :size, :options
     attr_reader :text, :textobject, :factor_x, :factor_y, :color, :shadow, :shadow_size, :shadow_alpha, :shadow_color
 
-    def initialize(text, options={})
+    def initialize(text, options = {})
       @text = text.to_s || ""
       @options = options
       @size = options[:size] || 18
-      @font = options[:font] || "sans-serif"#Gosu.default_font_name
+      @font = options[:font] || Gosu.default_font_name
       @x = options[:x] || 0
       @y = options[:y] || 0
       @z = options[:z] || 1025
       @factor_x = options[:factor_x]  || 1
       @factor_y = options[:factor_y]  || 1
       @color    = options[:color]     || Gosu::Color::WHITE
-      @alignment= options[:alignment] || nil
+      @mode     = options[:mode]      || :default
+      @alignment = options[:alignment] || nil
       @shadow   = true  if options[:shadow] == true
       @shadow   = false if options[:shadow] == false
-      @shadow   = true if options[:shadow] == nil
-      @shadow_size = options[:shadow_size] ? options[:shadow_size] : 1
-      @shadow_alpha= options[:shadow_alpha] ? options[:shadow_alpha] : 30
-      @shadow_alpha= options[:shadow_alpha] ? options[:shadow_alpha] : 30
-      @shadow_color= options[:shadow_color]
+      @shadow   = true if options[:shadow].nil?
+      @shadow_size = options[:shadow_size] || 1
+      @shadow_alpha = options[:shadow_alpha] || 30
+      @shadow_alpha = options[:shadow_alpha] || 30
+      @shadow_color = options[:shadow_color]
       @textobject = check_cache(@size, @font)
 
       if @alignment
         case @alignment
         when :left
-          @x = 0+BUTTON_PADDING
+          @x = 0 + BUTTON_PADDING
         when :center
-          @x = ($window.width/2)-(@textobject.text_width(@text)/2)
+          @x = ($window.width / 2) - (@textobject.text_width(@text) / 2)
         when :right
-          @x = $window.width-BUTTON_PADDING-@textobject.text_width(@text)
+          @x = $window.width - BUTTON_PADDING - @textobject.text_width(@text)
         end
       end
 
-      return self
+      self
     end
 
     def check_cache(size, font_name)
@@ -61,7 +62,7 @@ module CyberarmEngine
         CACHE[@size][@font] = font
       end
 
-      return font
+      font
     end
 
     def text=(string)
@@ -73,64 +74,76 @@ module CyberarmEngine
       @rendered_shadow = nil
       @factor_x = n
     end
+
     def factor_y=(n)
       @rendered_shadow = nil
       @factor_y = n
     end
+
     def color=(color)
       @rendered_shadow = nil
       @color = color
     end
+
     def shadow=(boolean)
       @rendered_shadow = nil
       @shadow = boolean
     end
+
     def shadow_size=(n)
       @rendered_shadow = nil
       @shadow_size = n
     end
+
     def shadow_alpha=(n)
       @rendered_shadow = nil
       @shadow_alpha = n
     end
+
     def shadow_color=(n)
       @rendered_shadow = nil
       @shadow_color = n
     end
 
-    def width
-      textobject.text_width(@text)
+    def width(text = @text)
+      textobject.text_width(text)
+    end
+
+    def markup_width(text = @text)
+      textobject.markup_width(text)
     end
 
-    def height
-      @text.lines.count > 0 ? (@text.lines.count) * textobject.height : @textobject.height
+    def height(text = @text)
+      text.lines.count > 0 ? text.lines.count * textobject.height : @textobject.height
     end
 
-    def draw
+    def draw(method = :draw_markup)
       if @shadow && !ARGV.join.include?("--no-shadow")
         shadow_alpha = @color.alpha <= 30 ? @color.alpha : @shadow_alpha
-        shadow_color = @shadow_color ? @shadow_color : Gosu::Color.rgba(@color.red, @color.green, @color.blue, shadow_alpha)
+        shadow_color = @shadow_color || Gosu::Color.rgba(@color.red, @color.green, @color.blue,
+                                                         shadow_alpha)
+        white = Gosu::Color::WHITE
 
         _x = @shadow_size
         _y = @shadow_size
 
-        @rendered_shadow ||= Gosu.render((self.width+(shadow_size*2)).ceil, (self.height+(@shadow_size*2)).ceil) do
-          @textobject.draw_markup(@text, _x-@shadow_size, _y, @z)
-          @textobject.draw_markup(@text, _x-@shadow_size, _y-@shadow_size, @z)
+        @rendered_shadow ||= Gosu.render((width + (shadow_size * 2)).ceil, (height + (@shadow_size * 2)).ceil) do
+          @textobject.send(method, @text, _x - @shadow_size, _y, @z, @factor_x, @factor_y, white, :add)
+          @textobject.send(method, @text, _x - @shadow_size, _y - @shadow_size, @z, @factor_x, @factor_y, white, :add)
 
-          @textobject.draw_markup(@text, _x, _y-@shadow_size, @z, @factor_x)
-          @textobject.draw_markup(@text, _x+@shadow_size, _y-@shadow_size, @z)
+          @textobject.send(method, @text, _x, _y - @shadow_size, @z, @factor_x, @factor_y, white, :add)
+          @textobject.send(method, @text, _x + @shadow_size, _y - @shadow_size, @z, @factor_x, @factor_y, white, :add)
 
-          @textobject.draw_markup(@text, _x, _y+@shadow_size, @z)
-          @textobject.draw_markup(@text, _x-@shadow_size, _y+@shadow_size, @z)
+          @textobject.send(method, @text, _x, _y + @shadow_size, @z, @factor_x, @factor_y, white, :add)
+          @textobject.send(method, @text, _x - @shadow_size, _y + @shadow_size, @z, @factor_x, @factor_y, white, :add)
 
-          @textobject.draw_markup(@text, _x+@shadow_size, _y, @z)
-          @textobject.draw_markup(@text, _x+@shadow_size, _y+@shadow_size, @z)
+          @textobject.send(method, @text, _x + @shadow_size, _y, @z, @factor_x, @factor_y, white, :add)
+          @textobject.send(method, @text, _x + @shadow_size, _y + @shadow_size, @z, @factor_x, @factor_y, white, :add)
         end
-        @rendered_shadow.draw(@x-@shadow_size, @y-@shadow_size, @z, @factor_x, @factor_y, shadow_color)
+        @rendered_shadow.draw(@x - @shadow_size, @y - @shadow_size, @z, @factor_x, @factor_y, shadow_color)
       end
 
-      @textobject.draw_markup(@text, @x, @y, @z, @factor_x, @factor_y, @color)
+      @textobject.send(method, @text, @x, @y, @z, @factor_x, @factor_y, @color, @mode)
     end
 
     def alpha=(n)
@@ -141,6 +154,7 @@ module CyberarmEngine
       @color.alpha
     end
 
-    def update; end
+    def update
+    end
   end
 end

data/lib/cyberarm_engine/timer.rb

@@ -20,4 +20,4 @@ module CyberarmEngine
       end
     end
   end
-end
+end

data/lib/cyberarm_engine/transform.rb

@@ -2,11 +2,12 @@ module CyberarmEngine
   # Basic 4x4 matrix operations
   class Transform
     attr_reader :elements
+
     def initialize(matrix)
       @elements = matrix
 
       raise "Transform is wrong size! Got #{@elements.size}, expected 16" if 16 != @elements.size
-      raise "Invalid value for matrix, must all be numeric!" if @elements.any? { |e| e.nil? || !e.is_a?(Numeric)}
+      raise "Invalid value for matrix, must all be numeric!" if @elements.any? { |e| e.nil? || !e.is_a?(Numeric) }
     end
 
     def self.identity
@@ -27,10 +28,10 @@ module CyberarmEngine
       double c = Math.cos(angle).degrees_to_radians
       double s = Math.sin(angle).degrees_to_radians
       matrix = [
-          +c, +s, 0, 0,
-          -s, +c, 0, 0,
-          0,  0,  1, 0,
-          0,  0,  0, 1,
+        +c, +s, 0, 0,
+        -s, +c, 0, 0,
+        0,  0,  1, 0,
+        0,  0,  0, 1
       ]
 
       rotate_matrix = Transform.new(matrix, rows: 4, columns: 4)
@@ -44,7 +45,7 @@ module CyberarmEngine
         )
       end
 
-      return rotate_matrix
+      rotate_matrix
     end
 
     # 2d translate operation, replicates Gosu's Gosu.translate function
@@ -54,7 +55,7 @@ module CyberarmEngine
         1, 0, 0, 0,
         0, 1, 0, 0,
         0, 0, 1, 0,
-        x, y, z, 1,
+        x, y, z, 1
       ]
 
       Transform.new(matrix)
@@ -67,7 +68,7 @@ module CyberarmEngine
         scale_x, 0,       0,       0,
         0,       scale_y, 0,       0,
         0,       0,       scale_z, 0,
-        0,       0,       0,       1,
+        0,       0,       0,       1
       ]
 
       scale_matrix = Transform.new(matrix)
@@ -81,7 +82,7 @@ module CyberarmEngine
         )
       end
 
-      return scale_matrix
+      scale_matrix
     end
 
     def self.concat(left, right)
@@ -107,13 +108,13 @@ module CyberarmEngine
         1, 0, 0, x,
         0, 1, 0, y,
         0, 0, 1, z,
-        0, 0, 0, 1,
+        0, 0, 0, 1
       ]
 
       Transform.new(matrix)
     end
 
-    def self.rotate_3d(vector, order = "zyx")
+    def self.rotate_3d(vector, _order = "zyx")
       x, y, z = vector.to_a[0..2].map { |axis| axis * Math::PI / 180.0 }
 
       rotation_x = Transform.new(
@@ -163,7 +164,7 @@ module CyberarmEngine
           x * x * n + c,     x * y * n - z * s, x * z * n + y * s, 0,
           y * x * n + z * s, y * y * n + c,     y * z * n - x * s, 0,
           x * z * n - y * s, y * z * n + x * s, z * z * n + c,     0,
-          0,                 0,                 0,               1.0
+          0,                 0,                 0, 1.0
         ]
       )
     end
@@ -190,12 +191,35 @@ module CyberarmEngine
         [
           f / aspect_ratio, 0.0,    0.0, 0.0,
           0.0,                f,    0.0, 0.0,
-          0.0,                0.0,   zn, zf,
+          0.0,                0.0, zn, zf,
           0.0,                0.0, -1.0, 0.0
         ]
       )
     end
 
+    def self.orthographic(left, right, bottom, top, near, far)
+      s = Vector.new(
+        2 / (right - left.to_f),
+        2 / (top - bottom.to_f),
+        -2 / (far - near.to_f)
+      )
+
+      t = Vector.new(
+        (right + left.to_f)   / (right - left.to_f),
+        (top   + bottom.to_f) / (top   - bottom.to_f),
+        (far   + near.to_f)   / (far   - near.to_f)
+      )
+
+      Transform.new(
+        [
+          s.x, 0.0, 0.0, t.x,
+          0.0, s.y, 0.0, t.y,
+          0.0, 0.0, s.z, t.z,
+          0.0, 0.0, 0.0, 1.0
+        ]
+      )
+    end
+
     def self.view(eye, orientation)
       # https://www.3dgep.com/understanding-the-view-matrix/#The_View_Matrix
       cosPitch = Math.cos(orientation.z * Math::PI / 180.0)
@@ -209,16 +233,15 @@ module CyberarmEngine
 
       Transform.new(
         [
-                  x_axis.x,         y_axis.y,         z_axis.z, 0,
-                  x_axis.x,         y_axis.y,         z_axis.z, 0,
-                  x_axis.x,         y_axis.y,         z_axis.z, 0,
+          x_axis.x, y_axis.y, z_axis.z, 0,
+          x_axis.x,         y_axis.y,         z_axis.z, 0,
+          x_axis.x,         y_axis.y,         z_axis.z, 0,
           -x_axis.dot(eye), -y_axis.dot(eye), -z_axis.dot(eye), 1
         ]
       )
     end
 
     def *(other)
-
       case other
       when CyberarmEngine::Vector
         matrix = @elements.clone
@@ -231,7 +254,7 @@ module CyberarmEngine
         Transform.new(matrix)
 
       when CyberarmEngine::Transform
-        return multiply_matrices(other)
+        multiply_matrices(other)
       else
         p other.class
         raise TypeError, "Expected CyberarmEngine::Vector or CyberarmEngine::Transform got #{other.class}"
@@ -256,7 +279,7 @@ module CyberarmEngine
         end
       end
 
-      return Transform.new(matrix)
+      Transform.new(matrix)
     end
 
     # arranges Matrix in column major form
@@ -270,4 +293,4 @@ module CyberarmEngine
       ]
     end
   end
-end
+end