cyberarm_engine 0.24.5 → 0.25.0

data/lib/cyberarm_engine/model/mesh.rb

@@ -1,131 +1,131 @@
-module CyberarmEngine
-  class Model
-    class Mesh
-      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
+module CyberarmEngine
+  class Model
+    class Mesh
+      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

@@ -1,74 +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 Mesh!"
-        end
-      end
-
-      def change_object(id, name)
-        @model.objects << Model::Mesh.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
+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 Mesh!"
+        end
+      end
+
+      def change_object(id, name)
+        @model.objects << Model::Mesh.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

data/lib/cyberarm_engine/model/parsers/collada_parser.rb

@@ -1,138 +1,138 @@
-module CyberarmEngine
-  class ColladaParser < Model::Parser
-    def self.handles
-      [:dae]
-    end
-
-    def parse
-      @collada = Nokogiri::XML(File.read(@model.file_path))
-
-      @collada.css("library_materials material").each do |material|
-        parse_material(material)
-      end
-
-      @collada.css("library_geometries geometry").each do |geometry|
-        parse_geometry(geometry)
-      end
-
-      @model.calculate_bounding_box(@model.vertices, @model.bounding_box)
-      @model.objects.each do |o|
-        @model.calculate_bounding_box(o.vertices, o.bounding_box)
-      end
-    end
-
-    def parse_material(material)
-      name = material.attributes["id"].value
-      effect_id = material.at_css("instance_effect").attributes["url"].value
-
-      mat = Model::Material.new(name)
-      effect = @collada.at_css("[id=\"#{effect_id.sub('#', '')}\"]")
-
-      emission = effect.at_css("emission color")
-      diffuse = effect.at_css("diffuse color").children.first.to_s.split(" ").map { |c| Float(c) }
-
-      mat.diffuse = Color.new(*diffuse[0..2])
-
-      add_material(name, mat)
-    end
-
-    def parse_geometry(geometry)
-      geometry_id = geometry.attributes["id"].value
-      geometry_name = geometry.attributes["name"].value
-
-      change_object(geometry_id, geometry_name)
-
-      mesh = geometry.at_css("mesh")
-
-      get_positions(geometry_id, mesh)
-      get_normals(geometry_id, mesh)
-      get_texture_coordinates(geometry_id, mesh)
-
-      project_node(geometry_name)
-      build_faces(geometry_id, mesh)
-    end
-
-    def get_positions(id, mesh)
-      positions = mesh.at_css("[id=\"#{id}-positions\"]")
-      array = positions.at_css("[id=\"#{id}-positions-array\"]")
-
-      stride = Integer(positions.at_css("[source=\"##{id}-positions-array\"]").attributes["stride"].value)
-      list = array.children.first.to_s.split(" ").map { |f| Float(f) }.each_slice(stride).each do |slice|
-        position = Vector.new(*slice)
-        @model.current_object.vertices << position
-        @model.vertices << position
-      end
-    end
-
-    def get_normals(id, mesh)
-      normals = mesh.at_css("[id=\"#{id}-normals\"]")
-      array = normals.at_css("[id=\"#{id}-normals-array\"]")
-
-      stride = Integer(normals.at_css("[source=\"##{id}-normals-array\"]").attributes["stride"].value)
-      list = array.children.first.to_s.split(" ").map { |f| Float(f) }.each_slice(stride).each do |slice|
-        normal = Vector.new(*slice)
-        @model.current_object.normals << normal
-        @model.normals << normal
-      end
-    end
-
-    def get_texture_coordinates(id, mesh)
-    end
-
-    def project_node(name)
-      @collada.css("library_visual_scenes visual_scene node").each do |node|
-        next unless node.attributes["name"].value == name
-
-        transform = Transform.new(node.at_css("matrix").children.first.to_s.split(" ").map { |f| Float(f) })
-
-        @model.current_object.vertices.each do |vert|
-          v = vert.multiply_transform(transform)
-          vert.x = v.x
-          vert.y = v.y
-          vert.z = v.z
-          vert.w = v.w
-        end
-
-        break
-      end
-    end
-
-    def build_faces(_id, mesh)
-      material_name = mesh.at_css("triangles").attributes["material"].value
-      set_material(material_name)
-
-      positions_index = []
-      normals_index = []
-      uvs_index = []
-
-      mesh.at_css("triangles p").children.first.to_s.split(" ").map { |i| Integer(i) }.each_slice(3).each do |slice|
-        positions_index << slice[0]
-        normals_index << slice[1]
-        uvs_index << slice[2]
-      end
-
-      norm_index = 0
-      positions_index.each_slice(3) do |slice|
-        face = Face.new
-        face.vertices = []
-        face.uvs      = []
-        face.normals  = []
-        face.colors   = []
-        face.material = current_material
-        face.smoothing = @model.smoothing
-
-        slice.each do |index|
-          face.vertices << @model.vertices[index]
-          # face.uvs << @model.uvs[index]
-          face.normals << @model.normals[normals_index[norm_index]]
-          face.colors << current_material.diffuse
-
-          norm_index += 1
-        end
-
-        @model.current_object.faces << face
-        @model.faces << face
-      end
-    end
-  end
-end
+module CyberarmEngine
+  class ColladaParser < Model::Parser
+    def self.handles
+      [:dae]
+    end
+
+    def parse
+      @collada = Nokogiri::XML(File.read(@model.file_path))
+
+      @collada.css("library_materials material").each do |material|
+        parse_material(material)
+      end
+
+      @collada.css("library_geometries geometry").each do |geometry|
+        parse_geometry(geometry)
+      end
+
+      @model.calculate_bounding_box(@model.vertices, @model.bounding_box)
+      @model.objects.each do |o|
+        @model.calculate_bounding_box(o.vertices, o.bounding_box)
+      end
+    end
+
+    def parse_material(material)
+      name = material.attributes["id"].value
+      effect_id = material.at_css("instance_effect").attributes["url"].value
+
+      mat = Model::Material.new(name)
+      effect = @collada.at_css("[id=\"#{effect_id.sub('#', '')}\"]")
+
+      emission = effect.at_css("emission color")
+      diffuse = effect.at_css("diffuse color").children.first.to_s.split(" ").map { |c| Float(c) }
+
+      mat.diffuse = Color.new(*diffuse[0..2])
+
+      add_material(name, mat)
+    end
+
+    def parse_geometry(geometry)
+      geometry_id = geometry.attributes["id"].value
+      geometry_name = geometry.attributes["name"].value
+
+      change_object(geometry_id, geometry_name)
+
+      mesh = geometry.at_css("mesh")
+
+      get_positions(geometry_id, mesh)
+      get_normals(geometry_id, mesh)
+      get_texture_coordinates(geometry_id, mesh)
+
+      project_node(geometry_name)
+      build_faces(geometry_id, mesh)
+    end
+
+    def get_positions(id, mesh)
+      positions = mesh.at_css("[id=\"#{id}-positions\"]")
+      array = positions.at_css("[id=\"#{id}-positions-array\"]")
+
+      stride = Integer(positions.at_css("[source=\"##{id}-positions-array\"]").attributes["stride"].value)
+      list = array.children.first.to_s.split(" ").map { |f| Float(f) }.each_slice(stride).each do |slice|
+        position = Vector.new(*slice)
+        @model.current_object.vertices << position
+        @model.vertices << position
+      end
+    end
+
+    def get_normals(id, mesh)
+      normals = mesh.at_css("[id=\"#{id}-normals\"]")
+      array = normals.at_css("[id=\"#{id}-normals-array\"]")
+
+      stride = Integer(normals.at_css("[source=\"##{id}-normals-array\"]").attributes["stride"].value)
+      list = array.children.first.to_s.split(" ").map { |f| Float(f) }.each_slice(stride).each do |slice|
+        normal = Vector.new(*slice)
+        @model.current_object.normals << normal
+        @model.normals << normal
+      end
+    end
+
+    def get_texture_coordinates(id, mesh)
+    end
+
+    def project_node(name)
+      @collada.css("library_visual_scenes visual_scene node").each do |node|
+        next unless node.attributes["name"].value == name
+
+        transform = Transform.new(node.at_css("matrix").children.first.to_s.split(" ").map { |f| Float(f) })
+
+        @model.current_object.vertices.each do |vert|
+          v = vert.multiply_transform(transform)
+          vert.x = v.x
+          vert.y = v.y
+          vert.z = v.z
+          vert.w = v.w
+        end
+
+        break
+      end
+    end
+
+    def build_faces(_id, mesh)
+      material_name = mesh.at_css("triangles").attributes["material"].value
+      set_material(material_name)
+
+      positions_index = []
+      normals_index = []
+      uvs_index = []
+
+      mesh.at_css("triangles p").children.first.to_s.split(" ").map { |i| Integer(i) }.each_slice(3).each do |slice|
+        positions_index << slice[0]
+        normals_index << slice[1]
+        uvs_index << slice[2]
+      end
+
+      norm_index = 0
+      positions_index.each_slice(3) do |slice|
+        face = Face.new
+        face.vertices = []
+        face.uvs      = []
+        face.normals  = []
+        face.colors   = []
+        face.material = current_material
+        face.smoothing = @model.smoothing
+
+        slice.each do |index|
+          face.vertices << @model.vertices[index]
+          # face.uvs << @model.uvs[index]
+          face.normals << @model.normals[normals_index[norm_index]]
+          face.colors << current_material.diffuse
+
+          norm_index += 1
+        end
+
+        @model.current_object.faces << face
+        @model.faces << face
+      end
+    end
+  end
+end