obj_parser 0.0.1 → 0.0.2

data/README.md

@@ -6,6 +6,7 @@ Can merge vertice, normals, and textures indexes into a single index for OpenGL
 
 - Support triangle primitives
 - Support only one model per obj file
+- Did not support materials
 
 ## Installation
 
@@ -25,10 +26,10 @@ Or install it yourself as:
 
 Sample to parse an obj file, generate tangents and transform to a single indexed 3D model.
 
-    @parser = ObjLoader::ObjParser.new
+    @parser = ObjParser::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)
+    obj = ObjParser::SingleIndexedObj.build_with_obj(obj)
     
     puts obj.vertice.map(&:data).join(",")
     puts obj.normals.map(&:data).join(",")

data/lib/obj_parser/face.rb

@@ -1,4 +1,4 @@
-module ObjLoader
+module ObjParser
   class Face
     attr_accessor :normals
     attr_accessor :vertice

data/lib/obj_parser/math_utils.rb

@@ -1,6 +1,6 @@
 require 'matrix'
 
-module ObjLoader
+module ObjParser
 
   module MathUtils
       

data/lib/obj_parser/obj.rb

@@ -1,7 +1,7 @@
 require_relative 'face'
 require_relative 'math_utils'
 
-module ObjLoader
+module ObjParser
   class Obj
     VERTEX_BY_FACE = 3
     attr_accessor :normals, :normals_indexes
@@ -41,35 +41,35 @@ module ObjLoader
     	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)
+    		tangent_for_face = ObjParser::MathUtils::tangent_for_vertices_and_texures(face.vertice.map(&:data), face.textures.map(&:data))
+    		tangent_for_face = ObjParser::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)
+    			vertex.tangent.data = ObjParser::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)
+    		vertex.tangent.data = ObjParser::MathUtils::orthogonalized_vector_with_vector(vertex.tangent.data, self.normals[self.normals_indexes[pindex * 3 + index]].data)
+    		vertex.tangent.data = ObjParser::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)
+    			binormal = ObjParser::MathUtils::cross_product(self.normals[self.normals_indexes[pindex * 3 + index]].data, vertex.tangent.data)
+    			vertex.binormal.data = ObjParser::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.binormal.data = ObjParser::MathUtils::normalized_vector(vertex.binormal.data)
+      		if(ObjParser::MathUtils::dot(ObjParser::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 
@@ -88,7 +88,7 @@ module ObjLoader
       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
+    		  ("%.2f" % ObjParser::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"}]"

data/lib/obj_parser/obj_parser.rb

@@ -1,7 +1,7 @@
 require_relative 'obj'
 require_relative 'point'
 
-module ObjLoader
+module ObjParser
   class ObjParser
     
     VERTEX_LINE_ID = 'v'

data/lib/obj_parser/point.rb

@@ -1,4 +1,4 @@
-module ObjLoader
+module ObjParser
   class Point
     attr_accessor :data
     attr_accessor :current_tangent

data/lib/obj_parser/single_indexed_obj.rb

@@ -1,6 +1,6 @@
 require 'delegate.rb'
 
-module ObjLoader
+module ObjParser
   class SingleIndexedObj < SimpleDelegator
 
     attr_accessor :detailed_vertice

data/lib/obj_parser/version.rb

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

data/lib/obj_parser.rb

@@ -3,6 +3,6 @@ require "obj_parser/obj_parser"
 require "obj_parser/single_indexed_obj"
 require "obj_parser/point"
 
-module ObjLoader
+module ObjParser
   # Your code goes here...
 end

data/obj_parser.gemspec

@@ -5,7 +5,7 @@ require 'obj_parser/version'
 
 Gem::Specification.new do |spec|
   spec.name          = "obj_parser"
-  spec.version       = ObjLoader::VERSION
+  spec.version       = ObjParser::VERSION
   spec.authors       = ["Laurent Cobos"]
   spec.email         = ["laurent@11factory.fr"]
   spec.summary       = %q{3D obj file parser.}

data/test/math_utils_test.rb

@@ -1,52 +1,52 @@
 require 'test/unit'
 require 'obj_parser'
 
-class ObjLoader::MathUtilsTest < Test::Unit::TestCase
+class ObjParser::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)
+  	assert_equal [1,0,0], ObjParser::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
+  	assert_array_in_delta [1.29289321881345, -0.707106781186547, 0.0], ObjParser::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])
+  	assert_equal 0, ObjParser::MathUtils::vector_length([0,0,0])
+  	assert_equal 1, ObjParser::MathUtils::vector_length([1,0,0])
+  	assert_equal Math.sqrt(29), ObjParser::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
+  	assert_equal [0,0,0], ObjParser::MathUtils.normalized_vector([0,0,0])
+  	assert_equal [1,0,0], ObjParser::MathUtils.normalized_vector([1,0,0])
+  	assert_array_in_delta [0.371390676354104, 0.557086014531156, 0.742781352708207], ObjParser::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)
+  	assert_equal 0, ObjParser::MathUtils.dot(v1, v2)
   	v2 = [1,1,0]
-  	assert_equal 1, ObjLoader::MathUtils.dot(v1, v2)
+  	assert_equal 1, ObjParser::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)
+  	assert_equal [0,1,0], ObjParser::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)
+  	assert_equal [0,0,1].map(&:to_s), ObjParser::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)
+  	assert_equal [-1,0,0].map(&:to_s), ObjParser::MathUtils.normal_for_face_with_vertices(vertices).map(&:to_s)
   end
   
   private

data/test/obj_parser_spec.rb

@@ -1,9 +1,10 @@
 require 'test_helper'
+require 'stringio'
 
-describe ObjLoader::ObjParser do
+describe ObjParser::ObjParser do
   
   it "should get obj vertice, normals, textures and indexes" do
-    @parser = ObjLoader::ObjParser.new
+    @parser = ObjParser::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)

data/test/obj_spec.rb

@@ -1,9 +1,9 @@
 require 'test_helper'
 
-describe ObjLoader::Obj do
+describe ObjParser::Obj do
   
   before do
-    @obj = ObjLoader::Obj.new
+    @obj = ObjParser::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])]
@@ -24,7 +24,7 @@ describe ObjLoader::Obj 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
+  		  ("%.2f" % ObjParser::MathUtils::dot(vertex.tangent.data[0..2], vertex.normal.data)).to_f
   		end.reduce(&:+)
     end.reduce(&:+)
     result.must_equal(0)

data/test/single_indexed_obj_spec.rb

@@ -1,14 +1,14 @@
 require 'test_helper'
 
-describe ObjLoader::SingleIndexedObj do
+describe ObjParser::SingleIndexedObj do
   
   before do
-    @obj = ObjLoader::Obj.new
+    @obj = ObjParser::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)
+    @single_indexed_obj = ObjParser::SingleIndexedObj.build_with_obj(@obj)
   end
   
   describe 'compute detailed vertice' do

data/test/test_helper.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: obj_parser
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
   prerelease: 
 platform: ruby
 authors: