pgtools 1.0.0

data/lib/bayonetta/tools/wmb_import_nier.rb

@@ -0,0 +1,309 @@
+require 'optparse'
+require 'set'
+require_relative '../../bayonetta.rb'
+require 'yaml'
+require 'shellwords'
+include Bayonetta
+
+def merge_bones(wmb1, wmb2)
+
+  tt1 = wmb1.bone_index_translate_table.table
+  tt2_orig = wmb2.bone_index_translate_table.table
+  tt2 = tt2_orig.invert
+
+  bones1 = wmb1.get_bone_structure
+  if $options[:bone_map]
+    common_mapping = YAML::load_file( $options[:bone_map] )
+  else
+    common_mapping = {}
+  end
+
+  mapping = {}
+
+  tt2.each { |key, val|
+    mapping[key] = tt1[common_mapping[val]]
+  }
+  mapping = mapping.to_a.sort { |e1, e2| e1.first <=> e2.first }.to_h
+
+  if $options[:update_bones]
+    mapping.select { |k,v| v }.each { |k,v|
+      bones1[v].position = wmb2.bones[k].position
+    }
+  end
+
+  mapping[-1] = -1
+  missing_bones = mapping.select { |k,v| v.nil? }.collect { |k,v| k }
+  if $options[:filter_bones]
+    missing_bones -= $options[:filter_bones]
+  end
+  new_bone_index = bones1.size
+  new_bone_indexes = []
+  missing_bones.each { |bi|
+    mapping[bi] = new_bone_index
+    new_bone_indexes.push(new_bone_index)
+
+    b = Bone::new(wmb2.bones[bi].position)
+    b.index = new_bone_index
+    b.parent = bones1[mapping[wmb2.bones[bi].parent_index]] if wmb2.bones[bi].parent_index != -1
+    b.symmetric = -1
+    b.flag = 5
+
+    bones1.push b
+    new_bone_index += 1
+  }
+  wmb1.set_bone_structure(bones1)
+  missing_bones_count = missing_bones.length
+  raise "Too many bones to add!" if missing_bones_count > 0x100
+  (align(missing_bones_count, 0x10) - missing_bones_count).times {
+    new_bone_indexes.push(0xfff)
+  }
+
+  used_indexes = tt1.keys
+  start_index = nil
+
+  (0x250..(0x1000-new_bone_indexes.size)).step(0x10) { |s_index|
+    if (used_indexes & (s_index..(s_index+new_bone_indexes.size)).to_a) == []
+      start_index = s_index
+      break
+    end
+  }
+  raise "No room available in translate table!" unless start_index
+  new_tt = wmb1.bone_index_translate_table.table.dup
+  new_bone_indexes.each_with_index { |ind, i|
+    new_tt[i+start_index] = ind
+    common_mapping[tt2[missing_bones[i]]] = i + start_index if i < missing_bones.length && missing_bones[i]
+  }
+  wmb1.bone_index_translate_table.table = new_tt
+
+  if wmb1.bone_symmetries
+    (-missing_bones_count..-1).each { |i|
+      symmetric = common_mapping[wmb1.bone_symmetries[i]]
+      symmetric = -1 unless symmetric
+      wmb1.bone_symmetries[i] = symmetric
+    }
+  end
+
+  [common_mapping, mapping]
+end
+
+def get_texture_map(tex1, tex2)
+  offset = tex1.each.count
+  tex_map = {}
+  tex2.each.each_with_index { |t,i|
+    info, _ = t
+    _, _, idx = info
+    idx = i unless idx
+    tex_map[idx] = i+offset
+  }
+  tex_map
+end
+
+def merge_geometry(wmb1, wmb2, bone_mapping)
+  new_meshes = wmb2.header.info_meshes.number.times.collect { WMBFile::Mesh::new }
+  new_meshes.each_with_index { |m, i|
+    m.header.name = wmb2.meshes[i].name
+    m.header.id = i + wmb1.header.num_meshes
+  }
+
+  batch_infos_map = {}
+  wmb2.lods.each { |l|
+    l.batch_infos.each_with_index { |batch_info, i|
+      batch_infos_map[i+l.header.batch_start] = batch_info
+    }
+  }
+
+  vertex_types = wmb1.get_vertex_types
+
+  wmb2.batches.each_with_index { |n_b, batch_index|
+    v_g = wmb2.vertex_groups[n_b.vertex_group_index]
+    b_s = wmb2.bone_sets[n_b.bone_set_index]
+    b = WMBFile::Batch::new
+    first_vertex_index = wmb1.vertexes.length
+    indices = v_g.indices.slice(n_b.index_start, n_b.num_indices)
+    index_set = indices.uniq.sort
+    num_vertex = index_set.length
+    index_map = index_set.each_with_index.collect { |ind, i|
+      [ind, i+first_vertex_index]
+    }
+
+
+    wmb1.vertexes += num_vertex.times.collect {
+      vertex_types[0]::new
+    }
+    if wmb1.vertexes_ex_data
+      wmb1.vertexes_ex_data += num_vertex.times.collect {
+        vertex_types[1]::new
+      }
+    end
+    wmb1.header.num_vertexes += num_vertex
+
+    fields = wmb1.get_vertex_fields
+    fields.each { |field|
+      unless v_g.get_vertex_field(field, 0)
+        warn "Couldn't find vertex field #{field} in model 2"
+        if field == :color
+          warn "Using default value 0xc0 0xc0 0xc0 0xff"
+          c = Color::new
+          c.r = 0xc0
+          c.g = 0xc0
+          c.b = 0xc0
+          c.a = 0xff
+          index_map.each { |ind, i|
+            wmb1.set_vertex_field(field, i, c)
+          }
+        elsif field == :mapping2
+          warn "Using mapping as default"
+          index_map.each { |ind, i|
+            wmb1.set_vertex_field(field, i, v_g.get_vertex_field(:mapping, ind))
+          }
+        else
+          warn "No suitable default found"
+        end
+      else
+        if field == :normal
+          index_map.each { |ind, i|
+            n = Normal::new
+            n2 = v_g.get_vertex_field(:normal, ind)
+            n.x = n2.x
+            n.y = n2.y
+            n.z = n2.z
+            wmb1.set_vertex_field(field, i, n)
+          }
+        else
+          index_map.each { |ind, i|
+            wmb1.set_vertex_field(field, i, v_g.get_vertex_field(field, ind))
+          }
+        end
+      end
+    }
+
+    index_map = index_map.to_h
+
+    batch_info = batch_infos_map[batch_index]
+    mesh = new_meshes[batch_info.mesh_index]
+
+    b.header.material_id = batch_info.material_index + wmb1.header.num_materials
+    b.header.mesh_id = mesh.header.id
+    b.header.num_indices = indices.length
+    b.indices = indices.collect { |ind| index_map[ind] }
+    b.recompute_from_absolute_indices
+    b.bone_refs = b_s.bone_indices.collect { |bi| bone_mapping[wmb2.bone_map[bi]] }
+    b.num_bone_ref = b.bone_refs.length
+
+    mesh.batches.push b
+    mesh.header.num_batch += 1
+  }
+
+  wmb1.meshes += new_meshes
+  wmb1.header.num_meshes += new_meshes.length
+
+end
+
+def merge_materials(wmb1, wmb2, tex_map)
+  new_mat_offset = wmb1.header.num_materials
+  mat_offset = wmb1.materials_offsets.last + wmb1.materials.last.__size
+  new_materials_offsets = []
+  new_materials = []
+
+  wmb2.materials.each_with_index { |e, i|
+    #biggest known material( in fact biggset is 0x174)
+    new_materials_offsets.push(mat_offset + i*0x124)
+    m = WMBFile::Material::new
+    m.type = 0x0
+    m.flag = 0x0
+    m.material_data = [0x0]*(0x120/4)
+    albedo = e.textures.find { |t| t.name.match("g_AlbedoMap") }
+    normal = e.textures.find { |t| t.name.match("g_NormalMap") }
+    m.material_data[0] = (albedo ? tex_map[albedo.texture_id] : 0x80000000)
+    m.material_data[1] = (normal ? tex_map[normal.texture_id] : 0x80000000)
+    m.material_data[0] = (m.material_data[0] ? m.material_data[0] : 0x80000000)
+    m.material_data[1] = (m.material_data[1] ? m.material_data[1] : 0x80000000)
+    new_materials.push(m)
+  }
+
+  wmb1.header.num_materials += wmb2.header.info_materials.number
+  wmb1.materials += new_materials
+  wmb1.materials_offsets += new_materials_offsets
+end
+
+$options = {}
+
+OptionParser.new do |opts|
+  opts.banner = "Usage: wmb_import_geometry_wiiu_pc.rb target_file source_file [options]"
+
+  opts.on("-bFILE", "--bone-map=FILE", "Bone map") do |bone_map|
+    $options[:bone_map] = bone_map
+  end
+
+  opts.on("-u", "--update-bones", "Update recognized bone positions") do |update_bones|
+    $options[:update_bones] = update_bones
+  end
+
+  opts.on("-t", "--[no-]import-textures", "Import textures also") do |import_textures|
+    $options[:import_textures] = import_textures
+  end
+
+  opts.on("-o", "--[no-]overwrite", "Overwrite destination files") do |overwrite|
+    $options[:overwrite] = overwrite
+  end
+
+  opts.on("-f", "--filter-bones=REJECT_LIST", "Don't import all bones") do |filter_bones|
+     $options[:filter_bones] = eval(filter_bones)
+  end
+
+  opts.on("-h", "--help", "Prints this help") do
+    puts opts
+    exit
+  end
+
+end.parse!
+
+input_file1 = ARGV[0]
+input_file2 = ARGV[1]
+
+raise "Invalid file #{input_file1}" unless File::file?(input_file1)
+raise "Invalid file #{input_file2}" unless File::file?(input_file2)
+
+Dir.mkdir("wmb_output") unless Dir.exist?("wmb_output")
+
+wmb1 = WMBFile::load(input_file1)
+wmb2 = WMBFile::load(input_file2)
+
+tex_map = {}
+
+if $options[:import_textures]
+  tex1_file_name = input_file1.gsub(/wmb\z/,"wtb")
+  tex1 = WTBFile::new(File::new(tex1_file_name, "rb"))
+  begin
+    tex2_file_name = input_file2.gsub(/wmb\z/,"wta")
+    tex2 = WTBFile::new(File::new(tex2_file_name, "rb"), true, File::new(input_file2.gsub(/wmb\z/,"wtp"), "rb"))
+  rescue
+    tex2_file_name = input_file2.gsub(/wmb\z/,"wtb")
+    tex2 = WTBFile::new(File::new(tex2_file_name, "rb"))
+  end
+
+  tex_map = get_texture_map(tex1, tex2)
+end
+
+common_mapping, bone_mapping = merge_bones(wmb1, wmb2)
+
+merge_geometry(wmb1, wmb2, bone_mapping)
+
+merge_materials(wmb1, wmb2, tex_map)
+
+wmb1.recompute_relative_positions
+wmb1.recompute_layout
+
+File::open(File.join("wmb_output", "#{File::basename(input_file2,".wmb")}_#{File::basename(input_file1,".wmb")}_bone_map.yaml"), "w") { |f|
+  f.write YAML::dump(common_mapping)
+}
+
+if $options[:overwrite]
+  wmb1.dump(input_file1)
+else
+  wmb1.dump(File.join("wmb_output", File.basename(input_file1)))
+end
+
+if $options[:import_textures]
+  `ruby #{Shellwords.escape File.join(__dir__,"wtb_import_textures.rb")} #{Shellwords.escape tex1_file_name} #{Shellwords.escape tex2_file_name}#{$options[:overwrite] ? " --overwrite" : ""}`
+end

