wavefront 0.0.5

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in wavefront.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Misha Conway
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,95 @@
+# Wavefront
+
+    This is a simple gem for importing and exporting wavefront object files. As it is in it's initial version there are
+    some unsupported features that will be coming in future updates. Still, I hope this initial version suffices for
+    your most basic wavefront obj needs
+
+    Here are some of the things it supports importing and exporting:
+        -objects
+        -groups
+        -smoothing groups
+        -vertices, normals, and texture coordinates
+
+    Some additional operations supported are:
+        -computing a simple vertex buffer from the wavefront model
+
+    Some features that are coming in the future
+        -ability to compute a vertex/index buffer pair since these will be more optimal than a single giant vertex buffer
+        -ability to scale, transform, rotate, and unitize the obj
+        -materials (this is a feature I am currently working on, but is not available in the current version)
+        -ability to support more than one object. Even though wavefront spec says a file should have only one object,
+            there are some 3d modeling tools that export anomalous .obj files and I plan to support them even though
+            they are out of spec.
+        -parameter space vertices (these are an exotic rarely used feature in the obj format but I plan to support them)
+        -higher-order surfaces using several different kinds of interpolation, such as Taylor and B-splines
+            (again this is an exotic rarely used feauture in the obj format)
+        #############################################################################################################
+        #############################################################################################################
+        Note: -Let me know if there are any features I should include that are missing from this list.
+              -Also please let me know about any bugs or crashes you encounter. My email is MishaAConway@gmail.com.
+               If you attach a wavefront model that fails to parse with this gem, I will see what I can do to
+               update the code.
+
+
+
+
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'wavefront'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install wavefront
+
+## Usage
+
+    So here is a little primer. A wavefront object basically contains a single object. This single object contains
+    several groups. Each of these groups can contain sub smoothing groups. Both groups and smoothing groups have a
+    list of triangles. Each triangle contains three vertices while each vertex contains a position, normal, and
+    texture coordinate. I've tried to make it so that the parsed WavefrontFile instance represents this hierarchy
+    as much as possible. Now with primer aside, let's go over some sample values we can extract from the
+    WavefrontFile instance.
+
+    w = Wavefront::File.new "my_wavefront_model"                  (import file, including .obj extension is optional)
+    w.export "my_exported_wavefront_model"                        (export file, including .obj extension is optional)
+
+    vertex_buffer = w.compute_vertex_buffer                       (compute an array of vertices from file)
+
+    w.object                                                                (inspect object itself)
+    group = w.object.groups.first                                           (grab the first group)
+    group.name                                                              (see what it's name is)
+    smoothing_group = group.smoothing_groups.first                          (grab the first smoothing group)
+    smoothing_group.name                                                    (see what it's name is)
+    triangles = smoothing_group.triangles                                   (grab triangles from this smoothing group)
+    triangle = triangles.first                                              (grab the first triangle)
+    vertices = triangle.vertices                                            (get the 3 vertices in this triangle)
+    vertex = vertices.first                                                 (get the first vertex)
+    vertex.position                                                         (look at position)
+    vertex.normal                                                           (look at normal)
+    vertex.tex                                                              (look at texture coordinate)
+
+
+    This is just the surface of what you can do to explore the parsed wavefront file. When I get more time, I'll try
+    to make these usage examples better.
+
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+or.....
+
+Let me know about any issues and send me any wavefront obj models that crash the app so that I can update the gem
+to support them.

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/group.rb

@@ -0,0 +1,45 @@
+module Wavefront
+  class Group
+    attr_reader :name, :triangles, :material, :smoothing_groups
+
+    def initialize n
+      @name = n
+      @triangles = []
+      @smoothing_groups = []
+    end
+
+    def set_smoothing_group smoothing_group_name
+      if smoothing_group_name.nil? || 'off' == smoothing_group_name.to_s || '0' == smoothing_group_name.to_s
+        @current_smoothing_group = nil
+      else
+        @current_smoothing_group = smoothing_groups.find{ |sg| sg.name.to_s == smoothing_group_name.to_s }
+        if @current_smoothing_group.nil?
+          @current_smoothing_group = SmoothingGroup.new smoothing_group_name
+          smoothing_groups << @current_smoothing_group
+        end
+      end
+    end
+
+    def merge_smoothing_groups!
+      set_smoothing_group nil
+      smoothing_groups.each { |smoothing_group| triangles += smoothing_group.triangles }
+      smoothing_groups.clear
+    end
+
+    def add_triangle triangle
+      if @current_smoothing_group
+        @current_smoothing_group.add_triangle triangle
+      else
+        @triangles << triangle
+      end
+    end
+
+    def num_faces
+      triangles.size + smoothing_groups.map(&:num_faces).inject(:+).to_i
+    end
+
+    def num_vertices
+      triangles.size * 3 + smoothing_groups.map(&:num_vertices).inject(:+).to_i
+    end
+  end
+end

data/lib/smoothing_group.rb

@@ -0,0 +1,26 @@
+module Wavefront
+  class SmoothingGroup
+    attr_reader :name, :triangles
+
+    def initialize _name
+      @name = _name
+      @triangles = []
+    end
+
+    def add_triangle triangle
+      @triangles << triangle
+    end
+
+    def num_faces
+      triangles.size
+    end
+
+    def num_vertices
+      triangles.size * 3
+    end
+
+    def to_s
+      "Smoothing Group\n\tNum Faces: #{num_faces}"
+    end
+  end
+end

data/lib/triangle.rb

@@ -0,0 +1,10 @@
+module Wavefront
+  class Triangle
+    attr_reader :vertices
+
+    def initialize v
+      raise "A triangle can only have three vertices!" if 3 != v.size
+      @vertices = v
+    end
+  end
+end

data/lib/vec3.rb

@@ -0,0 +1,15 @@
+module Wavefront
+  class Vec3
+    attr_reader :x, :y, :z
+
+    def initialize *args
+      @x = args[0] if args.size > 0
+      @y = args[1] if args.size > 1
+      @z = args[2] if args.size > 2
+    end
+
+    def to_s
+      [x, y, z].compact.join ' '
+    end
+  end
+end

data/lib/vertex.rb

@@ -0,0 +1,10 @@
+module Wavefront
+  class Vertex
+    attr_reader :position, :tex, :normal, :position_index, :texture_index, :normal_index
+
+    def initialize p, uv, n, p_index, t_index, n_index
+      @position, @uv, @normal = p, uv, n
+      @position_index, @texture_index, @normal_index = p_index, t_index, n_index
+    end
+  end
+end

data/lib/wavefront.rb

@@ -0,0 +1,9 @@
+require "wavefront/version"
+require "vec3"
+require "triangle"
+require "vertex"
+require "smoothing_group"
+require "group"
+require "wavefront_object"
+require "wavefront_file"
+

data/lib/wavefront/version.rb

@@ -0,0 +1,3 @@
+module Wavefront
+  VERSION = "0.0.5"
+end

data/lib/wavefront_file.rb

@@ -0,0 +1,45 @@
+module Wavefront
+  class File
+    attr_reader :file_path, :objects
+
+    def initialize file_path
+      @file_path = file_path
+      unless /\.obj$/.match @file_path
+        @file_path += ".obj"
+      end
+
+      @objects = []
+
+      file = ::File.new @file_path, 'r'
+      while line = file.gets
+        components = line.split
+        type = components.shift
+        if 'o' == type
+          name = components.first
+          objects << Wavefront::Object.new(name, file)
+        end
+      end
+
+      #no object was found so let's create one, rewind back to file, and try parsing again
+      if objects.size.zero?
+        file.rewind
+        objects << Wavefront::Object.new("default", file)
+      end
+
+      file.close
+    end
+
+    def export out_path
+      raise "no objects to export!" if objects.size.zero?
+      objects.first.export out_path
+    end
+
+    def compute_vertex_buffer
+      object.compute_vertex_buffer
+    end
+
+    def object
+      objects.first
+    end
+  end
+end

data/lib/wavefront_object.rb

@@ -0,0 +1,145 @@
+module Wavefront
+  class Object
+    attr_reader :file, :vertices, :texture_coordinates, :normals, :faces, :groups, :name
+
+    def initialize name, file
+      @name = name
+      @file = file
+      @vertices, @texture_coordinates, @normals, @faces, @groups = [], [], [], [], []
+      parse!
+    end
+
+    def to_s
+      s = "Object\n\tName: #{name}\n\tNum Vertices: #{vertices.size}\n\tNum Faces: #{num_faces}"
+      unless groups.size.zero?
+        s += "\n"
+        groups.each do |group|
+          s += "\tGroup #{group.name}\n\t\tNum Vertices: #{group.num_vertices}\n\t\tNum Faces: #{group.num_faces}"
+          group.smoothing_groups.each do |smoothing_group|
+            s += "\n\t\t\tSmoothing Group #{smoothing_group.name}\n\t\t\t\tNum Vertices: #{smoothing_group.num_vertices}\n\t\t\t\tNum Faces: #{smoothing_group.num_faces}"
+          end
+        end
+      end
+      s
+    end
+
+    def num_faces
+      @num_faces = 0
+      groups.each do |g|
+        @num_faces += g.num_faces
+      end
+      @num_faces
+    end
+
+
+
+
+    def export file_name
+      unless /\.obj$/.match file_name
+        file_name += ".obj"
+      end
+
+      ::File.delete file_name if ::File.exist? file_name
+      open file_name, 'a' do |f|
+        f.puts "# Exported from Wavefront Ruby Gem Version #{Wavefront::VERSION}"
+        f.puts "o #{name}"
+        f.puts "##{vertices.size} vertices, #{num_faces} faces"
+        vertices.each { |v| f.puts "v #{v}" }
+        texture_coordinates.each { |t| f.puts "vt #{t}" }
+        normals.each { |n| f.puts "vn #{n}" }
+        groups.each do |group|
+          f.puts "g ##{group.name}"
+          group.triangles.each do |t|
+            f.puts 'f ' + t.vertices.map { |v| [v.position_index, v.texture_index, v.normal_index].join '/' }.join(' ')
+          end
+          group.smoothing_groups.each do |smoothing_group|
+            f.puts "s #{smoothing_group.name}"
+            smoothing_group.triangles.each do |t|
+              f.puts 'f ' + t.vertices.map { |v| [v.position_index, v.texture_index, v.normal_index].join '/' }.join(' ')
+            end
+          end
+        end
+      end
+    end
+
+    def compute_vertex_buffer
+      vertex_buffer = []
+      groups.each do |group|
+        group.triangles.each { |t| vertex_buffer << t.vertices }
+        group.smoothing_groups.each do |smoothing_group|
+          smoothing_group.triangles.each { |t| vertex_buffer << t.vertices }
+        end
+      end
+      vertex_buffer.flatten
+    end
+
+    def compute_vertex_buffer_and_index_buffer
+      raise "not yet implemented in version #{Wavefront::VERSION}! will be coming in future versions!"
+      vertex_buffer, index_buffer = [], []
+
+
+      {:vertex_buffer => vertex_buffer, :index_buffer => index_buffer}
+    end
+
+private
+    def parse!
+      while line = file.gets
+        components = line.split
+        type = components.shift
+        case type
+          when 'v'
+            vertices << Vec3.new(*components.map(&:to_f))
+          when 'vt'
+            texture_coordinates << Vec3.new(*components.map(&:to_f))
+          when 'vn'
+            normals << Vec3.new(*components.map(&:to_f))
+          when 'vp'
+            #TODO: handle these later
+          when 'f'
+            triangles = []
+            if components.size > 4
+              raise "Sorry this version of the gem does not support polygons with more than 4 points. Updates to this gem will fix this issue."
+            end
+            if components.size == 4
+              triangles << triangle_from_face_components(components[0, 3])
+              triangles << triangle_from_face_components([components[0], components[2], components[3]])
+            elsif components.size == 3
+              triangles << triangle_from_face_components(components)
+            else
+              raise "current version of gem cannot parse triangles with #{components.size} verts!"
+            end
+            triangles.each { |triangle| @current_group.add_triangle triangle }
+          when 'g'
+            name = components.first
+            @current_group = Group.new name
+            groups << @current_group
+
+          when 's'
+            @current_group.set_smoothing_group components.first
+          when 'o'
+            raise "Wavefront Version #{Wavefront::VERSION} does not support obj files with more than one object. If you encounter such an obj that fails to load, please attach and email to mishaAconway@gmail.com so that I can update the gem to support the file."
+            #file.seek -line.size, IO::SEEK_CUR
+            #return
+        end
+      end
+    end
+
+    def triangle_from_face_components face_components
+      triangle_vertices = []
+      face_components.each do |vertex_str|
+        vertex_str_components = vertex_str.split('/').map { |index| index.size > 0 ? index.to_i : nil }
+        position_index = vertex_str_components[0]
+        tex_index = vertex_str_components[1]
+
+        normal_index = vertex_str_components[2]
+
+        position = vertices[position_index]
+        tex_coordinate = tex_index ? texture_coordinates[tex_index] : nil
+        normal = normals[normal_index]
+
+        triangle_vertices << Vertex.new(position, tex_coordinate, normal, position_index, tex_index, normal_index)
+      end
+      Triangle.new triangle_vertices
+    end
+  end
+end

data/wavefront.gemspec

@@ -0,0 +1,19 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'wavefront/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "wavefront"
+  gem.version       = Wavefront::VERSION
+  gem.authors       = ["Misha Conway"]
+  gem.email         = ["MishaAConway@gmail.com"]
+  gem.description   = %q{Wavefront parser and exporter}
+  gem.summary       = %q{Wavefront parser and exporter}
+  gem.homepage      = "https://github.com/MishaConway/wavefront-ruby"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+end

metadata

@@ -0,0 +1,60 @@
+--- !ruby/object:Gem::Specification
+name: wavefront
+version: !ruby/object:Gem::Version
+  version: 0.0.5
+  prerelease: 
+platform: ruby
+authors:
+- Misha Conway
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-03-07 00:00:00.000000000 Z
+dependencies: []
+description: Wavefront parser and exporter
+email:
+- MishaAConway@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/group.rb
+- lib/smoothing_group.rb
+- lib/triangle.rb
+- lib/vec3.rb
+- lib/vertex.rb
+- lib/wavefront.rb
+- lib/wavefront/version.rb
+- lib/wavefront_file.rb
+- lib/wavefront_object.rb
+- wavefront.gemspec
+homepage: https://github.com/MishaConway/wavefront-ruby
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+  none: false
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+  none: false
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Wavefront parser and exporter
+test_files: []