cyberarm_engine 0.25.0 → 0.30.0

data/lib/cyberarm_engine/opengl/texture.rb

@@ -1,69 +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_SRGB_ALPHA, 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
+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_SRGB_ALPHA, 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/opengl.rb

@@ -1,53 +1,53 @@
-begin
-  require "opengl"
-  require "glu"
-rescue LoadError
-  puts "Required gem is not installed, please install 'opengl-bindings' and try again."
-  exit(1)
-end
-
-module CyberarmEngine
-  def gl_error?
-    e = glGetError
-    if e != OpenGL::GL_NO_ERROR
-      warn "OpenGL error detected by handler at: #{caller[0]}"
-      warn "    #{gluErrorString(e)} (#{e})\n"
-      exit if Window.instance&.exit_on_opengl_error?
-    end
-  end
-
-  def preload_default_shaders
-    shaders = %w[g_buffer lighting]
-    shaders.each do |shader|
-      Shader.new(
-        name: shader,
-        includes_dir: "#{CYBERARM_ENGINE_ROOT_PATH}/assets/shaders/include",
-        vertex: "#{CYBERARM_ENGINE_ROOT_PATH}/assets/shaders/vertex/#{shader}.glsl",
-        fragment: "#{CYBERARM_ENGINE_ROOT_PATH}/assets/shaders/fragment/#{shader}.glsl"
-      )
-    end
-  end
-end
-
-require_relative "opengl/shader"
-require_relative "opengl/texture"
-require_relative "opengl/light"
-require_relative "opengl/perspective_camera"
-require_relative "opengl/orthographic_camera"
-
-require_relative "opengl/renderer/g_buffer"
-require_relative "opengl/renderer/bounding_box_renderer"
-require_relative "opengl/renderer/opengl_renderer"
-require_relative "opengl/renderer/renderer"
-
-require_relative "trees/aabb_tree_debug"
-require_relative "trees/aabb_node"
-require_relative "trees/aabb_tree"
-
-require_relative "model"
-require_relative "model_cache"
-require_relative "model/material"
-require_relative "model/mesh"
-require_relative "model/parser"
-require_relative "model/parsers/wavefront_parser"
-require_relative "model/parsers/collada_parser" if RUBY_ENGINE != "mruby" && defined?(Nokogiri)
+begin
+  require "opengl"
+  require "glu"
+rescue LoadError
+  puts "Required gem is not installed, please install 'opengl-bindings' and try again."
+  exit(1)
+end
+
+module CyberarmEngine
+  def gl_error?
+    e = glGetError
+    if e != OpenGL::GL_NO_ERROR
+      warn "OpenGL error detected by handler at: #{caller[0]}"
+      warn "    #{gluErrorString(e)} (#{e})\n"
+      exit if Window.instance&.exit_on_opengl_error?
+    end
+  end
+
+  def preload_default_shaders
+    shaders = %w[g_buffer lighting]
+    shaders.each do |shader|
+      Shader.new(
+        name: shader,
+        includes_dir: "#{CYBERARM_ENGINE_ROOT_PATH}/assets/shaders/include",
+        vertex: "#{CYBERARM_ENGINE_ROOT_PATH}/assets/shaders/vertex/#{shader}.glsl",
+        fragment: "#{CYBERARM_ENGINE_ROOT_PATH}/assets/shaders/fragment/#{shader}.glsl"
+      )
+    end
+  end
+end
+
+require_relative "opengl/shader"
+require_relative "opengl/texture"
+require_relative "opengl/light"
+require_relative "opengl/perspective_camera"
+require_relative "opengl/orthographic_camera"
+
+require_relative "opengl/renderer/g_buffer"
+require_relative "opengl/renderer/bounding_box_renderer"
+require_relative "opengl/renderer/opengl_renderer"
+require_relative "opengl/renderer/renderer"
+
+require_relative "trees/aabb_tree_debug"
+require_relative "trees/aabb_node"
+require_relative "trees/aabb_tree"
+
+require_relative "model"
+require_relative "model_cache"
+require_relative "model/material"
+require_relative "model/mesh"
+require_relative "model/parser"
+require_relative "model/parsers/wavefront_parser"
+require_relative "model/parsers/collada_parser" if RUBY_ENGINE != "mruby" && defined?(Nokogiri)

data/lib/cyberarm_engine/pathfinding/graph.rb