data/lib/bayonetta/tools/wtb_convert_wiiu_pc.rb

@@ -0,0 +1,95 @@
+require 'optparse'
+require_relative '../../bayonetta'
+require 'shellwords'
+include Bayonetta
+
+# https://stackoverflow.com/a/5471032
+def which(cmd)
+  ENV['PATH'].split(File::PATH_SEPARATOR).each do |path|
+    exe = File.join(path, cmd)
+    return exe if File.executable?(exe) && !File.directory?(exe)
+  end
+  nil
+end
+
+$options = {
+  output: nil
+}
+
+OptionParser.new do |opts|
+  opts.banner = <<EOF
+Usage: wtb_convert_wiiu_pc target_file
+EOF
+  opts.on("-h", "--help", "Prints this help") do
+    puts opts
+    exit
+  end
+
+  opts.on("-o", "--output=filename", "file to output result") do |name|
+    $options[:output] = name
+  end
+
+end.parse!
+
+input_file = ARGV[0]
+
+raise "Invalid file #{input_file}" unless input_file && File::file?(input_file)
+
+if File.extname(input_file) == ".wta"
+  fl = WTBFile::new(File::new(input_file, "rb"), true, File::new(input_file.gsub(/wta\z/,"wtp"), "rb"))
+else
+  fl = WTBFile::new(File::new(input_file, "rb"))
+end
+Dir.mkdir("tex_output") unless Dir.exist?("tex_output")
+prefix = File.join("tex_output", File.basename(input_file, ".wtb"))
+texs = fl.each.each_with_index.collect { |info_f, i|
+  info, f = info_f
+  ext, flags, idx = info
+  tex_name = "#{prefix}_#{"%03d"%i}#{ext}"
+  File::open(tex_name, "wb") { |f2|
+    f.rewind
+    f2.write(f.read)
+  }
+  [tex_name, [flags, idx]]
+}
+
+tex_conv_path = which("TexConv2.exe")
+if !tex_conv_path
+  tex_conv_path = File.join(".", "TexConv2.exe")
+  if (!File.exist?(tex_conv_path))
+    tex_conv_path = File.join(File.expand_path(File.join(File.dirname(__FILE__), *[".."]*3)), "TexConv2.exe")
+    if (!File.exist?(tex_conv_path))
+      tex_conv_path = nil
+    end
+  end
+end
+
+fl2 = WTBFile::new
+fl2.unknown = fl.unknown
+
+texs.each { |name, info|
+  flags, idx = info
+  if File.extname(input_file) == ".wta"
+    flags &= 0xffffffdf #remove 0x20 flag
+    if flags == 0x70000000
+      flags = 0x10000000
+    else
+      flags = 0x20000000
+    end
+  else
+    flags &= 0xfffffffd #remove 0x2 flag
+  end
+  new_name = name.gsub("gtx","dds")
+  raise "could not locate TexConv2.exe, put it in your PATH" unless tex_conv_path
+  res = `#{Shellwords.escape tex_conv_path} -i #{Shellwords.escape name} -o #{Shellwords.escape new_name}`
+  raise "could not execute TexConv2.exe:\n#{res}" if !$?.success?
+  fl2.push( File::new(new_name, "rb"), flags, idx )
+}
+
+output_file = $options[:output]
+if !output_file
+  Dir.mkdir("wtb_output") unless Dir.exist?("wtb_output")
+  output_file = File.join("wtb_output", "#{File.basename(input_file.gsub(/wta\z/,"wtb"))}")
+end
+fl2.dump(output_file)
+

