Refactored mesh handling, imported AABB tree implementation from I-MIC FPS

lib/cyberarm_engine.rb

@@ -67,12 +67,4 @@ require_relative "cyberarm_engine/ui/elements/menu_item"
 require_relative "cyberarm_engine/game_state"
 require_relative "cyberarm_engine/ui/gui_state"
 
-require_relative "cyberarm_engine/model"
-require_relative "cyberarm_engine/model_cache"
-require_relative "cyberarm_engine/model/material"
-require_relative "cyberarm_engine/model/model_object"
-require_relative "cyberarm_engine/model/parser"
-require_relative "cyberarm_engine/model/parsers/wavefront_parser"
-require_relative "cyberarm_engine/model/parsers/collada_parser" if RUBY_ENGINE != "mruby" && defined?(Nokogiri)
-
 require_relative "cyberarm_engine/builtin/intro_state"

lib/cyberarm_engine/model.rb

@@ -1,5 +1,8 @@
 module CyberarmEngine
   class Model
+    include OpenGL
+    include CyberarmEngine
+
     attr_accessor :objects, :materials, :vertices, :uvs, :texures, :normals, :faces, :colors, :bones, :material_file,
                   :current_material, :current_object, :vertex_count, :smoothing
     attr_reader :position, :bounding_box, :textured_material, :file_path, :positions_buffer_id, :colors_buffer_id,
@@ -49,9 +52,9 @@ module CyberarmEngine
 
       @objects.each { |o| @vertex_count += o.vertices.size }
 
-      # start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_millisecond)
-      # build_collision_tree
-      # puts "    Building mesh collision tree took #{((Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_millisecond) - start_time) / 1000.0).round(2)} seconds"
+      start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_millisecond)
+      build_collision_tree
+      puts "    Building mesh collision tree took #{((Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_millisecond) - start_time) / 1000.0).round(2)} seconds"
     end
 
     def parse(parser)
@@ -178,7 +181,7 @@ module CyberarmEngine
     end
 
     def build_collision_tree
-      @aabb_tree = IMICFPS::AABBTree.new
+      @aabb_tree = AABBTree.new
 
       @faces.each do |face|
         box = BoundingBox.new

lib/cyberarm_engine/model/mesh.rb

@@ -1,6 +1,6 @@
 module CyberarmEngine
   class Model
-    class ModelObject
+    class Mesh
       attr_reader :id, :name, :vertices, :uvs, :normals, :materials, :bounding_box, :debug_color
       attr_accessor :faces, :scale
 

lib/cyberarm_engine/model/parser.rb

@@ -48,12 +48,12 @@ module CyberarmEngine
         if _model
           @model.current_object = _model
         else
-          raise "Couldn't find ModelObject!"
+          raise "Couldn't find Mesh!"
         end
       end
 
       def change_object(id, name)
-        @model.objects << Model::ModelObject.new(id, name)
+        @model.objects << Model::Mesh.new(id, name)
         @model.current_object = @model.objects.last
       end
 

lib/cyberarm_engine/opengl.rb

@@ -1,5 +1,6 @@
 begin
   require "opengl"
+  require "glu"
 rescue LoadError
   puts "Required gem is not installed, please install 'opengl-bindings' and try again."
   exit(1)
@@ -8,7 +9,7 @@ end
 module CyberarmEngine
   def gl_error?
     e = glGetError
-    if e != GL_NO_ERROR
+    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?
@@ -38,3 +39,15 @@ 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)

lib/cyberarm_engine/opengl/light.rb

@@ -1,5 +1,7 @@
 module CyberarmEngine
   class Light
+    include OpenGL
+
     DIRECTIONAL = 0
     POINT = 1
     SPOT = 2

lib/cyberarm_engine/opengl/perspective_camera.rb

@@ -1,5 +1,8 @@
 module CyberarmEngine
   class PerspectiveCamera
+    include OpenGL
+    include GLU
+
     attr_accessor :position, :orientation, :aspect_ratio, :field_of_view,
                   :min_view_distance, :max_view_distance
 

lib/cyberarm_engine/opengl/renderer/g_buffer.rb

@@ -1,5 +1,7 @@
 module CyberarmEngine
   class GBuffer
+    include OpenGL
+
     attr_reader :screen_vbo, :vertices, :uvs
     attr_reader :width, :height
 

lib/cyberarm_engine/opengl/renderer/opengl_renderer.rb

@@ -1,5 +1,8 @@
 module CyberarmEngine
   class OpenGLRenderer
+    include OpenGL
+    include CyberarmEngine
+
     @@immediate_mode_warning = false
 
     attr_accessor :show_wireframe

lib/cyberarm_engine/opengl/shader.rb

@@ -2,6 +2,7 @@ module CyberarmEngine
   # Ref: https://github.com/vaiorabbit/ruby-opengl/blob/master/sample/OrangeBook/brick.rb
   class Shader
     include OpenGL
+
     @@shaders = {} # Cache for {Shader} instances
     PREPROCESSOR_CHARACTER = "@".freeze # magic character for preprocessor phase of {Shader} compilation
 
@@ -298,6 +299,7 @@ module CyberarmEngine
     # @see Shader.use Shader.use
     def use(&block)
       return unless compiled?
