cyberarm_engine 0.12.0 → 0.15.0

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

@@ -1,20 +1,37 @@
 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) }
+    end
+
+    def self.identity
+      Transform.new(
+        [
+          1, 0, 0, 0,
+          0, 1, 0, 0,
+          0, 0, 1, 0,
+          0, 0, 0, 1
+        ]
+      )
     end
 
+    ### 2D Operations meant for interacting with Gosu ###
+
+    # 2d rotate operation, replicates Gosu's Gosu.rotate function
     def self.rotate(angle, rotate_around = nil)
       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)
@@ -28,28 +45,30 @@ module CyberarmEngine
         )
       end
 
-      return rotate_matrix
+      rotate_matrix
     end
 
+    # 2d translate operation, replicates Gosu's Gosu.translate function
     def self.translate(vector)
       x, y, z = vector.to_a[0..2]
       matrix = [
         1, 0, 0, 0,
         0, 1, 0, 0,
         0, 0, 1, 0,
-        x, y, z, 1,
+        x, y, z, 1
       ]
 
       Transform.new(matrix)
     end
 
+    # 2d scale operation, replicates Gosu's Gosu.rotate function
     def self.scale(vector, center_around = nil)
       scale_x, scale_y, scale_z = vector.to_a[0..2]
       matrix = [
         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)
@@ -63,7 +82,7 @@ module CyberarmEngine
         )
       end
 
-      return scale_matrix
+      scale_matrix
     end
 
     def self.concat(left, right)
@@ -80,5 +99,198 @@ module CyberarmEngine
 
       Transform.new(matrix)
     end
+
+    #### 3D Operations meant for OpenGL ###
+
+    def self.translate_3d(vector)
+      x, y, z = vector.to_a[0..2]
+      matrix = [
+        1, 0, 0, x,
+        0, 1, 0, y,
+        0, 0, 1, z,
+        0, 0, 0, 1
+      ]
+
+      Transform.new(matrix)
+    end
+
+    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(
+        [
+          1, 0,           0,            0,
+          0, Math.cos(x), -Math.sin(x), 0,
+          0, Math.sin(x), Math.cos(x),  0,
+          0, 0,           0,            1
+        ]
+      )
+
+      rotation_y = Transform.new(
+        [
+          Math.cos(y),  0, Math.sin(y), 0,
+          0,            1, 0,           0,
+          -Math.sin(y), 0, Math.cos(y), 0,
+          0,            0, 0,           1
+        ]
+      )
+
+      rotation_z = Transform.new(
+        [
+          Math.cos(z), -Math.sin(z), 0, 0,
+          Math.sin(z), Math.cos(z),  0, 0,
+          0,           0,            1, 0,
+          0,           0,            0, 1
+        ]
+      )
+
+      rotation_z * rotation_y * rotation_x
+    end
+
+    # Implements glRotatef
+    # https://www.khronos.org/registry/OpenGL-Refpages/gl2.1/xhtml/glRotate.xml
+    def self.rotate_gl(angle, axis)
+      radians = angle * Math::PI / 180.0
+      s = Math.sin(radians)
+      c = Math.cos(radians)
+
+      axis = axis.normalized
+      x, y, z = axis.to_a[0..2]
+
+      n = (1.0 - c)
+
+      Transform.new(
+        [
+          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
+        ]
+      )
+    end
+
+    def self.scale_3d(vector)
+      x, y, z = vector.to_a[0..2]
+
+      Transform.new(
+        [
+          x, 0, 0, 0,
+          0, y, 0, 0,
+          0, 0, z, 0,
+          0, 0, 0, 1
+        ]
+      )
+    end
+
+    def self.perspective(fov_y, aspect_ratio, near, far)
+      f = 1.0 / Math.tan(fov_y.degrees_to_radians / 2.0) # cotangent
+      zn = (far + near.to_f) / (near - far.to_f)
+      zf = (2.0 * far * near.to_f) / (near - far.to_f)
+
+      Transform.new(
+        [
+          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, -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)
+      sinPitch = Math.sin(orientation.z * Math::PI / 180.0)
+      cosYaw = Math.cos(orientation.y * Math::PI / 180.0)
+      sinYaw = Math.sin(orientation.y * Math::PI / 180.0)
+
+      x_axis = Vector.new(cosYaw, 0, -sinYaw)
+      y_axis = Vector.new(sinYaw * sinPitch, cosPitch, cosYaw * sinPitch)
+      z_axis = Vector.new(sinYaw * cosPitch, -sinPitch, cosPitch * cosYaw)
+
+      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.dot(eye), -y_axis.dot(eye), -z_axis.dot(eye), 1
+        ]
+      )
+    end
+
+    def *(other)
+      case other
+      when CyberarmEngine::Vector
+        matrix = @elements.clone
+        list = other.to_a
+
+        @elements.each_with_index do |e, i|
+          matrix[i] = e + list[i % 4]
+        end
+
+        Transform.new(matrix)
+
+      when CyberarmEngine::Transform
+        multiply_matrices(other)
+      else
+        p other.class
+        raise TypeError, "Expected CyberarmEngine::Vector or CyberarmEngine::Transform got #{other.class}"
+      end
+    end
+
+    def get(x, y)
+      width = 4
+
+      # puts "Transform|#{self.object_id} -> #{@elements[width * y + x].inspect} (index: #{width * y + x})"
+      @elements[width * y + x]
+    end
+
+    def multiply_matrices(other)
+      matrix = Array.new(16, 0)
+
+      4.times do |x|
+        4.times do |y|
+          4.times do |k|
+            matrix[4 * y + x] += get(x, k) * other.get(k, y)
+          end
+        end
+      end
+
+      Transform.new(matrix)
+    end
+
+    # arranges Matrix in column major form
+    def to_gl
+      e = @elements
+      [
+        e[0], e[4], e[8],  e[12],
+        e[1], e[5], e[9],  e[13],
+        e[2], e[6], e[10], e[14],
+        e[3], e[7], e[11], e[15]
+      ]
+    end
   end
-end
+end