data/lib/bayonetta/tools/wtb_import_textures.rb

@@ -0,0 +1,103 @@
+require 'optparse'
+require_relative '../../bayonetta.rb'
+require 'shellwords'
+include Bayonetta
+
+# https://stackoverflow.com/a/5471032
+def which(cmd)
+  ENV['PATH'].split(File::PATH_SEPARATOR).each do |path|
+    exe = File.join(path, cmd)
+    return exe if File.executable?(exe) && !File.directory?(exe)
+  end
+  nil
+end
+
+$options = {}
+
+OptionParser.new do |opts|
+  opts.banner = "Usage: wtb_import_textures.rb target_file source_file [options]"
+
+  opts.on("-o", "--[no-]overwrite", "Overwrite destination file") do |overwrite|
+    $options[:overwrite] = overwrite
+  end
+
+  opts.on("-h", "--help", "Prints this help") do
+    puts opts
+    exit
+  end
+
+end.parse!
+
+input_file1 = ARGV[0]
+input_file2 = ARGV[1]
+raise "Invalid file #{input_file1}" unless File::file?(input_file1)
+fl0 = WTBFile::new(File::new(input_file1, "rb"))
+
+
+raise "Invalid file #{input_file2}" unless File::file?(input_file2)
+if File.extname(input_file2) == ".wta"
+  fl = WTBFile::new(File::new(input_file2, "rb"), true, File::new(input_file2.gsub(/wta\z/,"wtp"), "rb"))
+else
+  fl = WTBFile::new(File::new(input_file2, "rb"))
+end
+Dir.mkdir("tex_output") unless Dir.exist?("tex_output")
+prefix = File.join("tex_output", File.basename(input_file2, ".wtb"))
+texs = fl.each.each_with_index.collect { |info_f, i|
+  info, f = info_f
+  ext, flags, idx = info
+  tex_name = "#{prefix}_#{"%03d"%i}#{ext}"
+  File::open(tex_name, "wb") { |f2|
+    f.rewind
+    f2.write(f.read)
+  }
+  [tex_name, [flags, idx]]
+}
+
+tex_conv_path = which("TexConv2.exe")
+if !tex_conv_path
+  tex_conv_path = File.join(".", "TexConv2.exe")
+  if (!File.exist?(tex_conv_path))
+    tex_conv_path = File.join(File.expand_path(File.join(File.dirname(__FILE__), *[".."]*3)), "TexConv2.exe")
+    if (!File.exist?(tex_conv_path))
+      tex_conv_path = nil
+    end
+  end
+end
+
+fl2 = WTBFile::new
+fl2.unknown = fl.unknown
+
+fl0.each { |info, f|
+  ext, flags, idx = info
+  fl2.push( f, flags, idx )
+}
+
+texs.each { |name, info|
+  flags, idx = info
+  if File.extname(input_file2) == ".wta"
+    flags &= 0xffffffdf #remove 0x20 flag
+    if flags == 0x70000000
+      flags = 0x10000000
+    else
+      flags = 0x20000000
+    end
+  elsif fl.big
+    flags &= 0xfffffffd #remove 0x2 flag
+  end
+  if File.extname(name) == ".gtx"
+    new_name = name.gsub("gtx","dds")
+    raise "could not locate TexConv2.exe, put it in your PATH" unless tex_conv_path
+    res = `#{Shellwords.escape tex_conv_path} -i #{Shellwords.escape name} -o #{Shellwords.escape new_name}`
+    raise "could not execute TexConv2.exe:\n#{res}" if !$?.success?
+  else
+    new_name = name
+  end
+  fl2.push( File::new(new_name, "rb"), flags, nil )
+}
+
+if $options[:overwrite]
+  fl2.dump(input_file1)
+else
+  Dir.mkdir("wtb_output") unless Dir.exist?("wtb_output")
+  fl2.dump(File.join("wtb_output", File.basename(input_file1)))
+end