+
       raise "Another shader is already in use! #{Shader.active_shader.name.inspect}" if Shader.active_shader
 
       Shader.active_shader = self

lib/cyberarm_engine/trees/aabb_node.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module CyberarmEngine
+  class AABBTree
+    class AABBNode
+      attr_accessor :bounding_box, :parent, :object
+      attr_reader :a, :b
+
+      def initialize(parent:, object:, bounding_box:)
+        @parent = parent
+        @object = object
+        @bounding_box = bounding_box
+
+        @a = nil
+        @b = nil
+      end
+
+      def a=(leaf)
+        @a = leaf
+        @a.parent = self
+      end
+
+      def b=(leaf)
+        @b = leaf
+        @b.parent = self
+      end
+
+      def leaf?
+        @object
+      end
+
+      def insert_subtree(leaf)
+        if leaf?
+          new_node = AABBNode.new(parent: nil, object: nil, bounding_box: @bounding_box.union(leaf.bounding_box))
+
+          new_node.a = self
+          new_node.b = leaf
+
+          new_node
+        else
+          cost_a = @a.bounding_box.volume + @b.bounding_box.union(leaf.bounding_box).volume
+          cost_b = @b.bounding_box.volume + @a.bounding_box.union(leaf.bounding_box).volume
+
+          if cost_a == cost_b
+            cost_a = @a.proximity(leaf)
+            cost_b = @b.proximity(leaf)
+          end
+
+          if cost_b < cost_a
+            self.b = @b.insert_subtree(leaf)
+          else
+            self.a = @a.insert_subtree(leaf)
+          end
+
+          @bounding_box = @bounding_box.union(leaf.bounding_box)
+
+          self
+        end
+      end
+
+      def search_subtree(collider, items = [])
+        if @bounding_box.intersect?(collider)
+          if leaf?
+            items << self
+          else
+            @a.search_subtree(collider, items)
+            @b.search_subtree(collider, items)
+          end
+        end
+
+        items
+      end
+
+      def remove_subtree(leaf)
+        if leaf
+          self
+        elsif leaf.parent == self
+          other_child = other(leaf)
+          other_child.parent = @parent
+          other_child
+        else
+          leaf.parent.disown_child(leaf)
+          self
+        end
+      end
+
+      def other(leaf)
+        @a == leaf ? @b : @a
+      end
+
+      def disown_child(leaf)
+        value = other(leaf)
+        raise "Can not replace child of a leaf!" if @parent.leaf?
+        raise "Node is not a child of parent!" unless leaf.child_of?(@parent)
+
+        if @parent.a == self
+          @parent.a = value
+        else
+          @parent.b = value
+        end
+
+        @parent.update_bounding_box
+      end
+
+      def child_of?(leaf)
+        self == leaf.a || self == leaf.b
+      end
+
+      def proximity(leaf)
+        (@bounding_box - leaf.bounding_box).sum.abs
+      end
+
+      def update_bounding_box
+        node = self
+
+        unless node.leaf?
+          node.bounding_box = node.a.bounding_box.union(node.b.bounding_box)
+
+          while (node = node.parent)
+            node.bounding_box = node.a.bounding_box.union(node.b.bounding_box)
+          end
+        end
+      end
+    end
+  end
+end

lib/cyberarm_engine/trees/aabb_tree.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module CyberarmEngine
+  class AABBTree
+    include AABBTreeDebug
+
+    attr_reader :root, :objects, :branches, :leaves
+
+    def initialize
+      @objects = {}
+      @root = nil
+      @branches = 0
+      @leaves   = 0
+    end
+
+    def insert(object, bounding_box)
+      raise "BoundingBox can't be nil!" unless bounding_box
+      raise "Object can't be nil!" unless object
+      # raise "Object already in tree!" if @objects[object] # FIXME
+
+      leaf = AABBNode.new(parent: nil, object: object, bounding_box: bounding_box.dup)
+      @objects[object] = leaf
+
+      insert_leaf(leaf)
+    end
+
+    def insert_leaf(leaf)
+      @root = @root ? @root.insert_subtree(leaf) : leaf
+    end
+
+    def update(object, bounding_box)
+      leaf = remove(object)
+      leaf.bounding_box = bounding_box
+      insert_leaf(leaf)
+    end
+
+    # Returns a list of all objects that collided with collider
+    def search(collider, return_nodes = false)
+      items = []
+      if @root
+        items = @root.search_subtree(collider)
+        items.map!(&:object) unless return_nodes
+      end
+
+      items
+    end
+
+    def remove(object)
+      leaf  = @objects.delete(object)
+      @root = @root.remove_subtree(leaf) if leaf
+
+      leaf
+    end
+  end
+end

lib/cyberarm_engine/trees/aabb_tree_debug.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module CyberarmEngine
+  # Gets included into AABBTree
+  module AABBTreeDebug
+    def inspect
+      @branches = 0
+      @leaves = 0
+      if @root
+        node = @root
+
+        debug_search(node.a)
+        debug_search(node.b)
+      end
+
+      puts "<#{self.class}:#{object_id}> has #{@branches} branches and #{@leaves} leaves"
+    end
+
+    def debug_search(node)
+      if node.leaf?
+        @leaves += 1
+      else
+        @branches += 1
+        debug_search(node.a)
+        debug_search(node.b)
+      end
+    end
+  end
+end