collada 0.0.1 → 0.2.0

data/lib/collada/parser/library.rb

@@ -20,33 +20,38 @@
 
 require 'collada/parser/visual_scene'
 require 'collada/parser/geometry'
+require 'collada/parser/animation'
+require 'collada/parser/controller'
 
 module Collada
 	module Parser
 		class Library
 			SECTIONS = {
 				:visual_scenes => ['COLLADA/library_visual_scenes/visual_scene', VisualScene],
-				:geometries => ['COLLADA/library_geometries/geometry', Geometry]
+				:geometries => ['COLLADA/library_geometries/geometry', Geometry],
+				:animations => ['COLLADA/library_animations/animation', Animation],
+				:controllers => ['COLLADA/library_controllers/controller', Controller],
 			}
 			
-			def initialize(sections = {})
+			def initialize(doc, sections = {})
+				@doc = doc
 				@sections = sections
 			end
 			
 			def [] key
-				@sections[key]
+				@sections.fetch(key) do
+					path, klass = SECTIONS[key]
+					
+					raise ArgumentError.new("Invalid section name #{key}!") unless klass
+					
+					@sections[key] = OrderedMap.parse(@doc, path) do |element|
+						klass.parse(@doc, element)
+					end
+				end
 			end
 			
 			def self.parse(doc)
-				sections = {}
-				
-				SECTIONS.each do |key, (path, klass)|
-					sections[key] = OrderedMap.parse(doc, path) do |element|
-						klass.parse(doc, element)
-					end
-				end
-				
-				return Library.new(sections)
+				return Library.new(doc)
 			end
 		end
 	end

data/lib/collada/parser/scene.rb

@@ -67,131 +67,6 @@ module Collada
 		
 		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
-					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)
-					end
-					
-					def [] index
-						read(index).delete_if{|(name, value)| name == nil}
-					end
-					
-					def size
-						(@array.size - @offset) / @stride
-					end
-					
-					def each
-						size.times.each do |i|
-							yield self[i]
-						end
-					end
-					
-					def self.parse_parameters(doc, element)
-						OrderedMap.parse(element, 'param', 'name') do |param_element|
-							Parameter.parse(doc, param_element)
-						end
-					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
-						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 inspect
-						"<Input: #{@semantic}>"
-					end
-					
-					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)
-					end
-				end
-				
 				class TriangleVertices
 					def count(index)
 						3
@@ -302,14 +177,8 @@ module Collada
 				attr :sources
 				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)

data/lib/collada/parser/support.rb

@@ -37,6 +37,14 @@ module Collada
 			attr :ordered
 			attr :indexed
 			
+			def keys
+				@indexed.keys
+			end
+			
+			def values
+				@ordered
+			end
+			
 			def [] key
 				@indexed[key]
 			end
@@ -49,6 +57,11 @@ module Collada
 				@ordered.size
 			end
 			
+			def append(key, value)
+				@indexed[key] = value
+				@ordered << value
+			end
+			
 			def self.parse(top, path, id_key = 'id')
 				ordered = []
 				indexed = {}
@@ -64,5 +77,345 @@ module Collada
 				return OrderedMap.new(ordered, indexed)
 			end
 		end