data/lib/bayonetta/tools/wtx_creator.rb

@@ -0,0 +1,69 @@
+require 'optparse'
+require 'yaml'
+require_relative '../../bayonetta'
+include Bayonetta
+
+$options = {
+  output: nil
+}
+OptionParser.new do |opts|
+  opts.banner = <<EOF
+Usage: wtx_creator target_directory
+EOF
+  opts.on("-h", "--help", "Prints this help") do
+    puts opts
+    exit
+  end
+
+  opts.on("-o", "--output=filename", "file to output result") do |name|
+    $options[:output] = name
+  end
+
+end.parse!
+
+input_dir = ARGV[0]
+
+raise "Not a directory: #{input_dir}!" unless input_dir && File.directory?(input_dir)
+
+files  = Dir.entries(input_dir)
+pwd = Dir.pwd
+Dir.chdir(input_dir)
+files.select! { |f| File.file?(f) && [".gtx", ".dds", ".bntx", ".xt1"].include?( File.extname(f) ) }
+files.sort!
+puts files
+files.collect! { |fname| File::new(fname, "rb") }
+
+big = false
+big = YAML::load_file(".metadata/big.yaml") if File.exist?(".metadata/big.yaml")
+extension = ".wtb"
+extension = YAML::load_file(".metadata/extension.yaml") if File.exist?(".metadata/extension.yaml")
+flags = []
+flags = YAML::load_file(".metadata/texture_flags.yaml") if File.exist?(".metadata/texture_flags.yaml")
+idx = []
+idx = YAML::load_file(".metadata/texture_idx.yaml") if File.exist?(".metadata/texture_idx.yaml")
+infos = []
+infos = YAML::load_file(".metadata/texture_infos.yaml") if File.exist?(".metadata/texture_infos.yaml")
+unknown = 0
+unknown = YAML::load_file(".metadata/unknown.yaml") if File.exist?(".metadata/unknown.yaml")
+
+
+wtb = WTBFile::new(nil, big, extension == ".wta")
+files.each { |f|
+  wtb.push(f)
+}
+wtb.texture_flags = flags
+wtb.texture_infos = infos
+wtb.texture_idx   = idx
+wtb.unknown       = unknown
+
+output_file = $options[:output]
+if !output_file
+  Dir.mkdir("wtx_output") unless Dir.exist?("wtx_output")
+  Dir.chdir("wtx_output")
+  output_file = File.basename(ARGV[0]).gsub("_wta","").gsub("_wtb", "") << extension
+else
+  Dir.chdir(pwd)
+end
+
+wtb.dump(output_file)
+

