pgtools 1.0.0 → 1.0.1

data/lib/bayonetta/wmb3.rb

@@ -1,759 +1,759 @@
-module Bayonetta
-  class WMB3File < LibBin::Structure
-    include Alignment
-
-    class MeshMaterialPair < LibBin::Structure
-      uint32 :mesh_index
-      uint32 :material_index
-    end
-
-    class Mesh < LibBin::Structure
-      class Header < LibBin::Structure
-        uint32 :offset_name
-        float  :bounding_box, length: 6
-        uint32 :offset_materials
-        uint32 :num_materials
-        uint32 :offset_bones_indices
-        uint32 :num_bones_indices
-      end
-      register_field :header, Header
-      string :name, offset: 'header\offset_name'
-      uint16 :materials, length: 'header\num_materials', offset: 'header\offset_materials'
-      uint16 :bone_indices, length: 'header\num_bones_indices', offset: 'header\offset_bones_indices'
-    end
-
-    class Material < LibBin::Structure
-
-      class Variable < LibBin::Structure
-        uint32 :offset_name
-        float :value
-        string :name, offset: 'offset_name'
-      end
-
-      class ParameterGroup < LibBin::Structure
-        int32 :index
-        uint32 :offset_parameters
-        uint32 :num_parameters
-        float :parameters, length: 'num_parameters', offset: 'offset_parameters'
-      end
-
-      class Texture < LibBin::Structure
-        uint32 :offset_name
-        uint32 :texture_id
-        string :name, offset: 'offset_name'
-      end
-
-      class Header < LibBin::Structure
-        uint16 :date, length: 4
-        uint32 :offset_name
-        uint32 :offset_shader_name
-        uint32 :offset_technique_name
-        uint32 :u_a
-        uint32 :offset_textures
-        uint32 :num_textures
-        uint32 :offset_parameters_groups
-        uint32 :num_parameters_groups
-        uint32 :offset_variables
-        uint32 :num_variables
-      end
-      register_field :header, Header
-      string :name, offset: 'header\offset_name'
-      string :shader_name, offset: 'header\offset_shader_name'
-      string :technique_name, offset: 'header\offset_technique_name'
-      register_field :textures, Texture, count: 'header\num_textures', sequence: true,
-                     offset: 'header\offset_textures + __iterator * 8'
-      register_field :parameters_groups, ParameterGroup, count: 'header\num_parameters_groups',
-                     sequence: true, offset: 'header\offset_parameters_groups + __iterator * 12'
-      register_field :variables, Variable, count: 'header\num_variables', sequence: true,
-                     offset: 'header\offset_variables + __iterator * 8'
-
-    end
-
-    class BoneSet < LibBin::Structure
-      uint32 :offset_bone_indices
-      uint32 :num_bone_indices
-      int16 :bone_indices, length: 'num_bone_indices', offset: 'offset_bone_indices'
-    end
-
-    class Lod < LibBin::Structure
-
-      class BatchInfo < LibBin::Structure
-        uint32 :vertex_group_index
-        uint32 :mesh_index
-        uint32 :material_index
-        int32 :call_tree_node_index
-        uint32 :mesh_material_index
-        int32 :u_b
-      end
-
-      class Header < LibBin::Structure
-        uint32 :offset_name
-        int32 :lod_level
-        uint32 :batch_start
-        uint32 :offset_batch_infos
-        uint32 :num_batch_infos
-      end
-      register_field :header, Header
-      string :name, offset: 'header\offset_name'
-      register_field :batch_infos, BatchInfo, length: 'header\num_batch_infos', offset: 'header\offset_batch_infos'
-    end
-
-    class ColTreeNode < LibBin::Structure
-      register_field :p1, Position
-      register_field :p2, Position
-      int32 :left
-      int32 :right
-    end
-
-    class Batch < LibBin::Structure
-      uint32 :vertex_group_index
-      int32 :bone_set_index
-      uint32 :vertex_start
-      uint32 :index_start
-      uint32 :num_vertexes
-      uint32 :num_indices
-      uint32 :num_primitives
-    end
-
-    VERTEX_TYPES = {}
-    VERTEX_TYPES.update( YAML::load_file(File.join( File.dirname(__FILE__), 'vertex_types_nier.yaml')) )
-
-    class VertexGroup < LibBin::Structure
-
-      def is_bayo2? #UByteList are arrays of char really
-        true
-      end
-
-      def get_vertex_fields
-        if @vertex_fields
-          return @vertex_fields
-        else
-          types = VERTEX_TYPES[ @header.vertex_flags ]
-          @vertex_fields = []
-          if types[0]
-            types[0].each { |name, type|
-              @vertex_fields.push(name)
-            }
-          end
-          if types[1]
-            types[1].each { |name, type|
-              @vertex_fields.push(name)
-            }
-          end
-          return @vertex_fields
-        end
-      end
-
-      def get_vertex_types
-        if @vertex_type
-          return [@vertex_type, @vertex_ex_type]
-        else
-          types = VERTEX_TYPES[ @header.vertex_flags ]
-          @vertex_type = Class::new(LibBin::Structure)
-          @vertex_size = 0
-          if types[0]
-            types[0].each { |name, type|
-              @vertex_type.register_field(name, VERTEX_FIELDS[type][0])
-              @vertex_size += VERTEX_FIELDS[type][1]
-            }
-          end
-          raise "Invalid size for vertex data #{@vertex_size} != #{@header.vertex_size}!" if @vertex_size != @header.vertex_size
-          @vertex_ex_type = Class::new(LibBin::Structure)
-          @vertex_ex_size = 0
-          if types[1]
-            types[1].each { |name, type|
-              @vertex_ex_type.register_field(name, VERTEX_FIELDS[type][0])
-              @vertex_ex_size += VERTEX_FIELDS[type][1]
-            }
-          end
-          raise "Invalid size for ex data #{@vertex_ex_size} != #{@header.vertex_ex_data_size}!" if @vertex_ex_size != @header.vertex_ex_data_size
-          return [@vertex_type, @vertex_ex_type]
-        end
-      end
-
-      def get_vertex_field(field, vi)
-        if @vertexes[vi].respond_to?(field)
-          return @vertexes[vi].send(field)
-        elsif @vertexes_ex_data && @vertexes_ex_data[vi].respond_to?(field)
-          return @vertexes_ex_data[vi].send(field)
-        else
-          return nil
-        end
-      end
-
-      def set_vertex_field(field, vi, val)
-        if @vertexes[vi].respond_to?(field)
-          return @vertexes[vi].send(:"#{field}=", val)
-        elsif @vertexes_ex_data && @vertexes_ex_data[vi].respond_to?(field)
-          return @vertexes_ex_data[vi].send(:"#{field}=", val)
-        else
-          raise "Couldn't find field: #{field}!"
-        end
-      end
-
-      class Header < LibBin::Structure
-        uint32 :offset_vertexes
-        uint32 :offset_vertexes_ex_data
-        uint32 :u_a
-        uint32 :u_b
-        uint32 :vertex_size
-        uint32 :vertex_ex_data_size
-        uint32 :u_c
-        uint32 :u_d
-        uint32 :num_vertexes
-        uint32 :vertex_flags
-        uint32 :offset_indices
-        uint32 :num_indices
-      end
-      register_field :header, Header
-      register_field :vertexes, 'get_vertex_types[0]', length: 'header\num_vertexes', offset: 'header\offset_vertexes'
-      register_field :vertexes_ex_data, 'get_vertex_types[1]', length: 'header\num_vertexes',
-                     offset: 'header\offset_vertexes_ex_data'
-      register_field :indices, '(..\header.flags & 0x8) != 0 ? UInt32 : UInt16' , length: 'header\num_indices', offset: 'header\offset_indices'
-    end
-
-    class Bone < LibBin::Structure
-      int16 :id
-      int16 :parent_index
-      register_field :local_position, Position
-      register_field :local_rotation, Position
-      register_field :local_scale, Position
-      register_field :position, Position
-      register_field :rotation, Position
-      register_field :scale, Position
-      register_field :t_position, Position
-    end
-
-    class Unknown1 < LibBin::Structure
-      uint32 :data, length: 6
-    end
-
-    class InfoPair < LibBin::Structure
-      uint32 :offset
-      uint32 :number
-    end
-
-    class Header < LibBin::Structure
-      def self.info_pair(field, length: nil, count: nil, offset: nil, sequence: false, condition: nil)
-        register_field(field, InfoPair, length: length, count: count, offset: offset, sequence: sequence, condition: condition)
-      end
-
-      uint32 :id
-      uint32 :version
-      int32  :u_a
-      int16  :flags
-      int16  :u_c
-      float  :bounding_box, length: 6
-      info_pair :info_bones
-      info_pair :info_bone_index_translate_table
-      info_pair :info_vertex_groups
-      info_pair :info_batches
-      info_pair :info_lods
-      info_pair :info_col_tree_nodes
-      info_pair :info_bone_map
-      info_pair :info_bone_sets
-      info_pair :info_materials
-      info_pair :info_meshes
-      info_pair :info_mesh_material_pairs
-      info_pair :info_unknown1
-    end
-
-    register_field :header, Header
-    register_field :bones, Bone, length: 'header\info_bones\number',
-                   offset: 'header\info_bones\offset'
-    register_field :bone_index_translate_table, BoneIndexTranslateTable,
-                   offset: 'header\info_bone_index_translate_table\offset'
-    register_field :vertex_groups, VertexGroup, count: 'header\info_vertex_groups\number',
-                   sequence: true, offset: 'header\info_vertex_groups\offset + __iterator * 48'
-    register_field :batches, Batch, length: 'header\info_batches\number',
-                   offset: 'header\info_batches\offset'
-    register_field :lods, Lod, count: 'header\info_lods\number', sequence: true,
-                   offset: 'header\info_lods\offset + __iterator * 20'
-    register_field :col_tree_nodes, ColTreeNode, length: 'header\info_col_tree_nodes\number',
-                   offset: 'header\info_col_tree_nodes\offset'
-    uint32         :bone_map, length: 'header\info_bone_map\number',
-                   offset: 'header\info_bone_map\offset'
-    register_field :bone_sets, BoneSet, count: 'header\info_bone_sets\number', sequence: true,
-                   offset: 'header\info_bone_sets\offset + __iterator * 8'
-    register_field :materials, Material, count: 'header\info_materials\number', sequence: true,
-                   offset: 'header\info_materials\offset + __iterator * 48'
-    register_field :meshes, Mesh, count: 'header\info_meshes\number', sequence: true,
-                   offset: 'header\info_meshes\offset + __iterator * 44'
-    register_field :mesh_material_pairs, MeshMaterialPair,
-                   length: 'header\info_mesh_material_pairs\number',
-                   offset: 'header\info_mesh_material_pairs\offset'
-    register_field :unknown1, Unknown1, length: 'header\info_unknown1\number',
-                   offset: 'header\info_unknown1\offset'
-
-    def texture_ids
-      ids = @materials.collect { |m|
-        m.textures.collect { |t| t.texture_id }
-      }
-      ids.flatten.uniq
-    end
-
-    def materials_textures
-      mat_tex = @materials.collect { |m|
-        [m.name, m.textures.collect { |t| [t.texture_id, t.name] }]
-      }.to_h
-    end
-
-    def cleanup_vertexes
-      vertex_usage, index_usage = get_vertex_index_usage
-      @vertex_groups.each_with_index { |vertex_group, vertex_group_index|
-        new_vertex_map = vertex_usage[vertex_group_index].uniq.sort.each_with_index.to_h
-        vertex_group.vertexes = new_vertex_map.keys.collect { |i|
-          vertex_group.vertexes[i]
-        }
-        vertex_group.vertexes_ex_data = new_vertex_map.keys.collect { |i|
-          vertex_group.vertexes_ex_data[i]
-        }
-        vertex_group.header.num_vertexes = vertex_group.vertexes.size
-
-        new_index_map = index_usage[vertex_group_index].uniq.sort.each_with_index.to_h
-        vertex_group.indices = new_index_map.keys.collect { |i|
-          new_vertex_map[vertex_group.indices[i]]
-        }
-        vertex_group.header.num_indices = vertex_group.indices.size
-        @batches.select { |batch| batch.vertex_group_index == vertex_group_index }.each { |batch|
-          batch.vertex_start = new_vertex_map[batch.vertex_start]
-          batch.index_start = new_index_map[batch.index_start]
-          if batch.vertex_start != 0
-            ((batch.index_start)...(batch.index_start + batch.num_indices)).each { |i|
-              vertex_group.indices[i] = vertex_group.indices[i] - batch.vertex_start
-            }
-          end
-        }
-      }
-    end
-
-    def get_vertex_index_usage
-      vertex_usage = Hash::new { |h, k| h[k] = [] }
-      index_usage = Hash::new { |h, k| h[k] = [] }
-      @batches.each { |batch|
-        index_range = (batch.index_start)...(batch.index_start + batch.num_indices)
-        index_usage[batch.vertex_group_index] += index_range.to_a
-        vertex_usage[batch.vertex_group_index] += @vertex_groups[batch.vertex_group_index].indices[index_range].collect { |vertex|
-          vertex + batch.vertex_start
-        }
-      }
-      return [vertex_usage, index_usage]
-    end
-
-    def delete_meshes(list)
-      kept_meshes = @meshes.size.times.to_a - list
-      new_mesh_map = kept_meshes.each_with_index.to_h
-      if @meshes
-        @meshes = kept_meshes.collect { |i|
-          @meshes[i]
-        }
-        @header.info_meshes.number = @meshes.size
-      end
-      if @mesh_material_pairs
-        @mesh_material_pairs = @mesh_material_pairs.select { |pair|
-          ! list.include?(pair.mesh_index)
-        }
-        @header.info_mesh_material_pairs.number = @mesh_material_pairs.size
-        @mesh_material_pairs.each { |pair|
-          pair.mesh_index = new_mesh_map[pair.mesh_index]
-        }
-      end
-      if @lods && @batches
-        batch_indexes = @header.info_batches.number.times.to_a
-        filtered_batches = Set::new
-        @lods.each { |lod|
-          if lod.batch_infos
-            lod.batch_infos.each_with_index { |batch_info, index|
-              if list.include?(batch_info.mesh_index)
-                filtered_batches.add( index + lod.header.batch_start )
-              end
-            }
-            lod.batch_infos = lod.batch_infos.select { |batch_info|
-              ! list.include?(batch_info.mesh_index)
-            }
-            lod.header.num_batch_infos = lod.batch_infos.size
-            lod.batch_infos.each { |batch_info|
-              batch_info.mesh_index = new_mesh_map[batch_info.mesh_index]
-            }
-          end
-        }
-        batch_indexes -= filtered_batches.to_a
-        batch_index_map = batch_indexes.each_with_index.to_h
-        @batches = batch_indexes.collect { |index|
-          @batches[index]
-        }
-        @header.info_batches.number = @batches.size
-        @lods.each { |lod|
-          if lod.batch_infos
-            lod.header.batch_start = batch_index_map[lod.header.batch_start]
-          end
-        }
-      end
-      self
-    end
-
-    def delete_batches(batch_list)
-      if @lods && @batches
-        batch_indexes = @header.info_batches.number.times.to_a
-        batch_indexes -= batch_list
-        batch_index_map = batch_indexes.each_with_index.to_h
-        @batches = batch_indexes.collect { |index|
-          @batches[index]
-        }
-        @header.info_batches.number = @batches.size
-        @lods.each { |lod|
-          if lod.batch_infos
-            new_batch_infos = []
-            lod.batch_infos.each_with_index { |batch_info, index|
-              unless batch_list.include?(lod.header.batch_start + index)
-                new_batch_infos.push batch_info
-              end
-              lod.batch_infos = new_batch_infos
-              lod.header.num_batch_infos = lod.batch_infos.size
-            }
-          end
-        }
-        @lods.each { |lod|
-          if lod.batch_infos
-            lod.header.batch_start = batch_index_map[lod.header.batch_start]
-          end
-        }
-      end
-    end
-
-    def recompute_layout
-      last_offset = 0x88
-
-      if @header.info_bones.number > 0
-        last_offset = @header.info_bones.offset = align(last_offset, 0x10)
-        last_offset += @bones.first.__size * @header.info_bones.number
-      else
-        @header.info_bones.offset = 0x0
-      end
-
-      if @header.info_bones.number > 0
-        last_offset = @header.info_bone_index_translate_table.offset = align(last_offset, 0x10)
-        last_offset += @bone_index_translate_table.__size
-      else
-        @header.info_bone_index_translate_table.offset = 0x0
-      end
-
-      if @header.info_vertex_groups.number > 0
-        last_offset = @header.info_vertex_groups.offset = align(last_offset, 0x4)
-        last_offset += @vertex_groups.first.header.__size * @header.info_vertex_groups.number
-        @vertex_groups.each { |vg|
-          if vg.header.num_vertexes > 0
-            last_offset = vg.header.offset_vertexes = align(last_offset, 0x10)
-            last_offset += vg.header.vertex_size * vg.header.num_vertexes
-            if vg.header.vertex_ex_data_size > 0
-              last_offset = vg.header.offset_vertexes_ex_data = align(last_offset, 0x10)
-              last_offset += vg.header.vertex_ex_data_size * vg.header.num_vertexes
-            end
-          end
-          if vg.header.num_indices > 0
-            last_offset = vg.header.offset_indices = align(last_offset, 0x10)
-            last_offset += (@header.flags & 0x8 > 0 ? 4 : 2) * vg.header.num_indices
-          end
-        }
-      else
-        @header.info_vertex_groups.offset = 0x0
-      end
-
-      if @header.info_batches.number > 0
-        last_offset = @header.info_batches.offset = align(last_offset, 0x4)
-        last_offset += @batches.first.__size * @header.info_batches.number
-      else
-        @header.info_batches.offset = 0x0
-      end
-
-      if @header.info_lods.number > 0
-        last_offset = @header.info_lods.offset = align(last_offset, 0x4)
-        last_offset += @lods.first.header.__size * @header.info_lods.number
-        @lods.each { |lod|
-          if lod.header.num_batch_infos > 0
-            lod.header.offset_batch_infos = last_offset
-            last_offset += lod.batch_infos.first.__size * lod.header.num_batch_infos
-          end
-          lod.header.offset_name = last_offset
-          last_offset += lod.name.size
-        }
-      else
-        @header.info_lods.offset = 0x0
-      end
-
-      if @header.info_mesh_material_pairs.number > 0
-        last_offset = @header.info_mesh_material_pairs.offset = align(last_offset, 0x10)
-        last_offset += @mesh_material_pairs.first.__size * @header.info_mesh_material_pairs.number
-      else
-        @header.info_mesh_material_pairs.offset = 0x0
-      end
-
-      if @header.info_col_tree_nodes.number > 0
-        last_offset = @header.info_col_tree_nodes.offset = align(last_offset, 0x10)
-        last_offset += @col_tree_nodes.first.__size * @header.info_col_tree_nodes.number
-      else
-        @header.info_col_tree_nodes.offset = 0x0
-      end
-
-      if @header.info_bone_sets.number > 0
-        last_offset = @header.info_bone_sets.offset = align(last_offset, 0x10)
-        last_offset += 0x8 * @header.info_bone_sets.number
-        @bone_sets.each { |bone_set|
-          last_offset = bone_set.offset_bone_indices = align(last_offset, 0x10)
-          last_offset += 0x2 * bone_set.num_bone_indices
-        }
-      else
-        @header.info_bone_sets.offset = 0x0
-      end
-
-      if @header.info_bone_map.number > 0
-        last_offset = @header.info_bone_map.offset = align(last_offset, 0x10)
-        last_offset += 0x4 * @header.info_bone_map.number
-      else
-        @header.info_bone_map.offset = 0x0
-      end
-
-      if @header.info_meshes.number > 0
-        last_offset = @header.info_meshes.offset = align(last_offset, 0x4)
-        last_offset += @meshes.first.header.__size * @header.info_meshes.number
-        @meshes.each { |mesh|
-          mesh.header.offset_name = last_offset
-          last_offset += mesh.name.size
-          if mesh.header.num_materials > 0
-            mesh.header.offset_materials = last_offset
-            last_offset += 0x2 * mesh.header.num_materials
-          else
-            mesh.header.offset_materials = 0x0
-          end
-          if mesh.header.num_bones_indices > 0
-            mesh.header.offset_bones_indices = last_offset
-            last_offset += 0x2 * mesh.header.num_bones_indices
-          else
-            mesh.header.offset_bones_indices = 0x0
-          end
-        }
-      else
-        @header.info_meshes.offset = 0x0
-      end
-
-      if @header.info_materials.number > 0
-        last_offset = @header.info_materials.offset = align(last_offset, 0x10)
-        last_offset += @materials.first.header.__size * @header.info_materials.number
-        @materials.each { |material|
-          material.header.offset_name = last_offset
-          last_offset += material.name.size
-          material.header.offset_shader_name = last_offset
-          last_offset += material.shader_name.size
-          material.header.offset_technique_name = last_offset
-          last_offset += material.technique_name.size
-          if material.header.num_textures > 0
-            material.header.offset_textures = last_offset
-            last_offset += 0x8 * material.header.num_textures
-            material.textures.each { |texture|
-              texture.offset_name = last_offset
-              last_offset += texture.name.size
-            }
-          else
-            material.header.offset_textures = 0x0
-          end
-          if material.header.num_parameters_groups > 0
-            last_offset = material.header.offset_parameters_groups = align(last_offset, 0x10)
-            last_offset += 0xC * material.header.num_parameters_groups
-            material.parameters_groups.each { |parameter_group|
-              last_offset = parameter_group.offset_parameters = align(last_offset, 0x10)
-              last_offset += 0x4 * parameter_group.num_parameters
-            }
-          else
-            material.header.offset_parameters_group = 0x0
-          end
-          if material.header.num_variables > 0
-            last_offset = material.header.offset_variables = align(last_offset, 0x10)
-            last_offset += 0x8 * material.header.num_variables
-            material.variables.each { |variable|
-              variable.offset_name = last_offset
-              last_offset += variable.name.size
-            }
-          else
-            material.header.offset_variables = 0x0
-          end
-        }
-      else
-        @header.info_materials.offset = 0x0
-      end
-
-      if @header.info_unknown1.number > 0
-        last_offset = @header.info_unknown1.offset = align(last_offset, 0x4)
-        last_offset += @unknown1.first.__size * @header.info_unknown1.number
-      else
-        @header.info_unknown1.offset = 0x0
-      end
-
-    end
-
-    def was_big?
-      @__was_big
-    end
-
-    def get_vertex_field(field, vg, vi)
-      @vertex_groups[vg].get_vertex_field(field, vi)
-    end
-
-    def set_vertex_field(field, vg, vi, val)
-      @vertex_groups[vg].set_vertex_field(field, vi, val)
-    end
-
-    def scale(s)
-      @vertex_groups.each { |vg|
-        if vg.vertexes && vg.vertexes.first.respond_to?(:position)
-          vg.vertexes.each { |v|
-            v.position.x = v.position.x * s
-            v.position.y = v.position.y * s
-            v.position.z = v.position.z * s
-          }
-        end
-      }
-      @bones.each { |b|
-        b.position.x = b.position.x * s
-        b.position.y = b.position.y * s
-        b.position.z = b.position.z * s
-        b.local_position.x = b.local_position.x * s
-        b.local_position.y = b.local_position.y * s
-        b.local_position.z = b.local_position.z * s
-        b.t_position.x = b.t_position.x * s
-        b.t_position.y = b.t_position.y * s
-        b.t_position.z = b.t_position.z * s
-      }
-      self
-    end
-
-    def dump_bones(list = nil)
-      bone_struct = Struct::new(:index, :parent, :relative_position, :position, :global_index, :symmetric, :flag)
-      list = (0...@header.num_bones) unless list
-      list.collect { |bi|
-        bone_struct::new(bi, @bones[bi].parent_index, @bones[bi].local_position, @bones[bi].position,
-                         @bones[bi].id, -1, 5)
-      }
-    end
-
-    def get_vertex_usage
-      vertex_usage = Hash::new { |h, k| h[k] = [] }
-      @batches.each { |b|
-        @vertex_groups[b.vertex_group_index].indices[b.index_start...(b.index_start+b.num_indices)].each { |i|
-          vertex_usage[[b.vertex_group_index, i]].push( b )
-        }
-      }
-      vertex_usage.each { |k,v| v.uniq! }
-      vertex_usage
-    end
-
-    def recompute_relative_positions
-      @bones.each { |b|
-        if b.parent_index != -1
-          b.local_position = b.position - @bones[b.parent_index].position
-        else
-          b.local_position = b.position
-        end
-      }
-      self
-    end
-
-    def set_tpose
-      neutral_scale = Linalg::Vector::new(1.0, 1.0, 1.0)
-      inverse_bind_pose = @bones.collect { |b|
-        parent_scale = neutral_scale
-        parent_scale = @bones[b.parent_index].scale if b.parent_index != -1
-        Linalg::get_inverse_transformation_matrix(b.position, b.rotation, b.scale, parent_scale)
-      }
-      target_pose = @bones.collect { |b|
-        Linalg::get_translation_matrix(b.t_position)
-      }
-      bones.each { |b|
-        b.position = b.t_position
-        b.rotation.x = 0.0
-        b.rotation.y = 0.0
-        b.rotation.z = 0.0
-        b.scale.x = 1.0
-        b.scale.y = 1.0
-        b.scale.z = 1.0
-        b.local_rotation.x = 0.0
-        b.local_rotation.y = 0.0
-        b.local_rotation.z = 0.0
-        b.local_scale.x = 1.0
-        b.local_scale.y = 1.0
-        b.local_scale.z = 1.0
-      }
-      multiplied_matrices = target_pose.each_with_index.collect { |m, i|
-        m * inverse_bind_pose[i]
-      }
-      vertex_usage = get_vertex_usage
-      vertex_usage.each { |(vgi, vi), bs|
-        if bs.first.bone_set_index >= 0
-          bone_set = bone_sets[bs.first.bone_set_index].bone_indices
-          bone_refs = bone_set.collect { |bi| @bone_map[bi] }
-        else
-          bone_refs = @bone_map
-        end
-        bone_infos = get_vertex_field(:bone_infos, vgi, vi)
-        indexes_and_weights = bone_infos.get_indexes_and_weights
-        vertex_matrix = Linalg::get_zero_matrix
-        indexes_and_weights.each { |bi, bw|
-          i = bone_refs[bi]
-          vertex_matrix = vertex_matrix + multiplied_matrices[i] * (bw.to_f/255.to_f)
-        }
-        vp = get_vertex_field(:position, vgi, vi)
-        new_vp = vertex_matrix * Linalg::Vector::new(vp.x, vp.y, vp.z)
-        vp.x = new_vp.x
-        vp.y = new_vp.y
-        vp.z = new_vp.z
-        n = get_vertex_field(:normal, vgi, vi)
-        new_n = vertex_matrix * Linalg::Vector::new(n.x, n.y, n.z, 0.0)
-        n.x = new_n.x
-        n.y = new_n.y
-        n.z = new_n.z
-        t = get_vertex_field(:tangents, vgi, vi)
-        new_t = vertex_matrix * Linalg::Vector::new(t.x, t.y, t.z, 0.0)
-        t.x = new_t.x
-        t.y = new_t.y
-        t.z = new_t.z
-      }
-      self
-    end
-
-    def self.load(input_name)
-      if input_name.respond_to?(:read) && input_name.respond_to?(:seek)
-        input = input_name
-      else
-        File.open(input_name, "rb") { |f|
-          input = StringIO::new(f.read, "rb")
-        }
-      end
-      wmb = self::new
-      wmb.instance_variable_set(:@__was_big, false)
-      wmb.__load(input, false)
-      input.close unless input_name.respond_to?(:read) && input_name.respond_to?(:seek)
-      wmb
-    end
-
-    def dump(output_name, output_big = false)
-      if output_name.respond_to?(:write) && output_name.respond_to?(:seek)
-        output = output_name
-      else
-        output = StringIO::new("", "wb")#File.open(output_name, "wb")
-      end
-      output.rewind
-
-      __set_dump_state(output, output_big, nil, nil)
-      __dump_fields
-      __unset_dump_state
-
-
-      unless output_name.respond_to?(:write) && output_name.respond_to?(:seek)
-        File.open(output_name, "wb") { |f|
-          f.write output.string
-        }
-        output.close
-      end
-      self
-    end
-  end
-end
+module Bayonetta
+  class WMB3File < LibBin::Structure
+    include Alignment
+
+    class MeshMaterialPair < LibBin::Structure
+      uint32 :mesh_index
+      uint32 :material_index
+    end
+
+    class Mesh < LibBin::Structure
+      class Header < LibBin::Structure
+        uint32 :offset_name
+        float  :bounding_box, length: 6
+        uint32 :offset_materials
+        uint32 :num_materials
+        uint32 :offset_bones_indices
+        uint32 :num_bones_indices
+      end
+      register_field :header, Header
+      string :name, offset: 'header\offset_name'
+      uint16 :materials, length: 'header\num_materials', offset: 'header\offset_materials'
+      uint16 :bone_indices, length: 'header\num_bones_indices', offset: 'header\offset_bones_indices'
+    end
+
+    class Material < LibBin::Structure
+
+      class Variable < LibBin::Structure
+        uint32 :offset_name
+        float :value
+        string :name, offset: 'offset_name'
+      end
+
+      class ParameterGroup < LibBin::Structure
+        int32 :index
+        uint32 :offset_parameters
+        uint32 :num_parameters
+        float :parameters, length: 'num_parameters', offset: 'offset_parameters'
+      end
+
+      class Texture < LibBin::Structure
+        uint32 :offset_name
+        uint32 :texture_id
+        string :name, offset: 'offset_name'
+      end
+
+      class Header < LibBin::Structure
+        uint16 :date, length: 4
+        uint32 :offset_name
+        uint32 :offset_shader_name
+        uint32 :offset_technique_name
+        uint32 :u_a
+        uint32 :offset_textures
+        uint32 :num_textures
+        uint32 :offset_parameters_groups
+        uint32 :num_parameters_groups
+        uint32 :offset_variables
+        uint32 :num_variables
+      end
+      register_field :header, Header
+      string :name, offset: 'header\offset_name'
+      string :shader_name, offset: 'header\offset_shader_name'
+      string :technique_name, offset: 'header\offset_technique_name'
+      register_field :textures, Texture, count: 'header\num_textures', sequence: true,
+                     offset: 'header\offset_textures + __iterator * 8'
+      register_field :parameters_groups, ParameterGroup, count: 'header\num_parameters_groups',
+                     sequence: true, offset: 'header\offset_parameters_groups + __iterator * 12'
+      register_field :variables, Variable, count: 'header\num_variables', sequence: true,
+                     offset: 'header\offset_variables + __iterator * 8'
+
+    end
+
+    class BoneSet < LibBin::Structure
+      uint32 :offset_bone_indices
+      uint32 :num_bone_indices
+      int16 :bone_indices, length: 'num_bone_indices', offset: 'offset_bone_indices'
+    end
+
+    class Lod < LibBin::Structure
+
+      class BatchInfo < LibBin::Structure
+        uint32 :vertex_group_index
+        uint32 :mesh_index
+        uint32 :material_index
+        int32 :call_tree_node_index
+        uint32 :mesh_material_index
+        int32 :u_b
+      end
+
+      class Header < LibBin::Structure
+        uint32 :offset_name
+        int32 :lod_level
+        uint32 :batch_start
+        uint32 :offset_batch_infos
+        uint32 :num_batch_infos
+      end
+      register_field :header, Header
+      string :name, offset: 'header\offset_name'
+      register_field :batch_infos, BatchInfo, length: 'header\num_batch_infos', offset: 'header\offset_batch_infos'
+    end
+
+    class ColTreeNode < LibBin::Structure
+      register_field :p1, Position
+      register_field :p2, Position
+      int32 :left
+      int32 :right
+    end
+
+    class Batch < LibBin::Structure
+      uint32 :vertex_group_index
+      int32 :bone_set_index
+      uint32 :vertex_start
+      uint32 :index_start
+      uint32 :num_vertexes
+      uint32 :num_indices
+      uint32 :num_primitives
+    end
+
+    VERTEX_TYPES = {}
+    VERTEX_TYPES.update( YAML::load_file(File.join( File.dirname(__FILE__), 'vertex_types_nier.yaml')) )
+
+    class VertexGroup < LibBin::Structure
+
+      def is_bayo2? #UByteList are arrays of char really
+        true
+      end
+
+      def get_vertex_fields
+        if @vertex_fields
+          return @vertex_fields
+        else
+          types = VERTEX_TYPES[ @header.vertex_flags ]
+          @vertex_fields = []
+          if types[0]
+            types[0].each { |name, type|
+              @vertex_fields.push(name)
+            }
+          end
+          if types[1]
+            types[1].each { |name, type|
+              @vertex_fields.push(name)
+            }
+          end
+          return @vertex_fields
+        end
+      end
+
+      def get_vertex_types
+        if @vertex_type
+          return [@vertex_type, @vertex_ex_type]
+        else
+          types = VERTEX_TYPES[ @header.vertex_flags ]
+          @vertex_type = Class::new(LibBin::Structure)
+          @vertex_size = 0
+          if types[0]
+            types[0].each { |name, type|
+              @vertex_type.register_field(name, VERTEX_FIELDS[type][0])
+              @vertex_size += VERTEX_FIELDS[type][1]
+            }
+          end
+          raise "Invalid size for vertex data #{@vertex_size} != #{@header.vertex_size}!" if @vertex_size != @header.vertex_size
+          @vertex_ex_type = Class::new(LibBin::Structure)
+          @vertex_ex_size = 0
+          if types[1]
+            types[1].each { |name, type|
+              @vertex_ex_type.register_field(name, VERTEX_FIELDS[type][0])
+              @vertex_ex_size += VERTEX_FIELDS[type][1]
+            }
+          end
+          raise "Invalid size for ex data #{@vertex_ex_size} != #{@header.vertex_ex_data_size}!" if @vertex_ex_size != @header.vertex_ex_data_size
+          return [@vertex_type, @vertex_ex_type]
+        end
+      end
+
+      def get_vertex_field(field, vi)
+        if @vertexes[vi].respond_to?(field)
+          return @vertexes[vi].send(field)
+        elsif @vertexes_ex_data && @vertexes_ex_data[vi].respond_to?(field)
+          return @vertexes_ex_data[vi].send(field)
+        else
+          return nil
+        end
+      end
+
+      def set_vertex_field(field, vi, val)
+        if @vertexes[vi].respond_to?(field)
+          return @vertexes[vi].send(:"#{field}=", val)
+        elsif @vertexes_ex_data && @vertexes_ex_data[vi].respond_to?(field)
+          return @vertexes_ex_data[vi].send(:"#{field}=", val)
+        else
+          raise "Couldn't find field: #{field}!"
+        end
+      end
+
+      class Header < LibBin::Structure
+        uint32 :offset_vertexes
+        uint32 :offset_vertexes_ex_data
+        uint32 :u_a
+        uint32 :u_b
+        uint32 :vertex_size
+        uint32 :vertex_ex_data_size
+        uint32 :u_c
+        uint32 :u_d
+        uint32 :num_vertexes
+        uint32 :vertex_flags
+        uint32 :offset_indices
+        uint32 :num_indices
+      end
+      register_field :header, Header
+      register_field :vertexes, 'get_vertex_types[0]', length: 'header\num_vertexes', offset: 'header\offset_vertexes'
+      register_field :vertexes_ex_data, 'get_vertex_types[1]', length: 'header\num_vertexes',
+                     offset: 'header\offset_vertexes_ex_data'
+      register_field :indices, '(..\header.flags & 0x8) != 0 ? UInt32 : UInt16' , length: 'header\num_indices', offset: 'header\offset_indices'
+    end
+
+    class Bone < LibBin::Structure
+      int16 :id
+      int16 :parent_index
+      register_field :local_position, Position
+      register_field :local_rotation, Position
+      register_field :local_scale, Position
+      register_field :position, Position
+      register_field :rotation, Position
+      register_field :scale, Position
+      register_field :t_position, Position
+    end
+
+    class Unknown1 < LibBin::Structure
+      uint32 :data, length: 6
+    end
+
+    class InfoPair < LibBin::Structure
+      uint32 :offset
+      uint32 :number
+    end
+
+    class Header < LibBin::Structure
+      def self.info_pair(field, length: nil, count: nil, offset: nil, sequence: false, condition: nil)
+        register_field(field, InfoPair, length: length, count: count, offset: offset, sequence: sequence, condition: condition)
+      end
+
+      uint32 :id
+      uint32 :version
+      int32  :u_a
+      int16  :flags
+      int16  :u_c
+      float  :bounding_box, length: 6
+      info_pair :info_bones
+      info_pair :info_bone_index_translate_table
+      info_pair :info_vertex_groups
+      info_pair :info_batches
+      info_pair :info_lods
+      info_pair :info_col_tree_nodes
+      info_pair :info_bone_map
+      info_pair :info_bone_sets
+      info_pair :info_materials
+      info_pair :info_meshes
+      info_pair :info_mesh_material_pairs
+      info_pair :info_unknown1
+    end
+
+    register_field :header, Header
+    register_field :bones, Bone, length: 'header\info_bones\number',
+                   offset: 'header\info_bones\offset'
+    register_field :bone_index_translate_table, BoneIndexTranslateTable,
+                   offset: 'header\info_bone_index_translate_table\offset'
+    register_field :vertex_groups, VertexGroup, count: 'header\info_vertex_groups\number',
+                   sequence: true, offset: 'header\info_vertex_groups\offset + __iterator * 48'
+    register_field :batches, Batch, length: 'header\info_batches\number',
+                   offset: 'header\info_batches\offset'
+    register_field :lods, Lod, count: 'header\info_lods\number', sequence: true,
+                   offset: 'header\info_lods\offset + __iterator * 20'
+    register_field :col_tree_nodes, ColTreeNode, length: 'header\info_col_tree_nodes\number',
+                   offset: 'header\info_col_tree_nodes\offset'
+    uint32         :bone_map, length: 'header\info_bone_map\number',
+                   offset: 'header\info_bone_map\offset'
+    register_field :bone_sets, BoneSet, count: 'header\info_bone_sets\number', sequence: true,
+                   offset: 'header\info_bone_sets\offset + __iterator * 8'
+    register_field :materials, Material, count: 'header\info_materials\number', sequence: true,
+                   offset: 'header\info_materials\offset + __iterator * 48'
+    register_field :meshes, Mesh, count: 'header\info_meshes\number', sequence: true,
+                   offset: 'header\info_meshes\offset + __iterator * 44'
+    register_field :mesh_material_pairs, MeshMaterialPair,
+                   length: 'header\info_mesh_material_pairs\number',
+                   offset: 'header\info_mesh_material_pairs\offset'
+    register_field :unknown1, Unknown1, length: 'header\info_unknown1\number',
+                   offset: 'header\info_unknown1\offset'
+
+    def texture_ids
+      ids = @materials.collect { |m|
+        m.textures.collect { |t| t.texture_id }
+      }
+      ids.flatten.uniq
+    end
+
+    def materials_textures
+      mat_tex = @materials.collect { |m|
+        [m.name, m.textures.collect { |t| [t.texture_id, t.name] }]
+      }.to_h
+    end
+
+    def cleanup_vertexes
+      vertex_usage, index_usage = get_vertex_index_usage
+      @vertex_groups.each_with_index { |vertex_group, vertex_group_index|
+        new_vertex_map = vertex_usage[vertex_group_index].uniq.sort.each_with_index.to_h
+        vertex_group.vertexes = new_vertex_map.keys.collect { |i|
+          vertex_group.vertexes[i]
+        }
+        vertex_group.vertexes_ex_data = new_vertex_map.keys.collect { |i|
+          vertex_group.vertexes_ex_data[i]
+        }
+        vertex_group.header.num_vertexes = vertex_group.vertexes.size
+
+        new_index_map = index_usage[vertex_group_index].uniq.sort.each_with_index.to_h
+        vertex_group.indices = new_index_map.keys.collect { |i|
+          new_vertex_map[vertex_group.indices[i]]
+        }
+        vertex_group.header.num_indices = vertex_group.indices.size
+        @batches.select { |batch| batch.vertex_group_index == vertex_group_index }.each { |batch|
+          batch.vertex_start = new_vertex_map[batch.vertex_start]
+          batch.index_start = new_index_map[batch.index_start]
+          if batch.vertex_start != 0
+            ((batch.index_start)...(batch.index_start + batch.num_indices)).each { |i|
+              vertex_group.indices[i] = vertex_group.indices[i] - batch.vertex_start
+            }
+          end
+        }
+      }
+    end
+
+    def get_vertex_index_usage
+      vertex_usage = Hash::new { |h, k| h[k] = [] }
+      index_usage = Hash::new { |h, k| h[k] = [] }
+      @batches.each { |batch|
+        index_range = (batch.index_start)...(batch.index_start + batch.num_indices)
+        index_usage[batch.vertex_group_index] += index_range.to_a
+        vertex_usage[batch.vertex_group_index] += @vertex_groups[batch.vertex_group_index].indices[index_range].collect { |vertex|
+          vertex + batch.vertex_start
+        }
+      }
+      return [vertex_usage, index_usage]
+    end
+
+    def delete_meshes(list)
+      kept_meshes = @meshes.size.times.to_a - list
+      new_mesh_map = kept_meshes.each_with_index.to_h
+      if @meshes
+        @meshes = kept_meshes.collect { |i|
+          @meshes[i]
+        }
+        @header.info_meshes.number = @meshes.size
+      end
+      if @mesh_material_pairs
+        @mesh_material_pairs = @mesh_material_pairs.select { |pair|
+          ! list.include?(pair.mesh_index)
+        }
+        @header.info_mesh_material_pairs.number = @mesh_material_pairs.size
+        @mesh_material_pairs.each { |pair|
+          pair.mesh_index = new_mesh_map[pair.mesh_index]
+        }
+      end
+      if @lods && @batches
+        batch_indexes = @header.info_batches.number.times.to_a
+        filtered_batches = Set::new
+        @lods.each { |lod|
+          if lod.batch_infos
+            lod.batch_infos.each_with_index { |batch_info, index|
+              if list.include?(batch_info.mesh_index)
+                filtered_batches.add( index + lod.header.batch_start )
+              end
+            }
+            lod.batch_infos = lod.batch_infos.select { |batch_info|
+              ! list.include?(batch_info.mesh_index)
+            }
+            lod.header.num_batch_infos = lod.batch_infos.size
+            lod.batch_infos.each { |batch_info|
+              batch_info.mesh_index = new_mesh_map[batch_info.mesh_index]
+            }
+          end
+        }
+        batch_indexes -= filtered_batches.to_a
+        batch_index_map = batch_indexes.each_with_index.to_h
+        @batches = batch_indexes.collect { |index|
+          @batches[index]
+        }
+        @header.info_batches.number = @batches.size
+        @lods.each { |lod|
+          if lod.batch_infos
+            lod.header.batch_start = batch_index_map[lod.header.batch_start]
+          end
+        }
+      end
+      self
+    end
+
+    def delete_batches(batch_list)
+      if @lods && @batches
+        batch_indexes = @header.info_batches.number.times.to_a
+        batch_indexes -= batch_list
+        batch_index_map = batch_indexes.each_with_index.to_h
+        @batches = batch_indexes.collect { |index|
+          @batches[index]
+        }
+        @header.info_batches.number = @batches.size
+        @lods.each { |lod|
+          if lod.batch_infos
+            new_batch_infos = []
+            lod.batch_infos.each_with_index { |batch_info, index|
+              unless batch_list.include?(lod.header.batch_start + index)
+                new_batch_infos.push batch_info
+              end
+              lod.batch_infos = new_batch_infos
+              lod.header.num_batch_infos = lod.batch_infos.size
+            }
+          end
+        }
+        @lods.each { |lod|
+          if lod.batch_infos
+            lod.header.batch_start = batch_index_map[lod.header.batch_start]
+          end
+        }
+      end
+    end
+
+    def recompute_layout
+      last_offset = 0x88
+
+      if @header.info_bones.number > 0
+        last_offset = @header.info_bones.offset = align(last_offset, 0x10)
+        last_offset += @bones.first.__size * @header.info_bones.number
+      else
+        @header.info_bones.offset = 0x0
+      end
+
+      if @header.info_bones.number > 0
+        last_offset = @header.info_bone_index_translate_table.offset = align(last_offset, 0x10)
+        last_offset += @bone_index_translate_table.__size
+      else
+        @header.info_bone_index_translate_table.offset = 0x0
+      end
+
+      if @header.info_vertex_groups.number > 0
+        last_offset = @header.info_vertex_groups.offset = align(last_offset, 0x4)
+        last_offset += @vertex_groups.first.header.__size * @header.info_vertex_groups.number
+        @vertex_groups.each { |vg|
+          if vg.header.num_vertexes > 0
+            last_offset = vg.header.offset_vertexes = align(last_offset, 0x10)
+            last_offset += vg.header.vertex_size * vg.header.num_vertexes
+            if vg.header.vertex_ex_data_size > 0
+              last_offset = vg.header.offset_vertexes_ex_data = align(last_offset, 0x10)
+              last_offset += vg.header.vertex_ex_data_size * vg.header.num_vertexes
+            end
+          end
+          if vg.header.num_indices > 0
+            last_offset = vg.header.offset_indices = align(last_offset, 0x10)
+            last_offset += (@header.flags & 0x8 > 0 ? 4 : 2) * vg.header.num_indices
+          end
+        }
+      else
+        @header.info_vertex_groups.offset = 0x0
+      end
+
+      if @header.info_batches.number > 0
+        last_offset = @header.info_batches.offset = align(last_offset, 0x4)
+        last_offset += @batches.first.__size * @header.info_batches.number
+      else
+        @header.info_batches.offset = 0x0
+      end
+
+      if @header.info_lods.number > 0
+        last_offset = @header.info_lods.offset = align(last_offset, 0x4)
+        last_offset += @lods.first.header.__size * @header.info_lods.number
+        @lods.each { |lod|
+          if lod.header.num_batch_infos > 0
+            lod.header.offset_batch_infos = last_offset
+            last_offset += lod.batch_infos.first.__size * lod.header.num_batch_infos
+          end
+          lod.header.offset_name = last_offset
+          last_offset += lod.name.size
+        }
+      else
+        @header.info_lods.offset = 0x0
+      end
+
+      if @header.info_mesh_material_pairs.number > 0
+        last_offset = @header.info_mesh_material_pairs.offset = align(last_offset, 0x10)
+        last_offset += @mesh_material_pairs.first.__size * @header.info_mesh_material_pairs.number
+      else
+        @header.info_mesh_material_pairs.offset = 0x0
+      end
+
+      if @header.info_col_tree_nodes.number > 0
+        last_offset = @header.info_col_tree_nodes.offset = align(last_offset, 0x10)
+        last_offset += @col_tree_nodes.first.__size * @header.info_col_tree_nodes.number
+      else
+        @header.info_col_tree_nodes.offset = 0x0
+      end
+
+      if @header.info_bone_sets.number > 0
+        last_offset = @header.info_bone_sets.offset = align(last_offset, 0x10)
+        last_offset += 0x8 * @header.info_bone_sets.number
+        @bone_sets.each { |bone_set|
+          last_offset = bone_set.offset_bone_indices = align(last_offset, 0x10)
+          last_offset += 0x2 * bone_set.num_bone_indices
+        }
+      else
+        @header.info_bone_sets.offset = 0x0
+      end
+
+      if @header.info_bone_map.number > 0
+        last_offset = @header.info_bone_map.offset = align(last_offset, 0x10)
+        last_offset += 0x4 * @header.info_bone_map.number
+      else
+        @header.info_bone_map.offset = 0x0
+      end
+
+      if @header.info_meshes.number > 0
+        last_offset = @header.info_meshes.offset = align(last_offset, 0x4)
+        last_offset += @meshes.first.header.__size * @header.info_meshes.number
+        @meshes.each { |mesh|
+          mesh.header.offset_name = last_offset
+          last_offset += mesh.name.size
+          if mesh.header.num_materials > 0
+            mesh.header.offset_materials = last_offset
+            last_offset += 0x2 * mesh.header.num_materials
+          else
+            mesh.header.offset_materials = 0x0
+          end
+          if mesh.header.num_bones_indices > 0
+            mesh.header.offset_bones_indices = last_offset
+            last_offset += 0x2 * mesh.header.num_bones_indices
+          else
+            mesh.header.offset_bones_indices = 0x0
+          end
+        }
+      else
+        @header.info_meshes.offset = 0x0
+      end
+
+      if @header.info_materials.number > 0
+        last_offset = @header.info_materials.offset = align(last_offset, 0x10)
+        last_offset += @materials.first.header.__size * @header.info_materials.number
+        @materials.each { |material|
+          material.header.offset_name = last_offset
+          last_offset += material.name.size
+          material.header.offset_shader_name = last_offset
+          last_offset += material.shader_name.size
+          material.header.offset_technique_name = last_offset
+          last_offset += material.technique_name.size
+          if material.header.num_textures > 0
+            material.header.offset_textures = last_offset
+            last_offset += 0x8 * material.header.num_textures
+            material.textures.each { |texture|
+              texture.offset_name = last_offset
+              last_offset += texture.name.size
+            }
+          else
+            material.header.offset_textures = 0x0
+          end
+          if material.header.num_parameters_groups > 0
+            last_offset = material.header.offset_parameters_groups = align(last_offset, 0x10)
+            last_offset += 0xC * material.header.num_parameters_groups
+            material.parameters_groups.each { |parameter_group|
+              last_offset = parameter_group.offset_parameters = align(last_offset, 0x10)
+              last_offset += 0x4 * parameter_group.num_parameters
+            }
+          else
+            material.header.offset_parameters_group = 0x0
+          end
+          if material.header.num_variables > 0
+            last_offset = material.header.offset_variables = align(last_offset, 0x10)
+            last_offset += 0x8 * material.header.num_variables
+            material.variables.each { |variable|
+              variable.offset_name = last_offset
+              last_offset += variable.name.size
+            }
+          else
+            material.header.offset_variables = 0x0
+          end
+        }
+      else
+        @header.info_materials.offset = 0x0
+      end
+
+      if @header.info_unknown1.number > 0
+        last_offset = @header.info_unknown1.offset = align(last_offset, 0x4)
+        last_offset += @unknown1.first.__size * @header.info_unknown1.number
+      else
+        @header.info_unknown1.offset = 0x0
+      end
+
+    end
+
+    def was_big?
+      @__was_big
+    end
+
+    def get_vertex_field(field, vg, vi)
+      @vertex_groups[vg].get_vertex_field(field, vi)
+    end
+
+    def set_vertex_field(field, vg, vi, val)
+      @vertex_groups[vg].set_vertex_field(field, vi, val)
+    end
+
+    def scale(s)
+      @vertex_groups.each { |vg|
+        if vg.vertexes && vg.vertexes.first.respond_to?(:position)
+          vg.vertexes.each { |v|
+            v.position.x = v.position.x * s
+            v.position.y = v.position.y * s
+            v.position.z = v.position.z * s
+          }
+        end
+      }
+      @bones.each { |b|
+        b.position.x = b.position.x * s
+        b.position.y = b.position.y * s
+        b.position.z = b.position.z * s
+        b.local_position.x = b.local_position.x * s
+        b.local_position.y = b.local_position.y * s
+        b.local_position.z = b.local_position.z * s
+        b.t_position.x = b.t_position.x * s
+        b.t_position.y = b.t_position.y * s
+        b.t_position.z = b.t_position.z * s
+      }
+      self
+    end
+
+    def dump_bones(list = nil)
+      bone_struct = Struct::new(:index, :parent, :relative_position, :position, :global_index, :symmetric, :flag)
+      list = (0...@header.num_bones) unless list
+      list.collect { |bi|
+        bone_struct::new(bi, @bones[bi].parent_index, @bones[bi].local_position, @bones[bi].position,
+                         @bones[bi].id, -1, 5)
+      }
+    end
+
+    def get_vertex_usage
+      vertex_usage = Hash::new { |h, k| h[k] = [] }
+      @batches.each { |b|
+        @vertex_groups[b.vertex_group_index].indices[b.index_start...(b.index_start+b.num_indices)].each { |i|
+          vertex_usage[[b.vertex_group_index, i]].push( b )
+        }
+      }
+      vertex_usage.each { |k,v| v.uniq! }
+      vertex_usage
+    end
+
+    def recompute_relative_positions
+      @bones.each { |b|
+        if b.parent_index != -1
+          b.local_position = b.position - @bones[b.parent_index].position
+        else
+          b.local_position = b.position
+        end
+      }
+      self
+    end
+
+    def set_tpose
+      neutral_scale = Linalg::Vector::new(1.0, 1.0, 1.0)
+      inverse_bind_pose = @bones.collect { |b|
+        parent_scale = neutral_scale
+        parent_scale = @bones[b.parent_index].scale if b.parent_index != -1
+        Linalg::get_inverse_transformation_matrix(b.position, b.rotation, b.scale, parent_scale)
+      }
+      target_pose = @bones.collect { |b|
+        Linalg::get_translation_matrix(b.t_position)
+      }
+      bones.each { |b|
+        b.position = b.t_position
+        b.rotation.x = 0.0
+        b.rotation.y = 0.0
+        b.rotation.z = 0.0
+        b.scale.x = 1.0
+        b.scale.y = 1.0
+        b.scale.z = 1.0
+        b.local_rotation.x = 0.0
+        b.local_rotation.y = 0.0
+        b.local_rotation.z = 0.0
+        b.local_scale.x = 1.0
+        b.local_scale.y = 1.0
+        b.local_scale.z = 1.0
+      }
+      multiplied_matrices = target_pose.each_with_index.collect { |m, i|
+        m * inverse_bind_pose[i]
+      }
+      vertex_usage = get_vertex_usage
+      vertex_usage.each { |(vgi, vi), bs|
+        if bs.first.bone_set_index >= 0
+          bone_set = bone_sets[bs.first.bone_set_index].bone_indices
+          bone_refs = bone_set.collect { |bi| @bone_map[bi] }
+        else
+          bone_refs = @bone_map
+        end
+        bone_infos = get_vertex_field(:bone_infos, vgi, vi)
+        indexes_and_weights = bone_infos.get_indexes_and_weights
+        vertex_matrix = Linalg::get_zero_matrix
+        indexes_and_weights.each { |bi, bw|
+          i = bone_refs[bi]
+          vertex_matrix = vertex_matrix + multiplied_matrices[i] * (bw.to_f/255.to_f)
+        }
+        vp = get_vertex_field(:position, vgi, vi)
+        new_vp = vertex_matrix * Linalg::Vector::new(vp.x, vp.y, vp.z)
+        vp.x = new_vp.x
+        vp.y = new_vp.y
+        vp.z = new_vp.z
+        n = get_vertex_field(:normal, vgi, vi)
+        new_n = vertex_matrix * Linalg::Vector::new(n.x, n.y, n.z, 0.0)
+        n.x = new_n.x
+        n.y = new_n.y
+        n.z = new_n.z
+        t = get_vertex_field(:tangents, vgi, vi)
+        new_t = vertex_matrix * Linalg::Vector::new(t.x, t.y, t.z, 0.0)
+        t.x = new_t.x
+        t.y = new_t.y
+        t.z = new_t.z
+      }
+      self
+    end
+
+    def self.load(input_name)
+      if input_name.respond_to?(:read) && input_name.respond_to?(:seek)
+        input = input_name
+      else
+        File.open(input_name, "rb") { |f|
+          input = StringIO::new(f.read, "rb")
+        }
+      end
+      wmb = self::new
+      wmb.instance_variable_set(:@__was_big, false)
+      wmb.__load(input, false)
+      input.close unless input_name.respond_to?(:read) && input_name.respond_to?(:seek)
+      wmb
+    end
+
+    def dump(output_name, output_big = false)
+      if output_name.respond_to?(:write) && output_name.respond_to?(:seek)
+        output = output_name
+      else
+        output = StringIO::new("", "wb")#File.open(output_name, "wb")
+      end
+      output.rewind
+
+      __set_dump_state(output, output_big, nil, nil)
+      __dump_fields
+      __unset_dump_state
+
+
+      unless output_name.respond_to?(:write) && output_name.respond_to?(:seek)
+        File.open(output_name, "wb") { |f|
+          f.write output.string
+        }
+        output.close
+      end
+      self
+    end
+  end
+end