cyberarm_engine 0.13.0 → 0.17.0

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

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

@@ -0,0 +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

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

@@ -0,0 +1,154 @@
+module CyberarmEngine
+  class WavefrontParser < Model::Parser
+    def self.handles
+      [:obj]
+    end
+
+    def parse
+      lines = 0
+      list = File.read(@model.file_path).split("\n")
+      list.each do |line|
+        lines += 1
+        line = line.strip
+
+        array = line.split(" ")
+        case array[0]
+        when "mtllib"
+          @model.material_file = array[1]
+          parse_mtllib
+        when "usemtl"
+          set_material(array[1])
+        when "o"
+          change_object(nil, array[1])
+        when "s"
+          set_smoothing(array[1])
+        when "v"
+          add_vertex(array)
+        when "vt"
+          add_texture_coordinate(array)
+
+        when "vn"
+          add_normal(array)
+
+        when "f"
+          verts = []
+          uvs   = []
+          norms = []
+          array[1..3].each do |f|
+            verts << f.split("/")[0]
+            uvs   << f.split("/")[1]
+            norms << f.split("/")[2]
+          end
+
+          face = Face.new
+          face.vertices = []
+          face.uvs      = []
+          face.normals  = []
+          face.colors   = []
+          face.material = current_material
+          face.smoothing = @model.smoothing
+
+          mat   = face.material.diffuse
+          color = mat
+
+          verts.each_with_index do |v, index|
+            if uvs.first != ""
+              face.vertices << @model.vertices[Integer(v) - 1]
+              face.uvs      << @model.uvs[Integer(uvs[index]) - 1]
+              face.normals  << @model.normals[Integer(norms[index]) - 1]
+              face.colors   << color
+            else
+              face.vertices << @model.vertices[Integer(v) - 1]
+              face.uvs      << nil
+              face.normals  << @model.normals[Integer(norms[index]) - 1]
+              face.colors   << color
+            end
+          end
+
+          @model.current_object.faces << face
+          @model.faces << face
+        end
+      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_mtllib
+      file = File.open(@model.file_path.sub(File.basename(@model.file_path), "") + @model.material_file, "r")
+      file.readlines.each do |line|
+        array = line.strip.split(" ")
+        case array.first
+        when "newmtl"
+          material = Model::Material.new(array.last)
+          @model.current_material = array.last
+          @model.materials[array.last] = material
+        when "Ns" # Specular Exponent
+        when "Ka" # Ambient color
+          @model.materials[@model.current_material].ambient  = Color.new(Float(array[1]), Float(array[2]),
+                                                                         Float(array[3]))
+        when "Kd" # Diffuse color
+          @model.materials[@model.current_material].diffuse  = Color.new(Float(array[1]), Float(array[2]),
+                                                                         Float(array[3]))
+        when "Ks" # Specular color
+          @model.materials[@model.current_material].specular = Color.new(Float(array[1]), Float(array[2]),
+                                                                         Float(array[3]))
+        when "Ke" # Emissive
+        when "Ni" # Unknown (Blender Specific?)
+        when "d"  # Dissolved (Transparency)
+        when "illum" # Illumination model
+        when "map_Kd" # Diffuse texture
+          texture = File.basename(array[1])
+          texture_path = "#{File.expand_path('../../', @model.file_path)}/textures/#{texture}"
+          @model.materials[@model.current_material].set_texture(texture_path)
+        end
+      end
+    end
+
+    def set_smoothing(value)
+      @model.smoothing = value == "1"
+    end
+
+    def add_vertex(array)
+      @model.vertex_count += 1
+      vert = nil
+      if array.size == 5
+        vert = Vector.new(Float(array[1]), Float(array[2]), Float(array[3]), Float(array[4]))
+      elsif array.size == 4
+        vert = Vector.new(Float(array[1]), Float(array[2]), Float(array[3]), 1.0)
+      else
+        raise
+      end
+      @model.current_object.vertices << vert
+      @model.vertices << vert
+    end
+
+    def add_normal(array)
+      vert = nil
+      if array.size == 5
+        vert = Vector.new(Float(array[1]), Float(array[2]), Float(array[3]), Float(array[4]))
+      elsif array.size == 4
+        vert = Vector.new(Float(array[1]), Float(array[2]), Float(array[3]), 1.0)
+      else
+        raise
+      end
+      @model.current_object.normals << vert
+      @model.normals << vert
+    end
+
+    def add_texture_coordinate(array)
+      texture = nil
+      if array.size == 4
+        texture = Vector.new(Float(array[1]), 1 - Float(array[2]), Float(array[3]))
+      elsif array.size == 3
+        texture = Vector.new(Float(array[1]), 1 - Float(array[2]), 1.0)
+      else
+        raise
+      end
+      @model.uvs << texture
+      @model.current_object.uvs << texture
+    end
+  end
+end

