collada 0.0.1 → 0.2.0

data/lib/collada/parser/animation.rb

@@ -0,0 +1,57 @@
+# Copyright, 2013, by Samuel G. D. Williams. <http://www.codeotaku.com>
+# 
+# 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.
+
+require 'collada/parser/support'
+
+module Collada
+	module Parser
+		class Animation
+			def initialize(id, sources, samples, channels)
+				@id = id
+				@sources = sources
+				@samples = samplers
+				@channels = channels
+			end
+			
+			attr :id
+			attr :sources
+			attr :samplers
+			attr :channels
+			
+			def self.parse(doc, element)
+				arrays = Source.parse_arrays(doc, element)
+				
+				sources = OrderedMap.parse(element, 'source') do |source_element|
+					Source.parse(doc, source_element, arrays)
+				end
+				
+				samplers = OrderedMap.parse(element, 'sampler') do |sampler_element|
+					Sampler.parse(doc, sampler_element, sources)
+				end
+				
+				channels = OrderedMap.parse(element, 'channel', 'target') do |channel_element|
+					Channel.parse(doc, channel_element, samplers)
+				end
+				
+				self.new(element.attributes['id'], sources, samplers, channels)
+			end
+		end
+	end
+end

data/lib/collada/parser/controller.rb

@@ -0,0 +1,152 @@
+# Copyright, 2013, by Samuel G. D. Williams. <http://www.codeotaku.com>
+# 
+# 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.
+
+require 'collada/parser/support'
+
+module Collada
+	module Parser
+		class Controller
+			class Skin < Controller
+				class Joints < Sampler
+				end
+				
+				class VertexWeights < Sampler
+					include Enumerable
+					
+					def initialize(id, inputs, counts, vertices)
+						super id, inputs
+						
+						@counts = counts
+						@vertices = vertices
+						
+						# The number of indices per vertex:
+						@stride = @inputs.sort_by(&:offset).last.offset + 1
+					end
+					
+					attr :counts
+					attr :vertices
+					
+					def size
+						@counts.size
+					end
+					
+					# Vertices by index:
+					def vertex(index)
+						offset = @stride * index
+						
+						attributes = @inputs.collect do |input|
+							input[@vertices[offset + input.offset]]
+						end
+						
+						return Attribute.flatten(attributes)
+					end
+					
+					def each
+						vertex_offset = 0
+						
+						@counts.each do |count|
+							# Grap all the vertices
+							weights = count.times.collect do |vertex_index|
+								vertex(vertex_offset + vertex_index)
+							end
+							
+							yield weights
+							
+							vertex_offset += count
+						end
+					end
+					
+					def self.parse(doc, element, sources)
+						inputs = parse_inputs(doc, element, sources)
+						
+						counts = element.elements['vcount'].text.split(/\s+/).collect &:to_i
+						vertices = element.elements['v'].text.split(/\s+/).collect &:to_i
+						
+						self.new(element.attributes['id'], inputs, counts, vertices)
+					end
+				end
+				
+				def initialize(id, name, source, bind_pose_transform, sources, joints, weights)
+					super id, name
+					
+					@bind_pose_transform = bind_pose_transform
+					
+					@source = source
+					@sources = sources
+					@joints = joints
+					
+					@weights = weights
+				end
+				
+				attr :source
+				
+				attr :bind_pose_transform
+				
+				attr :sources
+				attr :joints
+				
+				# May contain multiple weights per vertex.
+				attr :weights
+				
+				def self.parse(doc, controller_element, element)
+					id = controller_element.attributes['id']
+					name = controller_element.attributes['name']
+					source = Reference.new(:geometries, element.attributes['source'])
+					
+					bind_pose_transform = extract_float4x4_matrix(element.elements['bind_shape_matrix'].text)
+					
+					arrays = Source.parse_arrays(doc, element)
+				
+					sources = OrderedMap.parse(element, 'source') do |source_element|
+						Source.parse(doc, source_element, arrays)
+					end
+					
+					joints = Joints.parse(doc, element.elements['joints'], sources)
+					
+					vertex_weights = VertexWeights.parse(doc, element.elements['vertex_weights'], sources)
+					
+					self.new(id, name, source, bind_pose_transform, sources, joints, vertex_weights)
+				end
+				
+				private
+				
+				def self.extract_float4x4_matrix(text)
+					values = text.split(/\s+/).collect &:to_f
+					
+					Matrix[*(values.each_slice(4).to_a)]
+				end
+			end
+			
+			def initialize(id, name)
+				@id = id
+				@name = name
+			end
+			
+			attr :id
+			attr :name
+			
+			def self.parse(doc, element)
+				element.elements.each('skin') do |skin_element|
+					return Skin.parse(doc, element, skin_element)
+				end
+			end
+		end
+	end
+end

