cyberarm_engine 0.14.0 → 0.15.0

data/lib/cyberarm_engine/game_state.rb

@@ -5,7 +5,7 @@ module CyberarmEngine
     attr_accessor :options, :global_pause
     attr_reader :game_objects
 
-    def initialize(options={})
+    def initialize(options = {})
       @options = options
       @game_objects = []
       @global_pause = false
@@ -26,7 +26,10 @@ module CyberarmEngine
     end
 
     def draw_bounding_box(box)
-      x,y, max_x, max_y = box.x, box.y, box.max_x, box.max_y
+      x = box.x
+      y = box.y
+      max_x = box.max_x
+      max_y = box.max_y
 
       color = Gosu::Color.rgba(255, 127, 64, 240)
 
@@ -86,4 +89,4 @@ module CyberarmEngine
       @game_objects << object
     end
   end
-end
+end

data/lib/cyberarm_engine/model.rb

@@ -0,0 +1,207 @@
+module CyberarmEngine
+  class Model
+    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,
+                :normals_buffer_id, :uvs_buffer_id, :textures_buffer_id, :vertex_array_id, :aabb_tree
+
+    def initialize(file_path:)
+      @file_path = file_path
+
+      @material_file  = nil
+      @current_object = nil
+      @current_material = nil
+      @vertex_count = 0
+
+      @objects = []
+      @materials = {}
+      @vertices = []
+      @colors   = []
+      @uvs      = []
+      @normals  = []
+      @faces    = []
+      @bones    = []
+      @smoothing = 0
+
+      @bounding_box = BoundingBox.new
+      start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_millisecond)
+
+      type = File.basename(file_path).split(".").last.to_sym
+      parser = Model::Parser.find(type)
+      raise "Unsupported model type '.#{type}', supported models are: #{Model::Parser.supported_formats}" unless parser
+
+      parse(parser)
+
+      @has_texture = false
+
+      @materials.each do |_key, material|
+        @has_texture = true if material.texture_id
+      end
+
+      allocate_gl_objects
+      populate_vertex_buffer
+      configure_vao
+
+      @objects.each { |o| @vertex_count += o.vertices.size }
+
+      start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_millisecond)
+      # build_collision_tree
+    end
+
+    def parse(parser)
+      parser.new(self).parse
+    end
+
+    def calculate_bounding_box(vertices, bounding_box)
+      unless bounding_box.min.x.is_a?(Float)
+        vertex = vertices.last
+        bounding_box.min.x = vertex.x
+        bounding_box.min.y = vertex.y
+        bounding_box.min.z = vertex.z
+
+        bounding_box.max.x = vertex.x
+        bounding_box.max.y = vertex.y
+        bounding_box.max.z = vertex.z
+      end
+
+      vertices.each do |vertex|
+        bounding_box.min.x = vertex.x if vertex.x <= bounding_box.min.x
+        bounding_box.min.y = vertex.y if vertex.y <= bounding_box.min.y
+        bounding_box.min.z = vertex.z if vertex.z <= bounding_box.min.z
+
+        bounding_box.max.x = vertex.x if vertex.x >= bounding_box.max.x
+        bounding_box.max.y = vertex.y if vertex.y >= bounding_box.max.y
+        bounding_box.max.z = vertex.z if vertex.z >= bounding_box.max.z
+      end
+    end
+
+    def allocate_gl_objects
+      # Allocate arrays for future use
+      @vertex_array_id = nil
+      buffer = " " * 4
+      glGenVertexArrays(1, buffer)
+      @vertex_array_id = buffer.unpack1("L2")
+
+      # Allocate buffers for future use
+      @positions_buffer_id = nil
+      buffer = " " * 4
+      glGenBuffers(1, buffer)
+      @positions_buffer_id = buffer.unpack1("L2")
+
+      @colors_buffer_id = nil
+      buffer = " " * 4
+      glGenBuffers(1, buffer)
+      @colors_buffer_id = buffer.unpack1("L2")
+
+      @normals_buffer_id = nil
+      buffer = " " * 4
+      glGenBuffers(1, buffer)
+      @normals_buffer_id = buffer.unpack1("L2")
+
+      @uvs_buffer_id = nil
+      buffer = " " * 4
+      glGenBuffers(1, buffer)
+      @uvs_buffer_id = buffer.unpack1("L2")
+    end
+
+    def populate_vertex_buffer
+      pos     = []
+      colors  = []
+      norms   = []
+      uvs     = []
+
+      @faces.each do |face|
+        pos     << face.vertices.map { |vert| [vert.x, vert.y, vert.z] }
+        colors  << face.colors.map   { |color| [color.red, color.green, color.blue] }
+        norms   << face.normals.map  { |vert| [vert.x, vert.y, vert.z, vert.weight] }
+
+        uvs << face.uvs.map { |vert| [vert.x, vert.y, vert.z] } if has_texture?
+      end
+
+      glBindBuffer(GL_ARRAY_BUFFER, @positions_buffer_id)
+      glBufferData(GL_ARRAY_BUFFER, pos.flatten.size * Fiddle::SIZEOF_FLOAT, pos.flatten.pack("f*"), GL_STATIC_DRAW)
+
+      glBindBuffer(GL_ARRAY_BUFFER, @colors_buffer_id)
+      glBufferData(GL_ARRAY_BUFFER, colors.flatten.size * Fiddle::SIZEOF_FLOAT, colors.flatten.pack("f*"),
+                   GL_STATIC_DRAW)
+
+      glBindBuffer(GL_ARRAY_BUFFER, @normals_buffer_id)
+      glBufferData(GL_ARRAY_BUFFER, norms.flatten.size * Fiddle::SIZEOF_FLOAT, norms.flatten.pack("f*"), GL_STATIC_DRAW)
+
+      if has_texture?
+        glBindBuffer(GL_ARRAY_BUFFER, @uvs_buffer_id)
+        glBufferData(GL_ARRAY_BUFFER, uvs.flatten.size * Fiddle::SIZEOF_FLOAT, uvs.flatten.pack("f*"), GL_STATIC_DRAW)
+      end
+
+      glBindBuffer(GL_ARRAY_BUFFER, 0)
+    end
+
+    def configure_vao
+      glBindVertexArray(@vertex_array_id)
+      gl_error?
+
+      # index, size, type, normalized, stride, pointer
+      # vertices (positions)
+      glBindBuffer(GL_ARRAY_BUFFER, @positions_buffer_id)
+      gl_error?
+
+      #                     inPosition
+      glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, nil)
+      gl_error?
+      # colors
+      glBindBuffer(GL_ARRAY_BUFFER, @colors_buffer_id)
+      #                     inColor
+      glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, nil)
+      gl_error?
+      # normals
+      glBindBuffer(GL_ARRAY_BUFFER, @normals_buffer_id)
+      #                     inNormal
+      glVertexAttribPointer(2, 4, GL_FLOAT, GL_FALSE, 0, nil)
+      gl_error?
+
+      if has_texture?
+        # uvs
+        glBindBuffer(GL_ARRAY_BUFFER, @uvs_buffer_id)
+        #                     inUV
+        glVertexAttribPointer(3, 3, GL_FLOAT, GL_FALSE, 0, nil)
+        gl_error?
+      end
+
+      glBindBuffer(GL_ARRAY_BUFFER, 0)
+      glBindVertexArray(0)
+    end
+
+    def build_collision_tree
+      @aabb_tree = AABBTree.new
+
+      @faces.each do |face|
+        box = BoundingBox.new
+        box.min = face.vertices.first.dup
+        box.max = face.vertices.first.dup
+
+        face.vertices.each do |vertex|
+          if vertex.sum < box.min.sum
+            box.min = vertex.dup
+          elsif vertex.sum > box.max.sum
+            box.max = vertex.dup
+          end
+        end
+
+        # FIXME: Handle negatives
+        box.min *= 1.5
+        box.max *= 1.5
+        @aabb_tree.insert(face, box)
+      end
+    end
+
+    def has_texture?
+      @has_texture
+    end
+
+    def release_gl_resources
+      if @vertex_array_id
+
+      end
+    end
+  end
+end