@@ -0,0 +1,64 @@
+module CyberarmEngine
+  module Pathfinding
+    class Graph
+      class Node
+        KEY_FORMAT = "%s:%s:%s".freeze
+
+        attr_reader :x, :y, :z, :cost, :key, :edge_nodes
+
+        def initialize(x:, y:, z: 0, cost: 0)
+          @x = x
+          @y = y
+          @z = z
+          @cost = cost
+
+          @key = format(KEY_FORMAT, @x, @y, @z).freeze
+
+          @edge_nodes = []
+        end
+
+        def add_edge_node(node)
+          index = @edge_nodes.find_index { |n| n.key == node.key }
+
+          return if index
+
+          @edge_nodes.push(node)
+        end
+
+        def remove_edge_node(node)
+          index = @edge_nodes.find_index { |n| n.key == node.key }
+
+          return unless index
+
+          @edge_nodes.delete(index)
+        end
+
+        def inspect
+          format "#<%<class>s:%<id>#018x @key=%<key>s @cost=%<cost>s @edge_nodes=%<edge_nodes>s>",
+                 class: self.class,
+                 id: object_id << 1,
+                 key: key.inspect,
+                 cost: cost.inspect,
+                 edge_nodes: edge_nodes.map { |n| n&.key }
+        end
+      end
+
+      def initialize(nodes: {})
+        @nodes = nodes
+      end
+
+      def node(key)
+        @nodes[key]
+      end
+
+      def node_at(x, y, z = 0)
+        key = format(Node::KEY_FORMAT, x, y, z)
+        @nodes[key]
+      end
+
+      def neighbors(node)
+        node.edge_nodes
+      end
+    end
+  end
+end

data/lib/cyberarm_engine/pathfinding/graph_search.rb

@@ -0,0 +1,6 @@
+module CyberarmEngine
+  module Pathfinding
+    class GraphSearch
+    end
+  end
+end

data/lib/cyberarm_engine/pathfinding/graph_searches/astar_search.rb

@@ -0,0 +1,6 @@
+module CyberarmEngine
+  module Pathfinding
+    class AStarSearch < GraphSearch
+    end
+  end
+end

data/lib/cyberarm_engine/pathfinding/graph_searches/breadth_first_search.rb

@@ -0,0 +1,27 @@
+module CyberarmEngine
+  module Pathfinding
+    class BreadthFirstSearch < GraphSearch
+      def self.search(graph:, start:, goal: nil)
+        frontier = []
+        came_from = {}
+
+        frontier.push(start)
+        came_from[start.key] = start
+
+        while(current = frontier.shift)
+          # early exit if we reach our goal
+          break if current == goal
+
+          graph.neighbors(current).each do |neighbor|
+            next if came_from[neighbor.key]
+
+            frontier.push(neighbor)
+            came_from[neighbor.key] = current
+          end
+        end
+
+        came_from
+      end
+    end
+  end
+end

data/lib/cyberarm_engine/pathfinding/graph_searches/dijkstra_search.rb

@@ -0,0 +1,6 @@
+module CyberarmEngine
+  module Pathfinding
+    class DijkstraSearch < GraphSearch
+    end
+  end
+end

data/lib/cyberarm_engine/pathfinding/graphs/grid.rb

@@ -0,0 +1,52 @@
+module CyberarmEngine
+  module Pathfinding
+    class Grid < Graph
+      def add_node(x:, y:, z: 0, cost: 0, replace: false)
+        key = format(Node::KEY_FORMAT, x, y, z)
+        node = @nodes[key]
+
+        raise "Node at: #{key} already exists! (#{node})" if node && !replace
+
+        node = Node.new(x: x, y: y, z: z, cost: cost)
+        @nodes[key] = node
+
+        update_node_edge_nodes(node)
+        node
+      end
+
+      def remove_node(node)
+        update_node_edge_nodes(node, remove_node: true)
+
+        @nodes.delete(node.key)
+      end
+
+      def update_node_edge_nodes(node, remove_node: false)
+        x = node.x
+        y = node.y
+        z = node.z
+
+        # add node to neighbors
+        # 2D
+        left = @nodes[format(Node::KEY_FORMAT, x - 1, y, z)]
+        right = @nodes[format(Node::KEY_FORMAT, x + 1, y, z)]
+        top = @nodes[format(Node::KEY_FORMAT, x, y - 1, z)]
+        bottom = @nodes[format(Node::KEY_FORMAT, x, y + 1, z)]
+        # 3D
+        front = @nodes[format(Node::KEY_FORMAT, x, y, z - 1)]
+        back = @nodes[format(Node::KEY_FORMAT, x, y, z + 1)]
+
+        possible_edge_nodes = [left, right, top, bottom, front, back]
+
+        if remove_node
+          possible_edge_nodes.each { |n| n&.remove_edge_node(node) }
+        else
+          possible_edge_nodes.each { |n| n&.add_edge_node(node) }
+        end
+      end
+
+      def update_edge_nodes
+        @nodes.each { |k, n| update_node_edge_nodes(n) }
+      end
+    end
+  end
+end

data/lib/cyberarm_engine/ray.rb

@@ -1,56 +1,56 @@
-module CyberarmEngine
-  class Ray
-    def initialize(origin, direction, range = Float::INFINITY)
-      raise "Origin must be a Vector!" unless origin.is_a?(Vector)
-      raise "Direction must be a Vector!" unless direction.is_a?(Vector)
-
-      @origin = origin
-      @direction = direction
-      @range = range
-
-      @inverse_direction = @direction.inverse
-    end
-
-    def intersect?(intersectable)
-      if intersectable.is_a?(BoundingBox)
-        intersect_bounding_box?(intersectable)
-      else
-        raise NotImplementedError, "Ray intersection test for #{intersectable.class} not implemented."
-      end
-    end
-
-    # Based on: https://tavianator.com/fast-branchless-raybounding-box-intersections/
-    def intersect_bounding_box?(box)
-      tmin = -@range
-      tmax = @range
-
-      tx1 = (box.min.x - @origin.x) * @inverse_direction.x
-      tx2 = (box.max.x - @origin.x) * @inverse_direction.x
-
-      tmin = max(tmin, min(tx1, tx2))
-      tmax = min(tmax, max(tx1, tx2))
-
-      ty1 = (box.min.y - @origin.y) * @inverse_direction.y
-      ty2 = (box.max.y - @origin.y) * @inverse_direction.y
-
-      tmin = max(tmin, min(ty1, ty2))
-      tmax = min(tmax, max(ty1, ty2))
-
-      tz1 = (box.min.z - @origin.z) * @inverse_direction.z
-      tz2 = (box.max.z - @origin.z) * @inverse_direction.z
-
-      tmin = max(tmin, min(tz1, tz2))
-      tmax = min(tmax, max(tz1, tz2))
-
-      tmax >= max(tmin, 0.0)
-    end
-
-    def min(x, y)
-      ((x) < (y) ? x : y)
-    end
-
-    def max(x, y)
-      ((x) > (y) ? x : y)
-    end
-  end
-end
+module CyberarmEngine
+  class Ray
+    def initialize(origin, direction, range = Float::INFINITY)
+      raise "Origin must be a Vector!" unless origin.is_a?(Vector)
+      raise "Direction must be a Vector!" unless direction.is_a?(Vector)
+
+      @origin = origin
+      @direction = direction
+      @range = range
+
+      @inverse_direction = @direction.inverse
+    end
+
+    def intersect?(intersectable)
+      if intersectable.is_a?(BoundingBox)
+        intersect_bounding_box?(intersectable)
+      else
+        raise NotImplementedError, "Ray intersection test for #{intersectable.class} not implemented."
+      end
+    end
+
+    # Based on: https://tavianator.com/fast-branchless-raybounding-box-intersections/
+    def intersect_bounding_box?(box)
+      tmin = -@range
+      tmax = @range
+
+      tx1 = (box.min.x - @origin.x) * @inverse_direction.x
+      tx2 = (box.max.x - @origin.x) * @inverse_direction.x
+
+      tmin = max(tmin, min(tx1, tx2))
+      tmax = min(tmax, max(tx1, tx2))
+
+      ty1 = (box.min.y - @origin.y) * @inverse_direction.y
+      ty2 = (box.max.y - @origin.y) * @inverse_direction.y
+
+      tmin = max(tmin, min(ty1, ty2))
+      tmax = min(tmax, max(ty1, ty2))
+
+      tz1 = (box.min.z - @origin.z) * @inverse_direction.z
+      tz2 = (box.max.z - @origin.z) * @inverse_direction.z
+
+      tmin = max(tmin, min(tz1, tz2))
+      tmax = min(tmax, max(tz1, tz2))
+
+      tmax >= max(tmin, 0.0)
+    end
+
+    def min(x, y)
+      ((x) < (y) ? x : y)
+    end
+
+    def max(x, y)
+      ((x) > (y) ? x : y)
+    end
+  end
+end

data/lib/cyberarm_engine/result.rb

@@ -0,0 +1,19 @@
+module CyberarmEngine
+  # result pattern
+  class Result
+    attr_accessor :error, :data
+
+    def initialize(data: nil, error: nil)
+      @data = data
+      @error = error
+    end
+
+    def okay?
+      !error?
+    end
+
+    def error?
+      @error || @data.nil?
+    end
+  end
+end