data/lib/collada/parser/geometry.rb

@@ -24,144 +24,61 @@ module Collada
 	module Parser
 		class Geometry
 			class Mesh
-				class Parameter
-					def initialize(name, type)
-						@name = name
-						@type = type
-					end
-					
-					attr :name
-					attr :type
-					
-					def self.parse(doc, element)
-						self.new(element.attributes['name'], element.attributes['type'].to_sym)
-					end
-				end
-				
-				class Accessor
+				# A source that provides individual vertices:
+				class Vertices
 					include Enumerable
 					
-					def initialize(array, parameters, options = {})
-						@array = array
-						@parameters = parameters
-						@names = parameters.collect{|parameter| parameter.name}
-						
-						@offset = (options[:offset] || 0).to_i
-						@stride = (options[:stride] || parameters.size).to_i
-					end
-					
-					attr :array
-					attr :parameters
-					attr :names
-					
-					attr :offset
-					attr :stride
-					
-					def read index
-						base = @offset + (index * @stride)
-						values = @array[base, @parameters.size]
-						
-						@names.zip(values)
+					def initialize(id, inputs)
+						@id = id
+						@inputs = inputs
 					end
 					
-					def [] index
-						read(index).delete_if{|(name, value)| name == nil}
-					end
+					attr :id
+					attr :inputs
 					
 					def size
-						(@array.size - @offset) / @stride
-					end
-					
-					def each
-						size.times.each do |i|
-							yield self[i]
-						end
+						@inputs.collect{|input| input.size}.max
 					end
 					
-					def self.parse_parameters(doc, element)
-						OrderedMap.parse(element, 'param', 'name') do |param_element|
-							Parameter.parse(doc, param_element)
-						end
+					# Vertices by index, same interface as Input.
+					def [] index
+						@inputs.collect do |input|
+							input[index]
+						end + [Attribute.new(:vertex, :index => index)]
 					end
 					