data/lib/bayonetta/tools/wtx_extractor.rb

@@ -0,0 +1,85 @@
+require 'optparse'
+require 'yaml'
+require_relative '../../bayonetta'
+
+$options = {
+  output: nil
+}
+
+OptionParser.new do |opts|
+  opts.banner = <<EOF
+Usage: wtx_extractor file [wtp_file]
+EOF
+  opts.on("-h", "--help", "Prints this help") do
+    puts opts
+    exit
+  end
+
+  opts.on("-o", "--output=dirname", "directory to output result") do |name|
+    $options[:output] = name
+  end
+
+end.parse!
+
+save_pwd = Dir.pwd
+
+filename = ARGV[0]
+raise "Invalid file: #{filename}!" unless filename && File.exist?(filename)
+wtp_name = ARGV[1]
+raise "Invalid file: #{filename}!" if wtp_name && !File.exist?(wtp_name)
+
+directory = File.dirname(filename)
+name = File.basename(filename)
+ext_name = File.extname(name)
+
+raise "Invalid file: #{filename}!" unless ext_name == ".wta" ||  ext_name == ".wtb"
+
+f = File::open(filename, "rb")
+
+Dir.chdir(directory)
+tex_name = File.basename(name, ext_name)
+if ext_name == ".wta"
+  wtp_name = tex_name + ".wtp" unless wtp_name
+  f_wtp = File::open(wtp_name, "rb")
+  dir_name = tex_name + "_wta"
+else
+  f_wtp = nil
+  dir_name = tex_name + "_wtb"
+end
+if $options[:output]
+  Dir.chdir(save_pwd)
+  Dir.chdir($options[:output])
+end
+Dir.mkdir(dir_name) unless Dir.exist?(dir_name)
+Dir.chdir(dir_name)
+
+wtb =  Bayonetta::WTBFile::new(f, true, f_wtp)
+
+wtb.each.each_with_index { |info_f, i|
+  info, f = info_f
+  ext, _, _ = info
+  File::open("#{tex_name}_#{"%03d"%i}#{ext}", "wb") { |f2|
+    f.rewind
+    f2.write(f.read)
+  }
+}
+Dir.mkdir(".metadata") unless Dir.exist?(".metadata")
+Dir.chdir(".metadata")
+File::open("texture_flags.yaml", "w") { |fl|
+  fl.print YAML::dump( wtb.texture_flags )
+}
+File::open("texture_idx.yaml", "w") { |fl|
+  fl.print YAML::dump( wtb.texture_idx )
+}
+File::open("texture_infos.yaml", "w") { |fl|
+  fl.print YAML::dump( wtb.texture_infos )
+}
+File::open("big.yaml","w") { |fl|
+  fl.print YAML::dump( wtb.big )
+}
+File::open("unknown.yaml","w") { |fl|
+  fl.print YAML::dump( wtb.unknown )
+}
+File::open("extension.yaml", "w") { |fl|
+  fl.print YAML::dump( ext_name )
+}