data/lib/cyberarm_engine/model_cache.rb

@@ -0,0 +1,31 @@
+module CyberarmEngine
+  module ModelCache
+    CACHE = {}
+
+    def self.find_or_cache(manifest:)
+      model_file = manifest.file_path + "/model/#{manifest.model}"
+
+      type = File.basename(model_file).split(".").last.to_sym
+
+      if model = load_model_from_cache(type, model_file)
+        model
+      else
+        model = CyberarmEngine::Model.new(file_path: model_file)
+        cache_model(type, model_file, model)
+
+        model
+      end
+    end
+
+    def self.load_model_from_cache(type, model_file)
+      return CACHE[type][model_file] if CACHE[type].is_a?(Hash) && (CACHE[type][model_file])
+
+      false
+    end
+
+    def self.cache_model(type, model_file, model)
+      CACHE[type] = {} unless CACHE[type].is_a?(Hash)
+      CACHE[type][model_file] = model
+    end
+  end
+end

data/lib/cyberarm_engine/opengl.rb

@@ -0,0 +1,28 @@
+begin
+  require "opengl"
+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 != GL_NO_ERROR
+      warn "OpenGL error detected by handler at: #{caller[0]}"
+      warn "    #{gluErrorString(e)} (#{e})\n"
+      exit if window.exit_on_opengl_error?
+    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"

data/lib/cyberarm_engine/opengl/light.rb

@@ -0,0 +1,50 @@
+module CyberarmEngine
+  class Light
+    DIRECTIONAL = 0
+    POINT = 1
+    SPOT = 2
+
+    attr_reader :light_id
+    attr_accessor :type, :ambient, :diffuse, :specular, :position, :direction, :intensity
+
+    def initialize(
+      id:,
+      type: Light::POINT,
+      ambient: Vector.new(0.5, 0.5, 0.5),
+      diffuse: Vector.new(1, 1, 1),
+      specular: Vector.new(0.2, 0.2, 0.2),
+      position: Vector.new(0, 0, 0),
+      direction: Vector.new(0, 0, 0),
+      intensity: 1
+    )
+      @light_id = id
+      @type = type
+
+      @ambient  = ambient
+      @diffuse  = diffuse
+      @specular = specular
+      @position = position
+      @direction = direction
+
+      @intensity = intensity
+    end
+
+    def draw
+      glLightfv(@light_id, GL_AMBIENT, convert(@ambient).pack("f*"))
+      glLightfv(@light_id, GL_DIFFUSE, convert(@diffuse, true).pack("f*"))
+      glLightfv(@light_id, GL_SPECULAR, convert(@specular, true).pack("f*"))
+      glLightfv(@light_id, GL_POSITION, convert(@position).pack("f*"))
+      glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, 1)
+      glEnable(GL_LIGHTING)
+      glEnable(@light_id)
+    end
+
+    def convert(struct, apply_intensity = false)
+      if apply_intensity
+        struct.to_a.compact.map { |i| i * @intensity }
+      else
+        struct.to_a.compact
+      end
+    end
+  end
+end