+		
+		class Reference
+			def initialize(kind, url)
+				@kind = kind
+				@url = url
+			end
+			
+			attr :kind
+			attr :url
+			
+			def id
+				url.sub(/^.*\#/, '')
+			end
+			
+			def lookup(library)
+				library[@kind].each do |item|
+					return item if item.id == id
+				end
+				
+				return nil
+			end
+			
+			def to_s
+				"\#<#{self.class} #{@url.dump} in #{@kind}>"
+			end
+		end
+		
+		class Attribute
+			def initialize(semantic, value)
+				@semantic = semantic
+				@value = value
+			end
+			
+			attr :semantic
+			attr :value
+			
+			def [] key
+				@value[key]
+			end
+					
+			def == other
+				@value == other.value
+			end
+					
+			def inspect
+				"Attribute.#{@semantic}(#{@value.inspect})"
+			end
+					
+			def self.method_missing(method, *args)
+				if args.size == 1 && Hash === args[0]
+					new(method, args[0])
+				else
+					new(method, args)
+				end
+			end
+					
+			def flatten
+				if Array === @value
+					@value.collect{|attribute| attribute.flatten}
+				else
+					self
+				end
+			end
+			
+			def self.flatten(attributes)
+				attributes.collect{|attribute| attribute.flatten}.flatten
+			end
+			
+			def self.to_hash(attributes)
+				Hash[attributes.collect{|attribute| [attribute.semantic, attribute.value]}]
+			end
+			
+			def self.merge(attributes)
+				attributes.collect{|attribute| attribute.value}.inject(:merge)
+			end
+		end
+		
+		class Parameter
+			def initialize(name, type)
+				@name = name ? name.to_sym : nil
+				@type = type
+			end
+			
+			attr :name
+			attr :type
+			
+			def size
+				1
+			end
+			
+			def read value
+				value.first
+			end
+			
+			def self.parse(doc, element)
+				name = element.attributes['name']
+				type = element.attributes['type']
+				
+				case type
+				when /float(\d)x(\d)/
+					MatrixParameter.new(name, type, [$1.to_i, $2.to_i])
+				when /float(\d)/
+					VectorParameter.new(name, type, [$1.to_i, $2.to_i])
+				else
+					Parameter.new(name, type)
+				end
+			end
+		end
+		
+		class MatrixParameter < Parameter
+			def initialize(name, type, dimensions)
+				super name, type
+				
+				@rows = dimensions[1]
+				@size = dimensions[0] * dimensions[1]
+			end
+			
+			attr :size
+			
+			def read(value)
+				Matrix[*(value.each_slice(@rows).to_a)]
+			end
+		end
+		
+		class VectorParameter < Parameter
+			def initialize(name, type, size)
+				super name, type
+				
+				@size = size
+			end
+			
+			attr :size
+			
+			def read(value)
+				Vector[*value]
+			end
+		end
+		
+		class Accessor
+			include Enumerable
+			
+			def initialize(array, parameters, count, options = {})
+				@array = array
+				@parameters = parameters
+				@count = count
+				
+				# Chunk size and stride are usually the same in many cases.
+				@chunk_size = @parameters.inject(0) {|sum, parameter| sum + parameter.size}
+				
+				@offset = (options[:offset] || 0).to_i
+				@stride = (options[:stride] || @chunk_size).to_i
+			end
+			
+			attr :array
+			attr :parameters
+			attr :names
+			
+			attr :count
+			attr :offset
+			attr :stride
+			
+			def read index
+				base = @offset + (index * @stride)
+				values = @array[base, @chunk_size]
+				
+				@parameters.collect{|parameter| [parameter.name, parameter.read(values.shift(parameter.size))]}
+			end
+			
+			def [] index
+				read(index).delete_if{|(name, value)| name == nil}
+			end
+			
+			def size
+				(@array.size - @offset) / @stride
+			end
+			
+			def each
+				size.times.each do |i|
+					yield self[i]
+				end
+			end
+			
+			def self.parse_parameters(doc, element)
+				OrderedMap.parse(element, 'param', 'name') do |param_element|
+					Parameter.parse(doc, param_element)
+				end
+			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
+				end
+				
+				raise UnsupportedFeature.new("Source array binding must be valid (id=#{array_id})") unless array
+				
+				parameters = parse_parameters(doc, element)
+				count = element.attributes['count'].to_i
+				
+				options = {
+					:offset => element.attributes['offset'],
+					:stride => element.attributes['stride'],
+				}
+				
+				self.new(array, parameters, count, options)
+			end
+		end
+		
+		# A source that reads directly from a data array:
+		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
+			
+			def self.parse_arrays(doc, element)
+				OrderedMap.parse(element, '//float_array | //int_array | //Name_array') do |array_element|
+					case array_element.name
+					when 'Name_array'
+						array_element.text.strip.split(/\s+/)
+					else
+						array_element.text.strip.split(/\s+/).collect &:to_f
+					end
+				end
+			end
+			
+			def [] index
+				Hash[@accessor[index]]
+			end
+		end
+		
+		class Input
+			# `Vertices` or `Source` are both okay for source.
+			def initialize(semantic, source, offset = 0)
+				@semantic = semantic
+				@source = source
+				@offset = offset
+			end
+			
+			attr :semantic
+			attr :source
+			attr :offset
+			
+			def size
+				@source.accessor.count
+			end
+			
+			def [] index
+				Attribute.new(@semantic, @source[index])
+			end
+			
+			def self.parse(doc, element, sources = {})
+				semantic = element.attributes['semantic']
+				
+				if (source_id = element.attributes['source'])
+					source_id.sub!(/^#/, '')
+					source = sources[source_id]
+				end
+				
+				raise UnsupportedFeature.new("Can't instantiate input with nil source (#{source_id})!") unless source
+				
+				offset = element.attributes['offset'] || 0
+				
+				self.new(semantic.downcase.to_sym, source, offset.to_i)
+			end
+		end
+		
+		class Sampler
+			include Enumerable
+			
+			def initialize(id, inputs)
+				@id = id
+				@inputs = inputs
+			end
+				
+			attr :id
+			attr :inputs
+				
+			# Vertices by index, same interface as Input.
+			def [] index
+				@inputs.collect do |input|
+					input[index]
+				end
+			end
+				
+			def self.parse_inputs(doc, element, sources = {})
+				OrderedMap.parse(element, 'input') do |input_element|
+					Input.parse(doc, input_element, sources)
+				end
+			end
+				
+			def self.parse(doc, element, sources = {})
+				inputs = parse_inputs(doc, element, sources)
+				
+				self.new(element.attributes['id'], inputs)
+			end
+			
+			def size
+				@inputs.collect{|input| input.size}.max
+			end
+			
+			def each
+				size.times do |i|
+					yield self[i]
+				end
+			end
+		end
+		
+		class Channel
+			def initialize(source, target)
+				@source = source
+				@target = target
+			end
+				
+			attr :source
+			attr :target
+				
+			def self.parse(doc, element, sources = {})
+				source_id = element.attributes['source'].sub(/^#/, '')
+				target_id = element.attributes['target']
+				
+				source = sources[source_id]
+				
+				raise ArgumentError.new("Could not find #{source_id} in #{sources.keys.inspect}!") unless source
+				
+				self.new(source, target_id)
+			end
+		end
 	end
 end