obj_parser 0.0.1

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 obj_parser.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Laurent Cobos
+
+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,46 @@
+# ObjParser
+
+Parse a 3D obj file to a ruby data structure.
+Can compute tangent per vertex.
+Can merge vertice, normals, and textures indexes into a single index for OpenGL use case.
+
+- Support triangle primitives
+- Support only one model per obj file
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'obj_parser'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install obj_parser
+
+## Usage
+
+Sample to parse an obj file, generate tangents and transform to a single indexed 3D model.
+
+    @parser = ObjLoader::ObjParser.new
+    obj = @parser.load(File.open("/Users/lcobos/development/ios/OpenGL-4/models/cube.obj"))
+    obj.compute_tangents
+    obj = ObjLoader::SingleIndexedObj.build_with_obj(obj)
+    
+    puts obj.vertice.map(&:data).join(",")
+    puts obj.normals.map(&:data).join(",")
+    puts obj.textures.map(&:data).join(",")
+    puts obj.tangents.map(&:data).join(",")
+    puts obj.indexes.join(",")
+  
+
+## Contributing
+
+1. Fork it ( http://github.com/<my-github-username>/obj_parser/fork )
+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

data/Rakefile

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

data/lib/obj_parser.rb

@@ -0,0 +1,8 @@
+require "obj_parser/version"
+require "obj_parser/obj_parser"
+require "obj_parser/single_indexed_obj"
+require "obj_parser/point"
+
+module ObjLoader
+  # Your code goes here...
+end

data/lib/obj_parser/face.rb

@@ -0,0 +1,8 @@
+module ObjLoader
+  class Face
+    attr_accessor :normals
+    attr_accessor :vertice
+    attr_accessor :textures
+    attr_accessor :tangents
+  end
+end

data/lib/obj_parser/math_utils.rb

@@ -0,0 +1,107 @@
+require 'matrix'
+
+module ObjLoader
+
+  module MathUtils
+      
+    def self.tangent_for_vertices_and_texures(vertices, textures)
+    	u1, u2, u3 = textures.map {|texture| texture[0]}
+    	v1, v2, v3 = textures.map {|texture| texture[1]}
+    	p1, p2, p3 = vertices.map {|vertex| normalized_vector(vertex)}
+    	#Tangent formula: http://jerome.jouvie.free.fr/opengl-tutorials/Lesson8.php
+    	nominator = substract_vectors( mul_vector_by_scalar(substract_vectors(p2, p1), (v3 - v1)), mul_vector_by_scalar(substract_vectors(p3, p1), (v2 - v1)))
+    	denominator = (u2 - u1) * (v3 - v1) - (v2 - v1) * (u3 - u1)
+    	denominator = denominator == 0 ? 1 : denominator
+    	divide_vector_by_scalar(nominator, denominator)
+    end
+  
+    def self.tangent2_for_vertices_and_texures(vertices, textures)
+    	u1, u2, u3 = textures.map {|texture| texture[0]}
+    	v1, v2, v3 = textures.map {|texture| texture[1]}
+    	p1, p2, p3 = vertices.map {|vertex| normalized_vector(vertex)}
+    	q1 = substract_vectors(p2, p1)
+    	q2 = substract_vectors(p3, p2)
+    	t1 = u2 - u1
+    	t2 = u3 - u1
+    	substract_vectors(mul_vector_by_scalar(q1, t2), mul_vector_by_scalar(q2, t1))
+    end
+  
+    def self.binormal2_for_vertices_and_texures(vertices, textures)
+    	u1, u2, u3 = textures.map {|texture| texture[0]}
+    	v1, v2, v3 = textures.map {|texture| texture[1]}
+    	p1, p2, p3 = vertices.map {|vertex| normalized_vector(vertex)}
+    	q1 = substract_vectors(p2, p1)
+    	q2 = substract_vectors(p3, p2)
+    	s1 = v2 - v1
+    	s2 = v3 - v1
+    	binormal = sum_vectors(mul_vector_by_scalar(q1, -s2), mul_vector_by_scalar(q2, s1))
+    end
+    
+    def self.cross_product(v1, v2)
+      [ ( (v1[1] * v2[2]) - (v1[2] * v2[1]) ),
+       - ( (v1[0] * v2[2]) - (v1[2] * v2[0]) ),
+         ( (v1[0] * v2[1]) - (v1[1] * v2[0]) ) ]
+    end
+ 
+    def self.substract_vectors a, b
+      [a[0] - b[0], a[1] - b[1], a[2] - b[2]]
+    end
+  
+    def self.sum_vectors a, b
+      [a[0] + b[0], a[1] + b[1], a[2] + b[2]]
+    end
+  
+    def self.mul_vector_by_scalar(vector, scalar)
+      vector.map {|component|  component * scalar}
+    end
+  
+    def self.divide_vector_by_scalar(vector, scalar)
+      vector.map {|component|  component / scalar}
+    end
+  
+    def self.vector_length(vector)
+      Math.sqrt(vector.map { |item| (item * item) }.reduce(:+))
+    end
+  
+    def self.normalized_vector(vector)
+    	current_vector_length = vector_length(vector)
+    	current_vector_length = current_vector_length == 0 ? 1 : current_vector_length
+    	vector.map do |component|
+    		component / current_vector_length
+    	end
+    end
+  
+    def self.dot(vector1, vector2)
+    	#http://en.wikipedia.org/wiki/Dot_product
+    	vector1.each_with_index.map do |component, index|
+    		component * vector2[index]
+    	end.inject(&:+)
+    end
+  
+    def self.orthogonalized_vector_with_vector(vector1, vector2)
+    	#Gram-Schmidt orthogonalization -> http://jerome.jouvie.free.fr/opengl-tutorials/Lesson8.php
+    	substract_vectors(vector1, mul_vector_by_scalar(vector2, dot(vector2, vector1)))
+    end
+		
+    def self.mul_mat_per_vector(mat, vector)
+    	m = Matrix[mat[0], mat[1], mat[2]]
+    	v = Matrix[ [vector[0]], [vector[1]], [vector[2]]]
+    	(m * v).to_a
+    end
+  
+    def self.mat_inverse(mat)
+    	m = Matrix[mat[0],mat[1], mat[2]]
+    	puts "non regular" unless m.regular?
+    	m.regular? ? m.inverse.to_a : m.to_a
+    end
+  
+    def self.normal_for_face_with_vertices(face_vertices)
+    	p1 = face_vertices[0]
+    	p2 = face_vertices[1]
+    	p3 = face_vertices[2]
+    	u = substract_vectors(p2, p1)
+    	v = substract_vectors(p3, p1)
+    	cross_product(u, v)
+    end
+  end
+end

data/lib/obj_parser/obj.rb

@@ -0,0 +1,99 @@
+require_relative 'face'
+require_relative 'math_utils'
+
+module ObjLoader
+  class Obj
+    VERTEX_BY_FACE = 3
+    attr_accessor :normals, :normals_indexes
+    attr_accessor :vertice, :vertice_indexes
+    attr_accessor :textures, :textures_indexes
+    attr_accessor :tangents, :tangents_indexes
+    attr_accessor :faces
+    
+    def initialize
+      self.vertice = []
+      self.normals = []
+      self.textures = []
+      self.tangents = []
+      self.vertice_indexes = []
+      self.normals_indexes = []
+      self.textures_indexes = []
+      self.tangents_indexes = []
+    end
+    
+    def resolve_faces
+      self.faces = (self.vertice_indexes.count / VERTEX_BY_FACE).times.map { Face.new }
+      self.faces.each_with_index do |face, face_index|
+        [:vertice, :normals, :textures, :tangents].each do |element|
+          point_indexes = (self.send("#{element}_indexes")[face_index * VERTEX_BY_FACE..-1] || []).take(VERTEX_BY_FACE)
+          points = point_indexes.map do |point_index|
+            self.send(element)[point_index]
+          end
+          face.send("#{element}=", points)
+        end
+      end
+    end
+    
+    def compute_tangents
+      self.resolve_faces
+    	self.tangents = []
+    	self.tangents_indexes = []
+    	pindex = 0
+    	self.faces.each do |face|
+      	pindex += 1
+    		tangent_for_face = ObjLoader::MathUtils::tangent_for_vertices_and_texures(face.vertice.map(&:data), face.textures.map(&:data))
+    		tangent_for_face = ObjLoader::MathUtils::normalized_vector(tangent_for_face)
+    		#set the same tangent for the 3 vertex of current face
+    		#re-compute tangents for duplicates vertices to get tangent per face
+    		face.vertice.each_with_index do |vertex, index|
+    			vertex.tangent.data = ObjLoader::MathUtils::sum_vectors(vertex.tangent.data, tangent_for_face)
+    		end
+      end
+	
+    	#orthonormalize
+    	self.faces.each_with_index do |face,pindex|
+    	  face.vertice.each_with_index do |vertex, index|
+    		vertex.tangent.data = ObjLoader::MathUtils::orthogonalized_vector_with_vector(vertex.tangent.data, self.normals[self.normals_indexes[pindex * 3 + index]].data)
+    		vertex.tangent.data = ObjLoader::MathUtils::normalized_vector(vertex.tangent.data)
+       	 end
+    	end
+	
+    	#binormal should be computed with per vertex tangent and summed for each vertex
+    	self.faces.each_with_index do |face,pindex|
+    		face.vertice.each_with_index do |vertex, index|
+    			binormal = ObjLoader::MathUtils::cross_product(self.normals[self.normals_indexes[pindex * 3 + index]].data, vertex.tangent.data)
+    			vertex.binormal.data = ObjLoader::MathUtils::sum_vectors(vertex.binormal.data, binormal)
+    		end
+    	end
+	
+    	self.faces.each_with_index do |face,pindex|
+    	  face.vertice.each_with_index do |vertex, index|
+      		vertex.binormal.data = ObjLoader::MathUtils::normalized_vector(vertex.binormal.data)
+      		if(ObjLoader::MathUtils::dot(ObjLoader::MathUtils::cross_product(self.normals[self.normals_indexes[pindex * 3 + index]].data, vertex.tangent.data), vertex.binormal.data) < 0.0)
+      			vertex.tangent.data[3] = -1.0 
+      		else
+      			vertex.tangent.data[3] = 1.0 
+      		end
+        end
+      end
+
+    	self.faces.each_with_index do |face, index|
+    		self.tangents += face.vertice.map(&:tangent)
+    		point_index = index * 3
+    		self.tangents_indexes += [point_index, point_index + 1, point_index + 2]
+    	end
+    end
+  
+    def tangents_self_check
+      self.resolve_faces
+      result = self.faces.each_with_index.map do |face, index| 
+    		face.vertice.map do |vertex|
+    		  ("%.2f" % ObjLoader::MathUtils::dot(vertex.tangent.data[0..2], vertex.normal.data)).to_f
+    		end.reduce(&:+)
+      end.reduce(&:+)
+      puts "RESULT: tangents and normals are orthogonal -> [#{result == 0 ? "VALID" : "NOT VALID"}]"
+      result == 0
+    end
+        
+  end
+end

data/lib/obj_parser/obj_parser.rb

@@ -0,0 +1,50 @@
+require_relative 'obj'
+require_relative 'point'
+
+module ObjLoader
+  class ObjParser
+    
+    VERTEX_LINE_ID = 'v'
+    NORMAL_LINE_ID = 'vn'
+    TEXTURE_LINE_ID = 'vt'
+    INDEXES_ID = 'f'
+    
+    attr_accessor :index_array_starting_at_index
+    
+    def initialize(index_array_starting_at = 0)
+      self.index_array_starting_at_index = 1
+    end
+    
+    def load(input_io)
+      obj = Obj.new
+      input_io.rewind
+      while(line = input_io.gets)
+        parser_for_line(line).call(line, obj)
+      end
+      obj
+    end
+    
+    private
+  
+    def parser_for_line(input_line)
+      {
+        NORMAL_LINE_ID => Proc.new {|line, obj| obj.normals <<  parse_point_on_line(line, :item_size => 3)},
+        TEXTURE_LINE_ID => Proc.new {|line, obj| obj.textures << parse_point_on_line(line, :item_size => 2)},
+        VERTEX_LINE_ID => Proc.new {|line, obj| obj.vertice << parse_point_on_line(line, :item_size => 3)},
+        INDEXES_ID => Proc.new { |line, obj|
+              v_regex = line.include?("/") ? /\s(\d+).*?\s(\d+).*?\s(\d+)/ : /\s*(\d+)\s*(\d+)\s*(\d+)/
+                              obj.vertice_indexes += (line.scan(v_regex).last || []).map{|index| index.to_i - self.index_array_starting_at_index}
+                    n_regex = line.include?("/") ? /\s\d*\/\d*\/(\d+)\s\d*\/\d*\/(\d+)\s\d*\/\d*\/(\d+)/ : /\s*(\d+)\s*(\d+)\s*(\d+)/
+                              obj.normals_indexes += (line.scan(n_regex).last || []).map{|index| index.to_i - self.index_array_starting_at_index}
+                    t_regex = line.include?("/") ? /\s\d*\/(\d+)\/\d*\s\d*\/(\d+)\/\d*\s\d*\/(\d+)\/\d*/ : /nothing/
+                              obj.textures_indexes += (line.scan(t_regex).last || []).map{|index| index.to_i - self.index_array_starting_at_index} }
+      }[input_line[0..1].rstrip] || Proc.new{|line, obj| [] }
+    end
+  
+    def parse_point_on_line(line, options = {})
+      item_size = {:item_size => 3}.merge(options)[:item_size] 
+      vertice_regex = "\s(.[^\s]*)" * item_size
+      Point.new((line.scan(/#{vertice_regex}/).last || []))
+    end
+  end
+end

data/lib/obj_parser/point.rb

@@ -0,0 +1,37 @@
+module ObjLoader
+  class Point
+    attr_accessor :data
+    attr_accessor :current_tangent
+    attr_accessor :current_binormal
+    attr_accessor :current_normal
+  
+    attr_accessor :normals
+    attr_accessor :textures
+    attr_accessor :flag
+  
+    def initialize(point_data = [0, 0, 0])
+      self.data = point_data.map(&:to_f)
+      self.textures = []
+      self.normals = []
+    end
+  
+    def tangent
+      self.current_tangent ||= Point.new
+    end
+   
+    def binormal
+      self.current_binormal ||= Point.new
+    end
+  
+    def normal
+      self.current_normal ||= Point.new
+    end
+     
+    def x; self.data[0]; end
+    def y; self.data[1]; end
+    def z; self.data[2]; end
+  
+    def u; self.data[0]; end
+    def v; self.data[1]; end
+  end
+end

data/lib/obj_parser/single_indexed_obj.rb

@@ -0,0 +1,83 @@
+require 'delegate.rb'
+
+module ObjLoader
+  class SingleIndexedObj < SimpleDelegator
+
+    attr_accessor :detailed_vertice
+    attr_accessor :indexes
+    
+    def target; __getobj__ ;end
+    def class; target.class ;end
+    
+    class << self
+      def build_with_obj(obj)
+        instance = self.new(obj)
+        instance.setup
+        instance
+      end  
+    end
+    
+    def setup
+      compute_detailed_vertice
+    	temp_vertice = []
+    	temp_normals = []
+    	temp_textures = []
+    	temp_tangents = []
+    	vec_indexes = []
+    	self.vertice_indexes.each_with_index do |vertex_index, index|
+    		vertex = self.detailed_vertice[vertex_index]
+    		normal = vertex.normals.select{|n| n == self.normals[self.normals_indexes[index]] }.first
+    		texture = vertex.textures.select{|n| n == self.textures[self.textures_indexes[index]] }.first
+    		if(point_used_for_vertex_at_index?(normal, vertex_index) && point_used_for_vertex_at_index?(texture, vertex_index))
+    			candids = texture.flag[vertex_index] & normal.flag[vertex_index]
+    			vec_indexes << candids.first
+    		else
+    			temp_vertice << vertex
+    			temp_tangents << vertex.tangent if vertex.tangent
+    			vec_indexes << temp_vertice.count - 1
+    			if(normal)
+    				temp_normals << normal
+    				normal.flag ||= {}
+    				normal.flag[vertex_index] ||= []
+    				normal.flag[vertex_index] << temp_vertice.count - 1
+    			end
+    			if(texture)
+    				temp_textures << texture
+    				texture.flag ||= {}
+    				texture.flag[vertex_index] ||= []
+    				texture.flag[vertex_index] << temp_vertice.count - 1
+    			end
+    		end
+    	end
+    	self.vertice = temp_vertice.map {|detailed_vertice| Point.new(detailed_vertice.data)}
+    	self.normals = temp_normals.map {|detailed_vertice| Point.new(detailed_vertice.data)}
+    	self.textures = temp_textures.map {|detailed_vertice| Point.new(detailed_vertice.data)}
+    	self.tangents = temp_tangents.map {|detailed_vertice| Point.new(detailed_vertice.data)}
+    	self.vertice_indexes = vec_indexes
+    	self.normals_indexes = vec_indexes
+    	self.textures_indexes = vec_indexes
+    	self.tangents_indexes = vec_indexes
+      self.indexes = vec_indexes
+    end
+    
+    private
+
+    def point_used_for_vertex_at_index?(point, vertex_index)
+  	  point && point.flag && point.flag[vertex_index]
+    end
+        
+    def compute_detailed_vertice
+      self.detailed_vertice = self.vertice.map {|vertex| Point.new(vertex.data)}
+    	self.vertice_indexes.each_with_index do |vertex_index, index|
+    		vertex = self.detailed_vertice[vertex_index]
+        [:normals, :textures, :tangents].each do |element|
+      		if(self.send(element).any? && self.send("#{element}_indexes")[index])
+      			candid = self.send(element)[self.send("#{element}_indexes")[index]] 
+      			vertex.send(element) << candid unless vertex.send(element).include?(candid)
+      		end
+        end
+    	end      
+    end
+    
+  end
+end

data/lib/obj_parser/version.rb

@@ -0,0 +1,3 @@
+module ObjLoader
+  VERSION = "0.0.1"
+end

data/obj_parser.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'obj_parser/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "obj_parser"
+  spec.version       = ObjLoader::VERSION
+  spec.authors       = ["Laurent Cobos"]
+  spec.email         = ["laurent@11factory.fr"]
+  spec.summary       = %q{3D obj file parser.}
+  spec.description   = %q{Parse a 3D obj file to a ruby data structure. Can compute tangent per vertex. Can merge vertice, normals, and textures indexes into a single index for OpenGL use case.}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake"
+end

data/test/math_utils_test.rb

@@ -0,0 +1,60 @@
+require 'test/unit'
+require 'obj_parser'
+
+class ObjLoader::MathUtilsTest < Test::Unit::TestCase
+  
+  def test_tangent_computing_given_vertices_and_normal
+  	vertices = [[0,0,0], [1,0,0], [1,1,0]]
+  	textures = [[0,1], [1,1], [1,0]]
+  	assert_equal [1,0,0], ObjLoader::MathUtils.tangent_for_vertices_and_texures(vertices, textures)
+  end
+  
+  def test_tangent2_and_binormal_computing_given_vertices_and_normal
+  	vertices = [[0,0,0], [1,0,0], [1,1,0]]
+  	textures = [[0,1], [1,1], [1,0]]
+  	normal = [0,0,-1]
+  	assert_array_in_delta [1.29289321881345, -0.707106781186547, 0.0], ObjLoader::MathUtils.tangent2_for_vertices_and_texures(vertices, textures), 0.00001
+  end
+  
+  def test_vector_length
+  	assert_equal 0, ObjLoader::MathUtils::vector_length([0,0,0])
+  	assert_equal 1, ObjLoader::MathUtils::vector_length([1,0,0])
+  	assert_equal Math.sqrt(29), ObjLoader::MathUtils.vector_length([2,3,4])
+  end
+  
+  def test_vector_normalization
+  	assert_equal [0,0,0], ObjLoader::MathUtils.normalized_vector([0,0,0])
+  	assert_equal [1,0,0], ObjLoader::MathUtils.normalized_vector([1,0,0])
+  	assert_array_in_delta [0.371390676354104, 0.557086014531156, 0.742781352708207], ObjLoader::MathUtils.normalized_vector([2,3,4]), 0.00001
+  end
+  
+  def test_dot_product
+  	v1 = [1,0,0]
+  	v2 = [0,1,0]
+  	assert_equal 0, ObjLoader::MathUtils.dot(v1, v2)
+  	v2 = [1,1,0]
+  	assert_equal 1, ObjLoader::MathUtils.dot(v1, v2)
+  end
+  
+  def test_orthogonalize
+  	v1 = [0.2,1,0]
+  	v2 = [1,0,0]
+  	assert_equal [0,1,0], ObjLoader::MathUtils.orthogonalized_vector_with_vector(v1, v2)
+  end
+  
+  def test_normal_computing_given_face_vertices
+  	vertices = [[0,0,0], [1,0,0], [1,1,0]]
+  	assert_equal [0,0,1].map(&:to_s), ObjLoader::MathUtils.normal_for_face_with_vertices(vertices).map(&:to_s)
+  	vertices = [[0,0,0], [0,0,1], [0,1,0]]
+  	assert_equal [-1,0,0].map(&:to_s), ObjLoader::MathUtils.normal_for_face_with_vertices(vertices).map(&:to_s)
+  end
+  
+  private
+  
+  def assert_array_in_delta(expected_array, actual_array, delta)
+    assert_equal(expected_array.count, actual_array.count)
+    expected_array.each_with_index do |expected_element, index|
+      assert_in_delta(expected_element, actual_array[index], delta)
+    end
+  end
+end

data/test/obj_parser_spec.rb

@@ -0,0 +1,58 @@
+require 'test_helper'
+
+describe ObjLoader::ObjParser do
+  
+  it "should get obj vertice, normals, textures and indexes" do
+    @parser = ObjLoader::ObjParser.new
+    obj = @parser.load(StringIO.new(sample_cube_obj))
+    obj.vertice.take(3).map(&:data).must_equal([p([0.0,0.0,0.0]), p([0.0,0.0,1.0]), p([0.0,1.0,0.0])].map(&:data))
+    obj.normals.count.must_equal(6)
+    obj.textures.count.must_equal(4)
+    obj.vertice_indexes.count.must_equal(36)
+    obj.normals_indexes.count.must_equal(36)
+    obj.textures_indexes.count.must_equal(36)    
+  end
+
+  private
+    
+  def sample_cube_obj
+    <<CUBE_OBJ
+# Blender v2.65 (sub 0) OBJ File: ''
+# www.blender.org
+o Cube
+v 0.0 0.0 0.0
+v 0.0 0.0 1.0
+v 0.0 1.0 0.0
+v 0.0 1.0 1.0
+v 1.0 0.0 0.0
+v 1.0 0.0 1.0
+v 1.0 1.0 0.0
+v 1.0 1.0 1.0
+
+vn 0.0 0.0 1.0
+vn 0.0 0.0 -1.0
+vn 0.0 1.0 0.0
+vn 0.0 -1.0 0.0
+vn 1.0 0.0 0.0
+vn -1.0 0.0 0.0
+
+vt 0.0 0.0
+vt 1.0 0.0
+vt 1.0 1.0
+vt 0.0 1.0
+
+f 1/1/2 7/3/2 5/2/2
+f 1/1/2 3/4/2 7/3/2 
+f 1/1/6 4/3/6 3/4/6 
+f 1/1/6 2/2/6 4/3/6 
+f 3/1/3 8/3/3 7/4/3 
+f 3/1/3 4/2/3 8/3/3 
+f 5/2/5 7/3/5 8/4/5 
+f 5/2/5 8/4/5 6/1/5 
+f 1/1/4 5/2/4 6/3/4 
+f 1/1/4 6/3/4 2/4/4 
+f 2/1/1 6/2/1 8/3/1 
+f 2/1/1 8/3/1 4/4/1
+CUBE_OBJ
+  end
+end

data/test/obj_spec.rb

@@ -0,0 +1,33 @@
+require 'test_helper'
+
+describe ObjLoader::Obj do
+  
+  before do
+    @obj = ObjLoader::Obj.new
+    @obj.vertice = [p([0.0,0.0,0.0]), p([0.0,0.0,1.0]), p([0.0,1.0,0.0]), p([0.0,1.0,1.0])]
+    @obj.vertice_indexes = [0, 1, 2, 1, 2, 3]
+    @obj.normals = [p([1.0,0.0,0.0]), p([0.0,1.0,0.0])]
+    @obj.normals_indexes = [0, 0, 0, 1, 1, 1]
+    @obj.textures = [p([1.0,0.0]), p([0.0,1.0])]
+    @obj.textures_indexes = [1, 1, 0, 0, 1, 1]
+  end
+  
+  it 'resolve faces based on indexes' do
+    @obj.resolve_faces
+    @obj.faces.count.must_equal(2)
+    @obj.faces.first.vertice.map(&:data).must_equal([p([0.0,0.0,0.0]), p([0.0,0.0,1.0]), p([0.0,1.0,0.0])].map(&:data))
+    @obj.faces.first.normals.map(&:data).must_equal([p([1.0,0.0,0.0]), p([1.0,0.0,0.0]), p([1.0,0.0,0.0])].map(&:data))
+    @obj.faces.first.textures.map(&:data).must_equal([p([0.0,1.0]), p([0.0,1.0]), p([1.0,0.0])].map(&:data))
+  end
+  
+  it 'compute tangents' do
+    @obj.compute_tangents
+    result = @obj.faces.each_with_index.map do |face, index| 
+  		face.vertice.map do |vertex|
+  		  ("%.2f" % ObjLoader::MathUtils::dot(vertex.tangent.data[0..2], vertex.normal.data)).to_f
+  		end.reduce(&:+)
+    end.reduce(&:+)
+    result.must_equal(0)
+  end
+  
+end

data/test/single_indexed_obj_spec.rb

@@ -0,0 +1,41 @@
+require 'test_helper'
+
+describe ObjLoader::SingleIndexedObj do
+  
+  before do
+    @obj = ObjLoader::Obj.new
+    @obj.vertice = [p([0.0,0.0,0.0]), p([0.0,0.0,1.0]), p([0.0,1.0,0.0]), p([0.0,1.0,1.0])]
+    @obj.vertice_indexes = [0, 1, 2,  0, 2, 3]
+    @obj.normals = [p([1.0,0.0,0.0]), p([0.0,1.0,0.0])]
+    @obj.normals_indexes = [1, 0, 1,  1, 0, 0]
+    @single_indexed_obj = ObjLoader::SingleIndexedObj.build_with_obj(@obj)
+  end
+  
+  describe 'compute detailed vertice' do
+    
+    it 'can build detailed vertice with associated uniq normals, textures,..' do
+      @single_indexed_obj.detailed_vertice[2].normals.map(&:data).must_equal([p([0.0,1.0,0.0]), p([1.0,0.0,0.0])].map(&:data))
+    end
+  
+    it 'should skip duplicate normals, textures by vertex' do
+      @single_indexed_obj.detailed_vertice[0].normals.count.must_equal(1)
+    end
+  
+    it 'should not modify original vertice' do
+      @obj.vertice.first.normals.must_be_empty
+      @single_indexed_obj.vertice.first.normals.must_be_empty
+    end
+    
+  end
+  
+  describe 'use a single index' do
+    
+    it 'reorganize normals, textures, ... based on vertices indexes' do
+      @single_indexed_obj.normals.count.must_equal(@obj.vertice_indexes.uniq.count)
+      @single_indexed_obj.normals.map(&:data).must_equal(
+        [p([0.0,1.0,0.0]), p([1.0,0.0,0.0]), p([0.0,1.0,0.0]), p([0.0,1.0,0.0]), p([1.0,0.0,0.0]), p([1.0,0.0,0.0])].map(&:data))
+    end
+    
+  end
+    
+end

data/test/test_helper.rb

@@ -0,0 +1,7 @@
+require 'minitest'
+require 'minitest/autorun'
+require 'obj_parser'
+
+def p(data)
+  ObjLoader::Point.new(data)
+end

metadata

@@ -0,0 +1,104 @@
+--- !ruby/object:Gem::Specification
+name: obj_parser
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Laurent Cobos
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-01-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Parse a 3D obj file to a ruby data structure. Can compute tangent per
+  vertex. Can merge vertice, normals, and textures indexes into a single index for
+  OpenGL use case.
+email:
+- laurent@11factory.fr
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/obj_parser.rb
+- lib/obj_parser/face.rb
+- lib/obj_parser/math_utils.rb
+- lib/obj_parser/obj.rb
+- lib/obj_parser/obj_parser.rb
+- lib/obj_parser/point.rb
+- lib/obj_parser/single_indexed_obj.rb
+- lib/obj_parser/version.rb
+- obj_parser.gemspec
+- test/math_utils_test.rb
+- test/obj_parser_spec.rb
+- test/obj_spec.rb
+- test/single_indexed_obj_spec.rb
+- test/test_helper.rb
+homepage: ''
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: 3D obj file parser.
+test_files:
+- test/math_utils_test.rb
+- test/obj_parser_spec.rb
+- test/obj_spec.rb
+- test/single_indexed_obj_spec.rb
+- test/test_helper.rb