-					def self.parse(doc, element, arrays = {})
-						if (array_id = element.attributes['source'])
-							array_id.sub!(/^#/, '')
-							
-							array = arrays[array_id]
-						else
-							array = Mesh.parse_arrays(doc, element).first
+					def self.parse_inputs(doc, element, sources = {})
+						OrderedMap.parse(element, 'input') do |input_element|
+							Input.parse(doc, input_element, sources)
 						end
-						
-						parameters = parse_parameters(doc, element)
-						
-						options = {
-							:offset => element.attributes['offset'],
-							:stride => element.attributes['stride'],
-						}
-						
-						self.new(array, parameters, options)
-					end
-				end
-				
-				class Source
-					def initialize(id, accessor)
-						@id = id
-						@accessor = accessor
 					end
 					
-					attr :id
-					attr :accessor
-					
-					def self.parse(doc, element, arrays = {})
-						accessor = Accessor.parse(doc, element.elements['technique_common/accessor'], arrays)
-						
-						self.new(element.attributes['id'], accessor)
-					end
-				end
-				
-				class Input
-					def initialize(semantic, source, offset = 0)
-						@semantic = semantic
-						@source = source
-						@offset = offset
-					end
-					
-					attr :semantic
-					attr :source
-					attr :offset
-					
 					def self.parse(doc, element, sources = {})
-						semantic = element.attributes['semantic']
-
-						if (source_id = element.attributes['source'])
-							source_id.sub!(/^#/, '')
-							source = sources[source_id]
-						end
-
-						offset = element.attributes['offset'] || 0
-
-						self.new(semantic, source, offset.to_i)
+						inputs = parse_inputs(doc, element, sources)
+						
+						self.new(element.attributes['id'], inputs)
 					end
 				end
 				
-				class TriangleVertices
-					def count(index)
+				# Vertices are organised as triangles
+				class Triangles
+					def vertex_count index
 						3
 					end
 				end
 				
-				class PolygonVertices
+				# Vertices are organised as arbitrary ngons.
+				class PolyList
 					def initialize(counts)
 						@counts = counts
 					end
 					
-					def count(index)
+					def vertex_count index
 						@counts[index]
 					end
 					
 					def self.parse(doc, element)
-						counts = element.elements('vcount').text.strip.split(/\s+/).collect &:to_i
+						counts = element.elements['vcount'].text.strip.split(/\s+/).collect &:to_i
 						
 						self.new(counts)
 					end
@@ -170,15 +87,15 @@ module Collada
 				class Polygons
 					include Enumerable
 					
-					def initialize(inputs, indices, count, vertices)
+					def initialize(inputs, indices, size, elements)
 						@inputs = inputs
 						@indices = indices
 						
 						# The total number of polygons:
-						@count = count
+						@size = size
 						
 						# The number of vertices per polygon:
-						@vertices = vertices
+						@elements = elements
 						
 						# The number of indices per vertex:
 						@stride = @inputs.sort_by(&:offset).last.offset + 1
@@ -187,49 +104,62 @@ module Collada
 					attr :inputs
 					attr :indices
 					
-					# Element count:
-					attr :count
+					# Number of polygons
+					attr :size
 					
-					# Number of vertices per element:
-					attr :vertices
+					# Per-element data:
+					attr :elements
 					
 					# Number of indices consumed per vertex:
 					attr :stride
 					
-					def size
-						@count
-					end
-					
 					# Vertices by index:
-					def [] index
+					def vertex(index)
 						offset = @stride * index
 						
-						@inputs.collect do |input|
-							input.source.accessor[@indices[offset + input.offset]]
+						attributes = @inputs.collect do |input|
+							input[@indices[offset + input.offset]]
 						end
+						
+						return Attribute.flatten(attributes)
 					end
 					
-					def each
-						consumed = 0
+					def each_indices
+						return to_enum(:each_indices) unless block_given?
 						
-						@count.times do |index|
-							elements = @vertices.count(index)
-							polygon = elements.times.collect{|edge| self[consumed + edge]}
+						vertex_offset = 0
+						
+						@size.times do |index|
+							# There are n vertices per face:
+							vertex_count = @elements.vertex_count(index)
+							
+							# Grap all the vertices
+							polygon_indices = vertex_count.times.collect do |vertex_index|
+								vertex_offset + vertex_index
+							end
 							
-							yield polygon
+							yield polygon_indices
 							
-							consumed += elements
+							vertex_offset += vertex_count
+						end
+					end
+					
+					def each
+						return to_enum(:each) unless block_given?
+						
+						each_indices.each do |indices|
+							yield indices.collect {|index| vertex(index)}
 						end
 					end
 					
 					def self.parse_inputs(doc, element, sources = {})
-						OrderedMap.parse(element, '//input') do |input_element|
+						OrderedMap.parse(element, 'input') do |input_element|
 							Input.parse(doc, input_element, sources)
 						end
 					end
 					
 					def self.parse_indices(doc, element)
-						element.elements['p'].text.strip.split(/\s+/).collect{|index| index.to_i - 1}
+						element.elements['p'].text.strip.split(/\s+/).collect &:to_i
 					end
 					
 					def self.parse(doc, element, sources = {})
@@ -238,54 +168,67 @@ module Collada
 						count = element.attributes['count'].to_i
 						
 						if element.name == 'triangles'
-							self.new(inputs, indices, count, TriangleVertices.new)
+							self.new(inputs, indices, count, Triangles.new)
 						elsif element.name == 'polylist'
-							self.new(inputs, indices, count, PolygonVertices.parse(doc, element))
+							self.new(inputs, indices, count, PolyList.parse(doc, element))
 						else
 							raise UnsupportedFeature.new(element)
 						end
 					end
 				end
 				
-				def initialize(sources, polygons)
+				def initialize(sources, vertices, polygons)
 					@sources = sources
+					@vertices = vertices
 					@polygons = polygons
 				end
 				
 				attr :sources
+				attr :vertices
 				attr :polygons
 				
-				def self.parse_arrays(doc, element)
-					OrderedMap.parse(element, '//float_array | //int_array', 'name') do |array_element|
-						array_element.text.strip.split(/\s+/).collect &:to_f
-					end
-				end
-				
 				def self.parse(doc, element)
-					arrays = parse_arrays(doc, element)
+					arrays = Source.parse_arrays(doc, element)
 					
 					sources = OrderedMap.parse(element, 'source') do |source_element|
 						Source.parse(doc, source_element, arrays)
 					end
 					
+					if (vertices_element = element.elements['vertices'])
+						vertices = Vertices.parse(doc, vertices_element, sources)
+						sources.append(vertices.id, vertices)
+					end
+					
 					if (polygons_element = element.elements['triangles | polylist'])
 						polygons = Polygons.parse(doc, polygons_element, sources)
 					end
 					
-					self.new(sources, polygons)
+					self.new(sources, vertices, polygons)
 				end
 			end
 			
-			def initialize(mesh)
+			def initialize(id, name, mesh, attributes)
+				@id = id
+				@name = name
+				
 				@mesh = mesh
+				
+				@attributes = attributes
 			end
 			
+			attr :id
+			attr :name
+			
 			attr :mesh
+			attr :attributes
 			
 			def self.parse(doc, element)
+				id = element.attributes['id']
+				name = element.attributes['name']
+				
 				mesh = Mesh.parse(doc, element.elements['mesh'])
 				
-				self.new(mesh)
+				self.new(id, name, mesh, element.attributes)
 			end
 		end
 	end