data/lib/cyberarm_engine/model/material.rb

@@ -0,0 +1,21 @@
+module CyberarmEngine
+  class Model
+    class Material
+      attr_accessor :name, :ambient, :diffuse, :specular
+      attr_reader :texture_id
+
+      def initialize(name)
+        @name    = name
+        @ambient = Color.new(1, 1, 1, 1)
+        @diffuse = Color.new(1, 1, 1, 1)
+        @specular = Color.new(1, 1, 1, 1)
+        @texture = nil
+        @texture_id = nil
+      end
+
+      def set_texture(texture_path)
+        @texture_id = Texture.new(path: texture_path).id
+      end
+    end
+  end
+end

data/lib/cyberarm_engine/model/model_object.rb

@@ -0,0 +1,131 @@
+module CyberarmEngine
+  class Model
+    class ModelObject
+      attr_reader :id, :name, :vertices, :uvs, :normals, :materials, :bounding_box, :debug_color
+      attr_accessor :faces, :scale
+
+      def initialize(id, name)
+        @id = id
+        @name = name
+        @vertices = []
+        @uvs      = []
+        @normals  = []
+        @faces    = []
+        @materials = []
+        @bounding_box = BoundingBox.new
+        @debug_color = Color.new(1.0, 1.0, 1.0)
+
+        @scale = 1.0
+
+        # Faces array packs everything:
+        #   vertex   = index[0]
+        #   uv       = index[1]
+        #   normal   = index[2]
+        #   material = index[3]
+      end
+
+      def has_texture?
+        @materials.find { |mat| mat.texture_id } ? true : false
+      end
+
+      def reflatten
+        @vertices_list = nil
+        @uvs_list = nil
+        @normals_list = nil
+
+        flattened_vertices
+        flattened_uvs
+        flattened_normals
+      end
+
+      def flattened_vertices
+        unless @vertices_list
+          @debug_color = @faces.first.material.diffuse
+
+          list = []
+          @faces.each do |face|
+            face.vertices.each do |v|
+              next unless v
+
+              list << v.x * @scale
+              list << v.y * @scale
+              list << v.z * @scale
+              list << v.weight
+            end
+          end
+
+          @vertices_list_size = list.size
+          @vertices_list = list.pack("f*")
+        end
+
+        @vertices_list
+      end
+
+      def flattened_vertices_size
+        @vertices_list_size
+      end
+
+      def flattened_uvs
+        unless @uvs_list
+          list = []
+          @faces.each do |face|
+            face.uvs.each do |v|
+              next unless v
+
+              list << v.x
+              list << v.y
+              list << v.z
+            end
+          end
+
+          @uvs_list_size = list.size
+          @uvs_list = list.pack("f*")
+        end
+
+        @uvs_list
+      end
+
+      def flattened_normals
+        unless @normals_list
+          list = []
+          @faces.each do |face|
+            face.normals.each do |n|
+              next unless n
+
+              list << n.x
+              list << n.y
+              list << n.z
+            end
+          end
+
+          @normals_list_size = list.size
+          @normals_list = list.pack("f*")
+        end
+
+        @normals_list
+      end
+
+      def flattened_materials
+        unless @materials_list
+          list = []
+          @faces.each do |face|
+            material = face.material
+            next unless material
+
+            face.vertices.each do # Add material to each vertex
+              list << material.diffuse.red
+              list << material.diffuse.green
+              list << material.diffuse.blue
+              # list << material.alpha
+            end
+          end
+
+          @materials_list_size = list.size
+          @materials_list = list.pack("f*")
+        end
+
+        @materials_list
+      end
+    end
+  end
+end

data/lib/cyberarm_engine/model/parser.rb

@@ -0,0 +1,74 @@
+module CyberarmEngine
+  TextureCoordinate = Struct.new(:u, :v, :weight)
+  Point = Struct.new(:x, :y)
+  Color = Struct.new(:red, :green, :blue, :alpha)
+  Face  = Struct.new(:vertices, :uvs, :normals, :colors, :material, :smoothing)
+
+  class Model
+    class Parser
+      @@parsers = []
+
+      def self.handles
+        raise NotImplementedError,
+              "Model::Parser#handles must return an array of file extensions that this parser supports"
+      end
+
+      def self.inherited(parser)
+        @@parsers << parser
+      end
+
+      def self.find(file_type)
+        @@parsers.find do |parser|
+          parser.handles.include?(file_type)
+        end
+      end
+
+      def self.supported_formats
+        @@parsers.map { |parser| parser.handles }.flatten.map { |s| ".#{s}" }.join(", ")
+      end
+
+      def initialize(model)
+        @model = model
+      end
+
+      def parse
+      end
+
+      def set_object(id: nil, name: nil)
+        _model = nil
+
+        if id
+          _model = @model.objects.find { |o| o.id == id }
+        elsif name
+          _model = @model.objects.find { |o| o.name == name }
+        else
+          raise "Must provide either an id: or name:"
+        end
+
+        if _model
+          @model.current_object = _model
+        else
+          raise "Couldn't find ModelObject!"
+        end
+      end
+
+      def change_object(id, name)
+        @model.objects << Model::ModelObject.new(id, name)
+        @model.current_object = @model.objects.last
+      end
+
+      def set_material(name)
+        @model.current_material = name
+        @model.current_object.materials << current_material
+      end
+
+      def add_material(name, material)
+        @model.materials[name] = material
+      end
+
+      def current_material
+        @model.materials[@model.current_material]
+      end
+    end
+  end
+end